Подтвердить что ты не робот

Обнаружение заблокированного всплывающего окна в Chrome

Мне известны методы javascript, чтобы определить, заблокировано ли всплывающее окно в других браузерах (как описано в ответе на этот вопрос). Здесь основной тест:

var newWin = window.open(url);

if(!newWin || newWin.closed || typeof newWin.closed=='undefined')
{
    //POPUP BLOCKED
}

Но это не работает в Chrome. Раздел "POPUP BLOCKED" никогда не достигается, когда всплывающее окно заблокировано.

Конечно, тест работает до такой степени, что Chrome фактически не блокирует всплывающее окно, но открывает его в крошечном свернутом окне в правом нижнем углу, в котором отображаются "заблокированные" всплывающие окна.

Что бы я хотел сделать, так это узнать, заблокировано ли всплывающее окно блокировщиком всплывающих окон Chrome. Я стараюсь избегать обнюхивания браузеров в пользу обнаружения функции. Есть ли способ сделать это без взлома браузера?

Изменить. Я попытался использовать newWin.outerHeight, newWin.left и другие подобные свойства для этого. Google Chrome возвращает все значения позиции и высоты как 0, когда всплывающее окно заблокировано.

К сожалению, он также возвращает те же значения, даже если всплывающее окно фактически открыто в течение неизвестного времени. После некоторого магического периода (пару секунд в моем тестировании) информация о местоположении и размере возвращается как правильные значения. Другими словами, я все еще не ближе к этому. Любая помощь будет оценена.

4b9b3361

ОТВЕТЫ

Ответ 1

Ну, "волшебное время", о котором вы говорите, вероятно, когда загружено всплывающее DOM. Или может быть, когда загружено все (изображения, внешний CSS и т.д.). Вы можете легко протестировать это, добавив в всплывающее окно очень большую графику (сначала очистите свой кеш!). Если вы используете Javascript Framework, например jQuery (или что-то подобное), вы можете использовать событие ready() (или что-то подобное), чтобы дождаться загрузки DOM до проверки смещения окна. Опасность в этом заключается в том, что обнаружение Safari работает конфликтующим образом: всплывающее DOM никогда не будет готово() в Safari, потому что оно даст вам действительный дескриптор для окна, которое вы пытаетесь открыть, - действительно ли оно открывается или не. (на самом деле, я считаю, что ваш всплывающий тестовый код выше не будет работать для сафари.)

Я думаю, что самое лучшее, что вы можете сделать, это обернуть свой тест в setTimeout() и дать всплывающее окно 3-5 секунд для завершения загрузки перед запуском теста. Это не идеально, но он должен работать не менее 95% времени.

Здесь код, который я использую для обнаружения кросс-браузера, без части Chrome.

function _hasPopupBlocker(poppedWindow) {
    var result = false;

    try {
        if (typeof poppedWindow == 'undefined') {
            // Safari with popup blocker... leaves the popup window handle undefined
            result = true;
        }
        else if (poppedWindow && poppedWindow.closed) {
            // This happens if the user opens and closes the client window...
            // Confusing because the handle is still available, but it in a "closed" state.
            // We're not saying that the window is not being blocked, we're just saying
            // that the window has been closed before the test could be run.
            result = false;
        }
        else if (poppedWindow && poppedWindow.test) {
            // This is the actual test. The client window should be fine.
            result = false;
        }
        else {
            // Else we'll assume the window is not OK
            result = true;
        }

    } catch (err) {
        //if (console) {
        //    console.warn("Could not access popup window", err);
        //}
    }

    return result;
}

То, что я делаю, это запустить этот тест у родителя и обернуть его в setTimeout(), предоставив дочернему окну 3-5 секунд для загрузки. В дочернем окне вам нужно добавить тестовую функцию:

function test() {}

Детектор блокировщика всплывающих окон проверяет, существует ли функция "тест" как член дочернего окна.

ДОБАВЛЕНО 15 ИЮНЯ 2015:

Я думаю, что современным способом справиться с этим было бы использовать window.postMessage(), чтобы ребенок уведомил родителя о том, что окно было загружено. Подход аналогичен (дочерний говорит родительскому загруженному), но средства связи улучшились. Мне удалось сделать этот кросс-домен у ребенка:

$(window).load(function() {
  this.opener.postMessage({'loaded': true}, "*");
  this.close();
});

Родитель слушает это сообщение, используя:

$(window).on('message', function(event) {     
  alert(event.originalEvent.data.loaded)
});

Надеюсь, что это поможет.

Ответ 2

Только одно улучшение для Snipet InvisibleBacon (протестировано в IE9, Safari 5, Chrome 9 и FF 3.6):

var myPopup = window.open("popupcheck.htm", "", "directories=no,height=150,width=150,menubar=no,resizable=no,scrollbars=no,status=no,titlebar=no,top=0,location=no");
if (!myPopup)
    alert("failed for most browsers");
else {
    myPopup.onload = function() {
        setTimeout(function() {
            if (myPopup.screenX === 0) {
                alert("failed for chrome");
            } else {
                // close the test window if popups are allowed.
                myPopup.close();  
            }
        }, 0);
    };
}

Ответ 3

Богатый ответ больше не будет работать для Chrome. Похоже, что Chrome фактически запускает любой Javascript во всплывающем окне. Я закончил проверку для значения screenX равным 0 для проверки заблокированных всплывающих окон. Я также думаю, что нашел способ гарантировать, что это свойство является окончательным до проверки. Это работает только для всплывающих окон в вашем домене, но вы можете добавить обработчик onload следующим образом:

var myPopup = window.open("site-on-my-domain", "screenX=100");
if (!myPopup)
    alert("failed for most browsers");
else {
    myPopup.onload = function() {
        setTimeout(function() {
            if (myPopup.screenX === 0)
                alert("failed for chrome");
        }, 0);
    };
}

Как сообщали многие, свойство screenX иногда сообщает о ненулевых ошибках всплывающих окон, даже после загрузки. Я тоже испытал это поведение, но если вы добавите проверку после тайм-аута с нулевым миллисекундом, свойство screenX всегда выводит согласованное значение.

Сообщите мне, есть ли способы сделать этот script более надежным. Кажется, что я работаю для своих целей.

Ответ 4

Ниже приведено решение jQuery для проверки блокировки всплывающих окон. Он был протестирован в FF (v11), Safari (v6), Chrome (v23.0.127.95) и IE (v7 и v9). Обновите функцию _displayError, чтобы обрабатывать сообщение об ошибке, как вам удобно.

var popupBlockerChecker = {
        check: function(popup_window){
            var _scope = this;
            if (popup_window) {
                if(/chrome/.test(navigator.userAgent.toLowerCase())){
                    setTimeout(function () {
                        _scope._is_popup_blocked(_scope, popup_window);
                     },200);
                }else{
                    popup_window.onload = function () {
                        _scope._is_popup_blocked(_scope, popup_window);
                    };
                }
            }else{
                _scope._displayError();
            }
        },
        _is_popup_blocked: function(scope, popup_window){
            if ((popup_window.innerHeight > 0)==false){ scope._displayError(); }
        },
        _displayError: function(){
            alert("Popup Blocker is enabled! Please add this site to your exception list.");
        }
    };

Использование:

var popup = window.open("http://www.google.ca", '_blank');
popupBlockerChecker.check(popup);

Надеюсь, это поможет!:)

Ответ 5

Это сработало для меня:

    cope.PopupTest.params = 'height=1,width=1,left=-100,top=-100,location=no,toolbar=no,menubar=no,scrollbars=no,resizable=no,directories=no,status=no';
    cope.PopupTest.testWindow = window.open("popupTest.htm", "popupTest", cope.PopupTest.params);

    if( !cope.PopupTest.testWindow
        || cope.PopupTest.testWindow.closed
        || (typeof cope.PopupTest.testWindow.closed=='undefined')
        || cope.PopupTest.testWindow.outerHeight == 0
        || cope.PopupTest.testWindow.outerWidth == 0
        ) {
        // pop-ups ARE blocked
        document.location.href = 'popupsBlocked.htm';
    }
    else {
        // pop-ups are NOT blocked
        cope.PopupTest.testWindow.close();
    }

Внешняя и верхняя ширина для хром, потому что трюк "около: пустой" сверху больше не работает в хроме.

Ответ 6

Проверьте положение окна относительно родителя. Chrome заставляет окно появляться почти на экране.

Ответ 7

У меня была аналогичная проблема с всплывающими окнами, которые не открываются в Chrome. Я был расстроен, потому что я не пытался сделать что-то подлый, как всплывающее окно onload, просто открывая окно, когда пользователь щелкнул. Я был DOUBLY расстроен, потому что запустил мою функцию, которая включала window.open() из командной строки firebug, хотя на самом деле щелчок по моей ссылке не был! Вот мое решение:

Неверный способ: запустить window.open() из прослушивателя событий (в моем случае dojo.создать метод события onclick для DOM node).

dojo.connect(myNode, "onclick", function() {
    window.open();
}

Правильный путь: назначение функции для свойства onclick для node, которое называется window.open().

myNode.onclick = function() {
    window.open();
}

И, конечно же, я все еще могу прослушивать события для этого самого события onclick, если нужно. С этим изменением я мог открыть мои окна, хотя Chrome был настроен на "Не разрешать всплывающим окнам на любом сайте". Джой.

Если кто-то из мудрых способов Chrome может рассказать остальным из нас, почему это имеет значение, я бы очень хотел его услышать, хотя я подозреваю, что это просто попытка закрыть дверь на вредоносных программных всплывающих окнах.

Ответ 8

Здесь версия, которая в настоящее время работает в Chrome. Просто небольшое изменение в стороне от решения Rich, хотя я добавил в оболочку, которая также обрабатывает время.

function checkPopupBlocked(poppedWindow) {
 setTimeout(function(){doCheckPopupBlocked(poppedWindow);}, 5000);
}

function doCheckPopupBlocked(poppedWindow) {

    var result = false;

    try {
        if (typeof poppedWindow == 'undefined') {
            // Safari with popup blocker... leaves the popup window handle undefined
            result = true;
        }
        else if (poppedWindow && poppedWindow.closed) {
            // This happens if the user opens and closes the client window...
            // Confusing because the handle is still available, but it in a "closed" state.
            // We're not saying that the window is not being blocked, we're just saying
            // that the window has been closed before the test could be run.
            result = false;
        }
        else if (poppedWindow && poppedWindow.outerWidth == 0) {
            // This is usually Chrome doing. The outerWidth (and most other size/location info)
         // will be left at 0, EVEN THOUGH the contents of the popup will exist (including the
         // test function we check for next). The outerWidth starts as 0, so a sufficient delay
         // after attempting to pop is needed.
            result = true;
        }
        else if (poppedWindow && poppedWindow.test) {
            // This is the actual test. The client window should be fine.
            result = false;
        }
        else {
            // Else we'll assume the window is not OK
            result = true;
        }

    } catch (err) {
        //if (console) {
        //    console.warn("Could not access popup window", err);
        //}
    }

    if(result)
     alert("The popup was blocked. You must allow popups to use this site.");
}

Чтобы использовать его, просто выполните следующее:

var popup=window.open('location',etc...);
checkPopupBlocked(popup);

Если всплывающее окно заблокировано, после 5-секундного льготного периода будет отображаться предупреждающее сообщение (вы можете настроить его, но 5 секунд должны быть совершенно безопасными).

Ответ 9

Этот фрагмент включает все вышеперечисленное. По какой-то причине StackOverflow исключает первую и последнюю строки кода в блоке ниже, поэтому я написал на нем блог. Для полного объяснения и остальной части (загружаемого) кода смотрите мой блог на thecodeabode.blogspot.com

var PopupWarning = {

    init : function()
    {

        if(this.popups_are_disabled() == true)
        {
            this.redirect_to_instruction_page();
        }
    },

    redirect_to_instruction_page : function()
    {
        document.location.href = "http://thecodeabode.blogspot.com";
    },

    popups_are_disabled : function()
    {
        var popup = window.open("http://localhost/popup_with_chrome_js.html", "popup_tester", "width=1,height=1,left=0,top=0");

        if(!popup || popup.closed || typeof popup == 'undefined' || typeof popup.closed=='undefined')
        {
            return true;
        }

        window.focus();
        popup.blur();

        //
        // Chrome popup detection requires that the popup validates itself - so we need to give
        // the popup time to load, then call js on the popup itself
        //
        if(navigator && (navigator.userAgent.toLowerCase()).indexOf("chrome") > -1)
        {
            var on_load_test = function(){PopupWarning.test_chrome_popups(popup);};     
            var timer = setTimeout(on_load_test, 60);
            return;
        }


        popup.close();
        return false;
    },

    test_chrome_popups : function(popup)
    {
        if(popup && popup.chrome_popups_permitted && popup.chrome_popups_permitted() == true)
        {
            popup.close();
            return true;
        }

        //
        // If the popup js fails - popups are blocked
        //
        this.redirect_to_instruction_page();
    }
};

PopupWarning.init();

Ответ 10

Ничего себе, здесь много решений. Это мое, оно использует решения, взятые из текущего принятого ответа (который не работает в последнем Chrome и требует обертывания его в тайм-аут), а также связанные с ним решение на этой теме (на самом деле это vanilla JS, а не jQuery).

Mine использует архитектуру обратного вызова, которая будет отправлена ​​ true, когда всплывающее окно заблокировано и false в противном случае.

window.isPopupBlocked = function(popup_window, cb)
{
    var CHROME_CHECK_TIME = 2000;       // the only way to detect this in Chrome is to wait a bit and see if the window is present

    function _is_popup_blocked(popup)
    {
        return !popup.innerHeight;
    }

    if (popup_window) {
        if (popup_window.closed) {
            // opened OK but was closed before we checked
            cb(false);
            return;
        }
        if (/chrome/.test(navigator.userAgent.toLowerCase())) {
            // wait a bit before testing the popup in chrome
            setTimeout(function() {
                cb(_is_popup_blocked(popup_window));
            }, CHROME_CHECK_TIME);
        } else {
            // for other browsers, add an onload event and check after that
            popup_window.onload = function() {
                cb(_is_popup_blocked(popup_window));
            };
        }
    } else {
        cb(true);
    }
};

Ответ 11

Ответ Джейсона - единственный метод, о котором я тоже могу думать, но полагаться на такую ​​позицию немного уродливо!

В эти дни вам не нужно задавать вопрос "был ли мой незапрашиваемый всплывающий экран заблокирован?", потому что ответ неизменно "да" - во всех основных браузерах включен блокировщик всплывающих окон по умолчанию. Лучший подход - это когда-либо только window.open() в ответ на прямой щелчок, который почти всегда разрешен.

Ответ 12

HI

Я немного изменил описанные выше решения и подумал, что он работает, по крайней мере, для Chrome. Мое решение сделано, чтобы определить, заблокировано ли всплывающее окно при открытии главной страницы, а не при всплывании, но я уверен, что есть некоторые люди, которые могут его изменить.:-) Недостатком здесь является то, что всплывающее окно отображается в течение нескольких секунд (возможно, можно сократить бит), когда нет всплывающего блока.

Я помещал это в раздел моего главного окна

<script type="text/JavaScript" language="JavaScript">

 var mine = window.open('popuptest.htm','popuptest','width=1px,height=1px,left=0,top=0,scrollbars=no');
 if(!mine|| mine.closed || typeof mine.closed=='undefined')
  {
    popUpsBlocked = true       
    alert('Popup blocker detected ');
    if(mine)
      mine.close();
 }
 else
 {
    popUpsBlocked = false    
    var cookieCheckTimer = null;
    cookieCheckTimer =  setTimeout('testPopup();', 3500);
 }


function testPopup()
{
  if(mine)
  {
    if(mine.test())
    {
       popUpsBlocked = false;
    }
    else
    {
        alert('Popup blocker detected ');
         popUpsBlocked = true;
     }
    mine.close();
}

} 
</script>

Popuptest выглядит следующим образом:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
    <title>Popup test</title>
<script type="text/javascript" language="Javascript">
   function test() {if(window.innerHeight!=0){return true;} else return false;}
</script>
</head>

<body>
</body>
</html>

Как я вызываю тестовую функцию на всплывающей странице после 3500 мс, внутренний хром был правильно установлен Chrome.

Я использую переменную popUpsBlocked, чтобы узнать, отображаются ли всплывающие окна или нет в других javascripts. iee

function ShowConfirmationMessage()
{
if(popUpsBlocked)
 { 
  alert('Popups are blocked, can not display confirmation popup. A mail will be sent with the confirmation.');
 } 
 else
 { 
  displayConfirmationPopup();
 }
 mailConfirmation();
}

Ответ 13

function openPopUpWindow(format)
{   
    var win = window.open('popupShow.html',
                          'ReportViewer',
                          'width=920px,height=720px,left=50px,top=20px,location=no,directories=no,status=no,menubar=no,toolbar=no,resizable=1,maximize:yes,scrollbars=0');

    if (win == null || typeof(win) == "undefined" || (win == null && win.outerWidth == 0) || (win != null && win.outerHeight == 0) || win.test == "undefined") 
    {
        alert("The popup was blocked. You must allow popups to use this site.");  
    }
    else if (win)
    {
        win.onload = function()
        {          
            if (win.screenX === 0) {
                alert("The popup was blocked. You must allow popups to use this site.");
                win.close();
            } 
        };
    }
}

Ответ 14

Я собираюсь просто скопировать/вставить предоставленный здесь ответ: fooobar.com/questions/58983/... от DanielB. работает на хроме 40, и он очень чистый. никакие грязные взломы или ожидания не связаны.

function popup(urlToOpen) {
  var popup_window=window.open(urlToOpen,"myWindow","toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=yes, resizable=yes, copyhistory=yes, width=400, height=400");            
  try {
    popup_window.focus();   
  }
  catch (e) {
    alert("Pop-up Blocker is enabled! Please add this site to your exception list.");
  }
}

Ответ 15

Насколько я могу судить (из того, что я тестировал), Chrome возвращает объект окна с расположением "about: blank". Итак, для всех браузеров должно работать следующее:

var newWin = window.open(url);
if(!newWin || newWin.closed || typeof newWin.closed=='undefined' || newWin.location=='about:blank')
{
    //POPUP BLOCKED
}