Come rilevare Adblock sul mio sito web?

https://stackoverflow.com/questions/4869154

28-10-2019
|

Domanda

Vorrei essere in grado di rilevare se l'utente utilizza il software adblock quando visitano il mio sito Web. Se lo stanno usando, voglio visualizzare un messaggio che chiede loro di spegnerlo per supportare il progetto, come questo sito web fa.

Se si entra in quel sito e il tuo browser ha una sorta di software AdBlock abilitato, il sito invece di mostrare gli annunci reali mostra un piccolo banner che dice agli utenti che le entrate pubblicita .

Voglio farlo sul mio sito Web, sto usando annunci AdSense su di esso, come posso farlo?

Soluzione

La mia soluzione non è specifica per una determinata rete pubblicitaria ed è molto leggera. L'ho gestito in produzione per alcuni anni. Adblock blocca tutti gli URL contenenti la parola "annunci". Quindi questo è quello che ho fatto:

Ho aggiunto un piccolo file JS al mio Webroot con il nome ads.js

Questa è l'unica riga di codice in quel file

var canRunAds = true;

Quindi da qualche parte nella mia pagina:

<html>
  <head>
    <script src="/js/ads.js"></script>
  </head>
  <body>
    <script>
      if( window.canRunAds === undefined ){
        // adblocker detected, show fallback
        showFallbackImage();
      }
    </script>
  </body>
</html>

File come ADS.JS sono bloccati da almeno questi annunci su Chrome:

Adblock
Adblock Plus
Adblock Pro
Ghostery

Aggiornamento il 2019-02-15:

Aggiunto Ghostery nell'elenco sopra perché l'estensione ora blocca anche le richieste ad ADS.JS. Molto maneggevole. Questo significa che Ghostery sta effettivamente aiutando gli sviluppatori a rilevare il blocco degli annunci con la loro estensione?

Non funziona con:

Badger privacy

Altri suggerimenti

Non è una risposta diretta, ma mettevo il messaggio dietro l'annuncio per essere caricato ... piuttosto che il tentativo di rilevarlo, si presenterebbe solo quando l'annuncio non lo fa.

http://thepcspy.com/read/how_to_block_adblock/

Con jQuery:

function blockAdblockUser() {
    if ($('.myTestAd').height() == 0) {
        window.location = 'http://example.com/AdblockNotice.html';
    }
}

$(document).ready(function(){
    blockAdblockUser();
});

Naturalmente, dovresti avere una pagina di destinazione per adblocknotice.html e la classe .mytestad deve riflettere i tuoi contenitori di annunci reali. Ma questo dovrebbe funzionare.

MODIFICARE

Come consiglia TD_NIJBOER, un modo migliore è usare il :hidden (o :visible, come uso sotto) selettore in modo che display: none è anche controllato:

function blockAdblockUser() {
    if ($('.myTestAd').filter(':visible').length == 0) {
        // All are hidden, or "not visible", so:
        // Redirect, show dialog, do something...
    } else if ($('.myTestAd').filter(':hidden').length > 0) {
        // Maybe a different error if only some are hidden?
        // Redirect, show dialog, do something...
    }
}

Certo, entrambi potrebbero essere combinati in uno if Blocca se lo si desidera.

Notare che visibility: hidden Non verrà catturato neanche da nemmeno da (dove rimane lo spazio di layout, ma l'annuncio non è visibile). Per verificarlo, è possibile utilizzare un altro filtro:

$('.myTestAd').filter(function fi(){
    return $(this).css('visibility') == 'hidden';
})

Che ti darà una serie di elementi pubblicitari che sono "invisibili" (con qualsiasi essere maggiore di 0 essere un problema, in teoria).

Nessuna richiesta extra. Nessuna libreria esterna. Semplicemente, semplice, semplice javascript:

var adBlockEnabled = false;
var testAd = document.createElement('div');
testAd.innerHTML = '&nbsp;';
testAd.className = 'adsbox';
document.body.appendChild(testAd);
window.setTimeout(function() {
  if (testAd.offsetHeight === 0) {
    adBlockEnabled = true;
  }
  testAd.remove();
  console.log('AdBlock Enabled? ', adBlockEnabled)
}, 100);

Si crea un elemento con la classe Adsbox (definito come elemento rimovibile nel file di definizione di Adblock Plus)
Lo aggiungi al documento e dopo un breve periodo leggi la sua parte
Se Adblock è installato, l'elemento non avrà alcuna altezza.

Credito a Il post di Christian Heilmann, Penso che sia di gran lunga la migliore soluzione per rilevare Adblock.

La maggior parte degli annunci sono caricati dinamicamente in JavaScript. Ho appena usato l'evento ONERROR per rilevare se lo script di annunci poteva essere caricato o meno. Sembra funzionare.

Esempio con Googleads:

<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js" onerror="adBlockFunction();"></script>

Questo può essere utilizzato anche su altri elementi per vedere se un blocco degli annunci sta bloccando il contenuto. Questo metodo può produrre falsi positivi se gli elementi remoti non esistono o non possono essere raggiunti.

Per rilevare se l'utente sta bloccando gli annunci, tutto ciò che devi fare è trovare una funzione nell'annuncio JavaScript e provare a testare. Non importa quale metodo stanno usando per bloccare l'annuncio. Ecco come appare per gli annunci di Google AdSense:

if(!window.hasOwnProperty('google_render_ad') || window.google_render_ad === undefined) { 
    //They're blocking ads, display your banner
}

Questo metodo è delineato qui: http://www.metamorphosite.com/detect-web-popup-blocker-software-adblock-spam

La mia soluzione più semplice con jQuery è:

$.ajax({
    url: "/scripts/advertisement.js", // this is just an empty js file
    dataType: "script"
}).fail(function () {
    // redirect or display message here
});

Pubblicità.js non contiene solo nulla. Quando qualcuno usa AdBlock, fallisce e la funzione viene chiamata.

So che ci sono già abbastanza risposte, ma dal momento che questa domanda viene pubblicata su Google ha cercato "Rileva Adblock" sull'argomento, volevo fornire alcune intuizioni nel caso in cui tu sia non usando Adsense.

In particolare, con questo esempio è possibile rilevare se viene utilizzata l'elenco di annunci predefinito fornito da Firefox Adblock. Approfitta che in questa lista di blocco c'è un elemento bloccato con l'ID CSS #bottomAd. Se includo un elemento del genere nella pagina e test per la sua altezza, so se l'adblocking è attivo o no:

<!-- some code before -->
<div id="bottomAd" style="font-size: 2px;">&nbsp;</div>
<!-- some code after -->

Il resto viene eseguito tramite il solito sospetto di jQuery:

$(document).ready( function() {
  window.setTimeout( function() {
    var bottomad = $('#bottomAd');
    if (bottomad.length == 1) {
      if (bottomad.height() == 0) {
        // adblocker active
      } else {
        // no adblocker
      }
    }      
  }, 1);
}

Come si può vedere, sto usando setTimeout con almeno un timeout di 1ms. L'ho provato su vari browser e la maggior parte delle volte, controllando direttamente l'elemento in ready restituito sempre 0; Non importa se l'Adblocker fosse attivo o meno. Stavo avendo due idee su questo: o rendering non era ancora finito o Adblock non è ancora entrato. Non mi sono preoccupato di indagare ulteriormente.

Il mio consiglio è: non farlo!

Qualsiasi scenario in cui tratti le persone come "trasgressori" si tradurrà in loro combattere.

Ecco la mia proposta.

Metti un piccolo messaggio discreto nella parte superiore della pagina (indipendentemente dal fatto che gli annunci vengano bloccati) con il testo I *totally* respect your right to block ads e un link a un'altra pagina/pop-up intitolato Read more ....

Dall'altra pagina, chiarisci che capisci che è il loro computer e sono liberi di utilizzare il blocco degli annunci.

Anche chiarire in modo non accusativo Che l'uso di questi bloccanti rende più difficile fornire grandi contenuti (spiegando perché in dettaglio) e quello, mentre preferiresti che il blocco degli annunci non accada sul tuo sito, è totalmente la loro decisione. Concentrati sugli aspetti positivi di disattivare il blocco.

Coloro che si opponeranno con veemenza alle pubblicità ignoreranno questo, ma non hai mai avuto la possibilità di convincerli comunque. Coloro che sono indifferenti possono essere influenzati dal tuo appello dal momento che non stai facendo il tutto "lasciami andare a modo mio o prenderò la mia palla e tornerò a casa" che onestamente dovrebbe essere il dominio esclusivo dei bambini di cinque anni.

Ricorda, nessuno ti ha tenuto una pistola in testa e ti ha costretto a mettere le tue cose in rete. Tratta i tuoi lettori/utenti con rispetto e probabilmente ne troverai un buon numero.

Stanno utilizzando il fatto che il codice pubblicitario di Google crea un iFrame con l'ID "iFrame". Quindi, finché non hai già qualcosa sulla tua pagina con quell'ID, questo funzionerebbe anche per te.

<p id="ads">
<script type="text/javascript"><!--
google_ad_client = "their-ad-code-here";
/* 160x600, droite */
google_ad_slot = "their-ad-code-here";
google_ad_width = 160;
google_ad_height = 600;
//-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
</script>

</p>

<script type="text/javascript"><!--
if(document.getElementsByTagName("iframe").item(0) == null)
{
    document.write("<div style='width:160px; height:600px; padding-top: 280px; margin-left:5px;border:1px solid #000000; text-align:center; font-family:century gothic, arial, helvetica, sans serif;padding-left:5px;padding-right:5px;'>Advertising seems to be blocked by your browser.<br /><br /><span style='font-size:10px'>Please notice that advertising helps us to host the project.<br /><br />If you find these ads intrusive or inappropriate, please contact me.</span><img src='http://www.playonlinux.com/images/abp.jpg' alt='Adblock Plus' /></div>");
}
--></script>

Ho notato che i commenti precedenti utilizzano Google Adsense come oggetto per testare. Alcune pagine non usano AdSense e usare AdSense Block come test non è davvero una buona idea. Perché AdSense Block potrebbe danneggiare il tuo SEO. Ecco l'esempio di come rilevo da Adblocker Simple Blockd Class:

Html:

<div class="ad-placement" id="ablockercheck"></div>
<div id="ablockermsg" style="display: none"></div>

JQuery:

$(document).ready(function()
{
   if(!$("#ablockercheck").is(":visible"))
   {
     $("#ablockermsg").text("Please disable adblocker.").show();
   }
});

"AblockerCheck" è un ID che Blocks Blocks. Quindi controllandolo se è visibile, puoi rilevare se l'adblocker è acceso.

Basta aggiungere un piccolo script sul tuo sito:

var isAdsDisplayed = true;

Con nome adsbygoogle.js

Quindi seguire:

<script src="/js/adsbygoogle.js"></script>
<script>
if(window.isAdsDisplayed === undefined ) {
  // AdBlock is enabled. Show message or track custom data here
}
</script>

Ho trovato questa soluzione qui

Adblock sembra bloccare il caricamento dei file JavaScript di Adsense (ecc.). Quindi, se stai usando una versione asincrona degli annunci adsense puoi verificare se adsbygoogle è un Array. Questo deve essere controllato dopo pochi secondi poiché la sceneggiatura asincrona è ... asincrona. Ecco un contorno ruvido:

window.setTimeout(function(){
    if(adsbygoogle instanceof Array) {
        // adsbygoogle.js did not execute; probably blocked by an ad blocker
    } else {
        // adsbygoogle.js executed
    }
}, 2000);

Per chiarire, ecco un esempio di come appare il codice degli annunci asincroni AdSense:

<!-- this can go anywhere -->
<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>

<!-- this is where the ads display -->
<ins class="adsbygoogle" ...></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

Notare che adsbygoogle è inizializzato come array. Il adsbygoogle.js La libreria cambia questo array in Object {push: ...} quando esegue. Controllare il tipo di variabile dopo un determinato tempo può dirti se lo script è stato caricato.

Questo approccio che uso sul mio sito, forse lo troverai utile. Secondo me, è il più semplice soluzione.

Adblocker blocca le classi specifiche ed elementi HTML, ispezionando questi selettori di qualsiasi annuncio bloccato nella console per sviluppatori (sono tutti elencati) puoi vedere quali elementi saranno sempre bloccati.

Ad esempio, ispeziona questa pagina di domanda su StackOverflow e vedrai un sacco di annunci bloccati.

Ad esempio, qualsiasi elemento con bottom-ad La classe viene bloccata automaticamente.

Ho creato un elemento div non vuoto con bottom-ad classe:<div class="bottom-ad" style="width: 1px; height: 1px;">HI</div>
Dopo il caricamento della pagina basta verificare se questo elemento è nascosto. Ho usato jQuery, ma mi sento libero di usare JavaScript:$('.bottom-ad').css('display') == "none" o anche meglio usando $('.bottom-ad').is(':visible')

Se il valore è true, quindi Adblocker è attivo.

Non hai bisogno di una richiesta HTTP extra, puoi semplicemente calcolare l'altezza di un falso aggiunta.

A proposito, ecco un lista completa Abbinamento degli elementi che gli annunci evitano il rendering.

window.adBlockRunning = function() {
    return (getComputedStyle(document.getElementById("detect"))["display"] == "none") ? true : false;
  }()

console.log(window.adBlockRunning);

#detect {
  height: 1px;
  width: 1px;
  position: absolute;
  left: -999em;
  top: -999em
}

<div id="detect" class="ads ad adsbox doubleclick ad-placement carbon-ads"></div>

Il modo sicuro è quello di avvolgere i tuoi annunci all'interno <div> e controlla l'altezza

<div id="check-ab">
/* your ads code */
</div>

setTimeout(function(){
  if(document.getElementById("check-ab").offsetHeight === 0){
    console.log("ads blocked");
  }
  else{
    console.log("ads running");
  }
}, 100);

Funziona con Adblock Plus e BlueHell Firewall.

Un modo efficiente per verificare se esiste un annuncio: controllare semplicemente se è abilitato ADBLOCK cercando di attivare l'URL degli annunci di Google. Se sì, esegui il callback_has_adblock, in caso contrario, eseguire il callback_no_adblock. Questa soluzione costa una richiesta di più ma almeno funziona:

var hasAdBlock = function (callback_has_adblock, callback_no_adblock) {

    $.getScript( "http://pagead2.googlesyndication.com/pagead/show_ads.js" )
        .done(function( script, textStatus ) {
            callback_no_adblock();
        })
        .fail(function( jqxhr, settings, exception ) {
            callback_has_adblock();
    });
};

Questa soluzione funziona per tutti i tipi di annunci, non solo Google Adsense.

Se si utilizza il nuovo codice Adsense, è possibile effettuare un controllo facile, senza ricorrere ai controlli di contenuto o CSS.

Posiziona i tuoi annunci normali nel tuo markup:

<ins class="adsbygoogle" style="display: block;"
   data-ad-client="ca-pub-######"
   data-ad-slot="#######"
   data-ad-format="auto"></ins>
<script>(adsbygoogle = window.adsbygoogle || []).push({});</script>

Quindi chiami il codice Adsense al parte inferiore della tua pagina (nota non utilizzare il "async" bandiera quando si chiama il adsbygoogle.js script):

<script src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>

Quindi aggiungi questo piccolo frammento di codice sotto quello:

<script>
if (!adsbygoogle.loaded) {
   // do something to alert the user
}
</script>

AdSense crea sempre/imposta la flag adsbygoogle.loaded a true Quando gli annunci vengono caricati, è possibile inserire il check -out di una funzione setTimeout per ritardare il controllo di alcuni secondi.

Nonostante l'età di questa domanda, recentemente l'ho trovato molto utile e quindi posso solo supporre che ci siano altri che lo vedono ancora. Dopo aver guardato qui e altrove ho ipotizzato che i principali controlli laterali del client per rilevare indirettamente un bloccante di annunci dovevano verificare il bloccato div/img, bloccato iframeS e risorse bloccate (file JavaScript).

Forse è sopra la parte superiore o paranoica, ma copre i sistemi di blocco degli annunci che bloccano solo uno o due della selezione e quindi potrebbero non essere stati coperti se avessi fatto solo un controllo.

Nella pagina stai eseguendo i controlli aggiungi: (Sto usando jQuery)

<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="advertisement.js"></script>
<script type="text/javascript" src="abds.js"></script>

E aggiungi quanto segue in qualsiasi altra parte della pagina:

<div id="myTestAd"><img src="http://placehold.it/300x250/000000/ffffff.png&text=Advert" /></div>

Ho usato un div con un nome esca e un'immagine ospitata esternamente con il testo "pubblicità" e nelle dimensioni utilizzate da Adsense (grazie a Placehold.it!).

In advertisement.js Dovresti aggiungere qualcosa al documento che possiamo verificare in seguito. Anche se sembra che tu stia facendo lo stesso di prima, stai effettivamente controllando il file (advertisement.js) stesso viene caricato, non l'output.

$(document).ready(
{

    $("body").append("<div id=\"myTestAd2\">check</div>");

});

E poi lo script di rilevamento del blocco degli annunci che combina tutto

$(document).ready(function()
{
    var ifr = '<iframe id="adServer" src="http://ads.google.com/adserver/adlogger_tracker.php" width="300" height="300"></iframe>';
    $("body").append(ifr);
});

$(window).on("load",function()
{

    var atb = $("#myTestAd");
    var atb2= $("#myTestAd2");
    var ifr = $("#adServer");

    setTimeout(function()
    {

        if( (atb.height()==0) ||
            (atb.filter(":visible").length==0) ||
            (atb.filter(":hidden").length>0) ||
            (atb.is("hidden")) ||
            (atb.css("visibility")=="hidden") ||
            (atb.css("display")=="none") ||
            (atb2.html()!="check") ||
            (ifr.height()!=300) ||
            (ifr.width()!=300) )
        {
            alert("You're using ad blocker you normal person, you!");
        }

    },500);

});

Quando il documento è pronto, cioè il markup viene caricato, aggiungiamo anche l'iframe al documento. Quindi, quando la finestra è caricato, cioè il contenuto incl. Le immagini ecc. vengono caricate, controlliamo:

Le dimensioni e la visibilità del primo test di test.
Che il contenuto del secondo test di test è "controllo", come sarebbe stato se il advertimsent.js era non bloccato.
Le dimensioni (e immagino visibilità, come oggetto nascosto non ha altezza o larghezza?) Dell'IFRAME

E gli stili:

div#myTestAd, iframe#adServer
{
    display: block;
    position: absolute;
    left: -9999px;
    top: -9999px;
}

div#myTestAd2
{
    display: none;
}

Spero che sia di aiuto

La maggior parte degli adblocker annulla la richiesta HTTP a ads.js e fare 0px per l'elemento ma a volte Adblocker rimosso il DOM, e alcune risposte sopra falliranno perché non verificare l'esistenza dell'elemento.

Usando setTimeout() è una buona pratica perché senza di essa, farà la gara della sceneggiatura con Adblocker.

Lo script seguente verificherà se DOM esiste/rimosso e controllerà offsetHeight di un elemento se esiste.

setTimeout(function() {
  var a = document.querySelector('.showads'),
    b = a ? (a.offsetHeight ? false : true) : true;
  console.log('ads blocked?', b)
}, 200); // don't too fast or will make the result wrong.

<div class="ads showads">
  Lorem ipsum dolor sit amet, consectetur adipisicing elit.
</div>

So che questo ha già una risposta, ma ho guardato il sito di esempio suggerito e vedo che lo fanno così:

<script type="text/javascript">
if(document.getElementsByTagName("iframe").item(0) == null) {
    document.write("<div style="width: 160px; height: 600px; padding-top: 280px; margin-left: 5px; border: 1px solid #666666; color: #FFF; background-color: #666; text-align:center; font-family: Maven Pro, century gothic, arial, helvetica, sans-serif; padding-left: 5px; padding-right: 5px; border-radius: 7px; font-size: 18px;">Advertising seems to be blocked by your browser.<br><br><span style="font-size: 12px;">Please notice that advertising helps us to host the project.<br><br>If you find these ads intrusive or inappropriate, please contact me.</span><br><img src="http://www.playonlinux.com/images/abp.png" alt="Adblock Plus"></div>");
};
</script>

Non c'è bisogno di timeout e sniffing Dom. Basta tentare di caricare uno script da reti pubblicitarie popolari e vedere se il bloccante di annuncio ha intercettato la richiesta HTTP.

/**
 * Attempt to load a script from a popular ad network. Ad blockers will intercept the HTTP request.
 *
 * @param {string} url
 * @param {Function} cb
 */
function detectAdBlockerAsync(url, cb){
    var script = document.createElement('script');

    script.onerror = function(){
        script.onerror = null;
        document.body.removeChild(script);
        cb();
    }

    script.src = url;
    document.body.appendChild(script);
}

detectAdBlockerAsync('http://ads.pubmatic.com/AdServer/js/gshowad.js', function(){
    document.body.style.background = '#c00';
});

Ho appena creato il mio "plugin" per risolvere questo e funziona davvero bene:

adbuddy + jsbuddy:

Adbuddy Jsbuddy github

Ho aggiunto la compatibilità mobile e il rilevamento di jsblocking tra le altre cose ... (come una sovrapposizione che viene mostrata agli utenti che chiedono loro di disabilitare il bloccanti/jsblocking Software); Lo ha anche reso reattivo amichevole.

È aperto sotto il Licenza Coffeeware.

<script src="http://code.jquery.com/jquery-latest.js"></script>
<script>var adb=true;</script>
<script src="./getbanner.cfm?"></script>
<script>
$(document).ready(function(){if(adb)alert('AdBlock!');});
</script>

e nel file getbanner.cfm:

adb = false;

Penso che sia il modo più semplice per rilevare Adblock.

Questo è ciò che ha funzionato per me:

function isAdBlocked() {
     return (typeof(window.google_jobrunner) === "undefined") ? true : false;
}

$(document).ready(function(){
    if(isAdBlocked()) {
       alert('Y U NO LIKE ADS?');
    }
});

timing's La risposta è bella pensata ma non più funzionante, quindi ho aggiornato il nome del file JS a "Adsense" da "annunci" e sta funzionando come un fascino!

Ecco il codice, forse questo aiuterà qualcuno:

<html>
      <head>
            <script src="/adsense.js"></script>
      </head>
             <body>
                   <script>
                           if( window.adblockDetecter === undefined ){
                           // Do anithing, adblocker detected!
                           alert('Adblocker Detected!');}
                   </script>
            </body>
</html>

Nel file JS metti proprio questa riga: var adblockDetecter = true;

Ora c'è un modo migliore per farlo usando un semplice script JS chiamato Rivelatore Adblock
Ecco come usarlo:
Aggiungi questo al tuo <head> sezione:

<script type="text/javascript">
window.onload = function() {
var iframe = document.createElement('iframe'),
    randomDomain = Math.floor(Math.random() * (10000 - 100 + 1)) + 100,
    iframeLoaded = true;

iframe.src = "http://"+ randomDomain +".com/ads.html";
iframe.height = ".1px";
iframe.width = ".1px";
iframe.id = 'some-ad';
iframe.onload = function() {iframeLoaded = false;};

document.body.appendChild(iframe);

setTimeout(function() { 
    var someAd = document.getElementById('some-ad');
    if(!iframeLoaded ||
       someAd == null || 
       someAd.style.display == "none" || 
       someAd.style.display == "hidden" || 
       someAd.style.visibility == "hidden" || 
       someAd.offsetHeight == 0)
        document.getElementById('ab-message').style.display = 'block';
    someAd.remove();
}, 500);
};
</script>`<br>

Ora puoi usare il ab-message ID ovunque si desideri visualizzare un messaggio agli utenti di Adblock:

<div id="ab-message" style="display: none">Your message here!</div>

Nota lo stile in linea aggiunto per nasconderlo originariamente (ovviamente, puoi anche farlo dal tuo file CSS).
Si noti inoltre che ci vogliono 500 ms, è perché deve aspettare che l'Adblocker faccia le sue cose o non funzionerà.

Una piccola spiegazione di come funziona questa sceneggiatura

Innanzitutto, aggiunge un IFRAME con una fonte di un collegamento generato in modo casuale. (Viene generato in modo casuale perché alcuni annunci sono intelligenti, ad un certo punto, si rendono conto che un link è falso).
Quindi esegue più controlli su quell'IFRAME (se è stato caricato correttamente o se il suo stile è stato modificato). Se uno di questi test è vero, mostra il ab-message Elemento per gli utenti di Adblock.

Questo script funziona per la maggior parte (se non tutti) bloccanti di annunci.

EXTRA

In realtà, in realtà, avrebbe potuto creare un GIST, ma invece ho creato un progetto GitHub, ma comunque, dai un'occhiata e lo star se ti ha aiutato.
Abdetector: Simple Vanilla JavaScript Adblock Detector.
Divertiti.

Puoi verificarlo potrebbe aiutareRilevamento-addblocatore

È un'implementazione di Risposta di tempistica

Aggiungi questo prima di qualsiasi script nel tag principale:

<head>
    <title></title>
    <meta/>

    <!--adBlocker detection code - START-->
    <script src="//adblocker.fortiapp.com/ads.js"></script>
    <script>
        (function (i, o, g, r) {
            i[o] = (typeof i[o] == typeof undefined) ? g : r
        })(window, 'adblocker', true, false);
    </script>
    <!--adBlocker detection code - END-->

    // Other scripts

</head>

Poi in seguito usalo:

if (adblocker) {
    // the add blocker is enabled
}else{
    // ad blocker is not enabled
}

Tutte le risposte sopra sono valide, tuttavia la maggior parte non funzionerà per il blocco degli annunci a livello DNS.

Bloccanti di annunci a livello DNS (come pi-hole) Fondamentalmente restituisce nxdomain (il dominio non esiste) per un elenco di domini di blocco degli annunci (ad esempio telemetria.microsoft.com non "esisterà" quando lo fa).

Ci sono alcuni modi per aggirare questo:

Metodo A.: Richiesta di annunci per indirizzo IP, non dominio.

Questo metodo è un po 'fastidioso in quanto dovresti tenere traccia degli indirizzi IP. Questo sarà problematico se il tuo codice non è ben mantenuto o aggiornato regolarmente.

Metodo b: Blocco tutto Richiede che falliscono, anche se il client riporta NxDomain.

Questo sarà molto fastidioso per gli utenti se si tratta di un nxdomain "legittimo".

Capisco la tua tensione e puoi verificare se l'elemento è stato creato da script o elemento è nascosto. E se parliamo di blocco degli annunci puoi contare solo sulla visibilità dell'elemento, non sulla presenza dell'elemento.

L'elemento creato con script di terze parti non sarà mai presente, che se lo script non è raggiungibile al momento (errore DNS, errore del server Web remoto, precarico della pagina Web offline, ecc.) E diventerai sempre falso positivo.

Tutte le altre risposte con i controlli sono corrette, ma tienilo a mente.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow