C'è un modo per rilevare se una finestra del browser non è attualmente attiva?

Ho JavaScript che sta svolgendo attività periodicamente. Quando l'utente non sta guardando il sito (ovvero, la finestra o la scheda non ha lo stato attivo), sarebbe bello non funzionare.

C'è un modo per farlo usando JavaScript?

Il mio punto di riferimento: Gmail Chat riproduce un suono se la finestra che stai utilizzando non è attiva.

Da quando ho scritto questa risposta, una nuova specifica ha raggiunto lo stato di raccomandazione grazie al W3C. L' API di visibilità della pagina (su MDN ) ora ci consente di rilevare con maggiore precisione quando una pagina è nascosta all'utente.

document.addEventListener("visibilitychange", onchange);

Supporto browser corrente:

• Chrome 13+
• Internet Explorer 10+
• Firefox 10+
• Opera 12.10+ ^{[ leggi note ]}

Il codice seguente ricade sul metodo di sfocatura / messa a fuoco meno affidabile nei browser incompatibili:

(function() {
  var hidden = "hidden";

  // Standards:
  if (hidden in document)
    document.addEventListener("visibilitychange", onchange);
  else if ((hidden = "mozHidden") in document)
    document.addEventListener("mozvisibilitychange", onchange);
  else if ((hidden = "webkitHidden") in document)
    document.addEventListener("webkitvisibilitychange", onchange);
  else if ((hidden = "msHidden") in document)
    document.addEventListener("msvisibilitychange", onchange);
  // IE 9 and lower:
  else if ("onfocusin" in document)
    document.onfocusin = document.onfocusout = onchange;
  // All others:
  else
    window.onpageshow = window.onpagehide
    = window.onfocus = window.onblur = onchange;

  function onchange (evt) {
    var v = "visible", h = "hidden",
        evtMap = {
          focus:v, focusin:v, pageshow:v, blur:h, focusout:h, pagehide:h
        };

    evt = evt || window.event;
    if (evt.type in evtMap)
      document.body.className = evtMap[evt.type];
    else
      document.body.className = this[hidden] ? "hidden" : "visible";
  }

  // set the initial state (but only if browser supports the Page Visibility API)
  if( document[hidden] !== undefined )
    onchange({type: document[hidden] ? "blur" : "focus"});
})();

onfocusine onfocusoutsono richiesti per IE 9 e versioni precedenti, mentre tutti gli altri utilizzano onfocuse onblur, ad eccezione di iOS, che utilizza onpageshowe onpagehide.

Vorrei usare jQuery perché poi tutto ciò che devi fare è questo:

$(window).blur(function(){
  //your code here
});
$(window).focus(function(){
  //your code
});

O almeno ha funzionato per me.

Esistono 3 metodi tipici utilizzati per determinare se l'utente può visualizzare la pagina HTML, tuttavia nessuno di questi funziona perfettamente:

• L' API W3C Page Visibility dovrebbe eseguire questa operazione (supportata da: Firefox 10, MSIE 10, Chrome 13). Tuttavia, questa API genera eventi solo quando la scheda del browser è completamente sostituita (ad es. Quando l'utente passa da una scheda all'altra). L'API non genera eventi quando la visibilità non può essere determinata con una precisione del 100% (ad esempio Alt + Tab per passare a un'altra applicazione).

• L'uso di metodi basati sulla messa a fuoco / sfocatura offre molti falsi positivi. Ad esempio, se l'utente visualizza una finestra più piccola nella parte superiore della finestra del browser, la finestra del browser perderà il focus (in onblurrilievo) ma l'utente sarà ancora in grado di vederlo (quindi deve ancora essere aggiornato). Vedi anche http://javascript.info/tutorial/focus

• Affidarsi all'attività dell'utente (spostamento del mouse, clic, digitazione dei tasti) ti dà anche molti falsi positivi. Pensa allo stesso caso sopra o a un utente che guarda un video.

Al fine di migliorare i comportamenti imperfetti sopra descritti, utilizzo una combinazione dei 3 metodi: W3C Visibility API, quindi focus / blur e metodi di attività dell'utente al fine di ridurre il tasso di falsi positivi. Ciò consente di gestire i seguenti eventi:

• Modifica della scheda del browser in un'altra (precisione del 100%, grazie all'API di visibilità della pagina del W3C)
• Pagina potenzialmente nascosta da un'altra finestra, ad esempio a causa di Alt + Tab (probabilistico = non preciso al 100%)
• Attenzione dell'utente potenzialmente non focalizzata sulla pagina HTML (probabilistica = non accurata al 100%)

Funziona così: quando il documento perde lo stato attivo, l'attività dell'utente (come lo spostamento del mouse) sul documento viene monitorata per determinare se la finestra è visibile o meno. La probabilità di visibilità della pagina è inversamente proporzionale al tempo dell'ultima attività dell'utente sulla pagina: se l'utente non fa attività sul documento per un lungo periodo, molto probabilmente la pagina non è visibile. Il codice seguente imita l'API di visibilità della pagina del W3C: si comporta allo stesso modo ma ha una piccola percentuale di falsi positivi. Ha il vantaggio di essere multibrowser (testato su Firefox 5, Firefox 10, MSIE 9, MSIE 7, Safari 5, Chrome 9).

    <div id = "x"> </div>

    <Script>
    / **
    Registra il gestore all'evento per l'oggetto specificato.
    @param obj l'oggetto che genererà l'evento
    @param ev Digitare il tipo di evento: clic, pressione dei tasti, passaggio del mouse, ...
    @param fn la funzione del gestore eventi
    @param isCapturing imposta la modalità evento (true = evento di acquisizione, false = evento di bubbling)
    @return true se il gestore eventi è stato collegato correttamente
    * /
    funzione addEvent (obj, evType, fn, isCapturing) {
      if (isCapturing == null) isCapturing = false; 
      if (obj.addEventListener) {
        // Firefox
        obj.addEventListener (evType, fn, isCapturing);
        ritorno vero;
      } else if (obj.attachEvent) {
        // MSIE
        var r = obj.attachEvent ('on' + evType, fn);
        ritorno r;
      } altro {
        restituire false;
      }
    }

    // registra la potenziale modifica della visibilità della pagina
    addEvent (documento, "entialvisilitychange ", funzione (evento) {
      document.getElementById ("x"). innerHTML + = "entialVisilityChange: potentialHidden = "+ document.potentialHidden +", document.potentiallyHiddenSince = "+ document.potentiallyHiddenSince +" s <br> ";
    });

    // registrati all'API di visibilità della pagina del W3C
    var nascosto = null;
    var visibleChange = null;
    if (typeof document.mozHidden! == "undefined") {
      hidden = "mozHidden";
      visibilityChange = "mozvisibilitychange";
    } else if (typeof document.msHidden! == "undefined") {
      hidden = "msHidden";
      visibilityChange = "msvisibilitychange";
    } else if (typeof document.webkitHidden! == "undefined") {
      hidden = "webkitHidden";
      visibilityChange = "webkitvisibilitychange";
    } else if (typeof document.hidden! == "hidden") {
      hidden = "hidden";
      visibilityChange = "visibilitychange";
    }
    if (nascosto! = null && visibleChange! = null) {
      addEvent (documento, visibilitàCambia, funzione (evento) {
        document.getElementById ("x"). innerHTML + = visibleChange + ":" + hidden + "=" + document [nascosto] + "<br>";
      });
    }


    var potenzialePageVisibility = {
      pageVisibilityChangeThreshold: 3 * 3600, // in secondi
      init: function () {
        function setAsNotHidden () {
          var dispatchEventRequired = document.potentialHidden;
          document.potentialHidden = false;
          document.potentiallyHiddenSince = 0;
          if (dispatchEventRequired) dispatchPageVisibilityChangeEvent ();
        }

        funzione initPotentiallyHiddenDetection () {
          if (! hasFocusLocal) {
            // la finestra non ha lo stato attivo => controlla l'attività dell'utente nella finestra
            lastActionDate = new Date ();
            if (timeoutHandler! = null) {
              clearTimeout (timeoutHandler);
            }
            timeoutHandler = setTimeout (checkPageVisibility ,entialPageVisibility.pageVisibilityChangeThreshold * 1000 + 100); // +100 ms per evitare problemi di arrotondamento in Firefox
          }
        }

        function dispatchPageVisibilityChangeEvent () {
          unifiedVisilityChangeEventDispatchAllowed = false;
          var evt = document.createEvent ("Event");
          evt.initEvent ("entialvisilitychange ", true, true);
          document.dispatchEvent (EVT);
        }

        function checkPageVisibility () {
          varentialHiddenDuration = (hasFocusLocal || lastActionDate == null? 0: Math.floor ((new Date (). getTime () - lastActionDate.getTime ()) / 1000));
                                        document.potentiallyHiddenSince = potentialHiddenDuration;
          if (entialHiddenDuration> = potentialPageVisibility.pageVisibilityChangeThreshold &&! document.potentialHidden) {
            // soglia di modifica della visibilità della pagina raiched => aumenta il pari
            document.potentialHidden = true;
            dispatchPageVisibilityChangeEvent ();
          }
        }

        var lastActionDate = null;
        var hasFocusLocal = true;
        var hasMouseOver = true;
        document.potentialHidden = false;
        document.potentiallyHiddenSince = 0;
        var timeoutHandler = null;

        addEvent (documento, "pageshow", funzione (evento) {
          document.getElementById ( "x") innerHTML + = "pageshow / doc: <br>.";
        });
        addEvent (documento, "pagehide", funzione (evento) {
          document.getElementById ( "x") innerHTML + = "pagehide / doc: <br>.";
        });
        addEvent (finestra, "pageshow", funzione (evento) {
          document.getElementById ( "x") innerHTML + = "pageshow / win: <br>."; // sollevato alla prima visualizzazione della pagina
        });
        addEvent (finestra, "pagehide", funzione (evento) {
          document.getElementById ( "x") innerHTML + = "pagehide / win: <br>."; // non sollevato
        });
        addEvent (documento, "mousemove", funzione (evento) {
          lastActionDate = new Date ();
        });
        addEvent (documento, "passaggio del mouse", funzione (evento) {
          hasMouseOver = true;
          setAsNotHidden ();
        });
        addEvent (documento, "mouseout", funzione (evento) {
          hasMouseOver = false;
          initPotentiallyHiddenDetection ();
        });
        addEvent (finestra, "sfocatura", funzione (evento) {
          hasFocusLocal = false;
          initPotentiallyHiddenDetection ();
        });
        addEvent (finestra, "focus", funzione (evento) {
          hasFocusLocal = true;
          setAsNotHidden ();
        });
        setAsNotHidden ();
      }
    }

    potentialPageVisibility.pageVisibilityChangeThreshold = 4; // 4 secondi per il test
    potentialPageVisibility.init ();
    </ Script>

Poiché al momento non esiste una soluzione cross-browser funzionante senza falsi positivi, è meglio pensarci due volte sulla disabilitazione dell'attività periodica sul proprio sito Web.

C'è una libreria ordinata disponibile su GitHub:

https://github.com/serkanyersen/ifvisible.js

Esempio:

// If page is visible right now
if( ifvisible.now() ){
  // Display pop-up
  openPopUp();
}

Ho testato la versione 1.0.1 su tutti i browser che ho e posso confermare che funziona con:

• IE9, IE10
• FF 26.0
• Chrome 34.0

... e probabilmente tutte le versioni più recenti.

Non funziona completamente con:

• IE8: indica sempre che la scheda / finestra è attualmente attiva ( .now()restituisce sempre trueper me)

Utilizzo: API di visibilità della pagina

document.addEventListener( 'visibilitychange' , function() {
    if (document.hidden) {
        console.log('bye');
    } else {
        console.log('well back');
    }
}, false );

Posso usare ? http://caniuse.com/#feat=pagevisibility

Creo una Comet Chat per la mia app e quando ricevo un messaggio da un altro utente utilizzo:

if(new_message){
    if(!document.hasFocus()){
        audio.play();
        document.title="Have new messages";
    }
    else{
        audio.stop();
        document.title="Application Name";
    } 
}

Ho iniziato utilizzando la risposta wiki della community, ma mi sono reso conto che non stava rilevando eventi alt-tab in Chrome. Questo perché utilizza la prima fonte di eventi disponibile, e in questo caso è l'API di visibilità della pagina, che in Chrome sembra non tenere traccia della tabulazione alternativa.

Ho deciso di modificare un po 'lo script per tenere traccia di tutti gli eventi possibili per le modifiche al focus della pagina. Ecco una funzione che puoi inserire:

function onVisibilityChange(callback) {
    var visible = true;

    if (!callback) {
        throw new Error('no callback given');
    }

    function focused() {
        if (!visible) {
            callback(visible = true);
        }
    }

    function unfocused() {
        if (visible) {
            callback(visible = false);
        }
    }

    // Standards:
    if ('hidden' in document) {
        document.addEventListener('visibilitychange',
            function() {(document.hidden ? unfocused : focused)()});
    }
    if ('mozHidden' in document) {
        document.addEventListener('mozvisibilitychange',
            function() {(document.mozHidden ? unfocused : focused)()});
    }
    if ('webkitHidden' in document) {
        document.addEventListener('webkitvisibilitychange',
            function() {(document.webkitHidden ? unfocused : focused)()});
    }
    if ('msHidden' in document) {
        document.addEventListener('msvisibilitychange',
            function() {(document.msHidden ? unfocused : focused)()});
    }
    // IE 9 and lower:
    if ('onfocusin' in document) {
        document.onfocusin = focused;
        document.onfocusout = unfocused;
    }
    // All others:
    window.onpageshow = window.onfocus = focused;
    window.onpagehide = window.onblur = unfocused;
};

Usalo in questo modo:

onVisibilityChange(function(visible) {
    console.log('the page is now', visible ? 'focused' : 'unfocused');
});

Questa versione è in ascolto di tutti i diversi eventi di visibilità e genera un callback se uno di essi provoca una modifica. I gestori focusede unfocusedassicurano che il callback non venga chiamato più volte se più API rilevano la stessa modifica di visibilità.

Questo è davvero complicato. Sembra che non ci sia soluzione dati i seguenti requisiti.

• La pagina include iframe su cui non hai alcun controllo
• Si desidera tenere traccia della modifica dello stato di visibilità indipendentemente dalla modifica attivata da una modifica TAB (ctrl + tab) o una modifica della finestra (alt + tab)

Questo accade perché:

• L'API di visibilità della pagina può dirti in modo affidabile di un cambio di scheda (anche con iframe), ma non può dirti quando l'utente cambia Windows.
• L'ascolto di eventi di sfocatura / messa a fuoco della finestra può rilevare alt + tab e ctrl + tab, purché l'iframe non abbia lo stato attivo.

Date queste restrizioni, è possibile implementare una soluzione che combina - L'API di visibilità della pagina - sfocatura / focus della finestra - document.activeElement

In grado di:

• 1) ctrl + tab quando la pagina principale è attiva: SÌ
• 2) ctrl + tab quando iframe è attivo: SÌ
• 3) alt + tab quando la pagina principale è attiva: SÌ
• 4) alt + tab quando iframe ha lo stato attivo: NO <- bummer

Quando l'iframe ha lo stato attivo, i tuoi eventi di sfocatura / stato attivo non vengono affatto richiamati e l'API di visibilità della pagina non si attiverà su alt + tab.

Ho sviluppato la soluzione di @ AndyE e implementato questa (quasi buona) soluzione qui: https://dl.dropboxusercontent.com/u/2683925/estante-components/visibility_test1.html (scusate, ho avuto qualche problema con JSFiddle).

Questo è disponibile anche su Github: https://github.com/qmagico/estante-components

Funziona su cromo / cromo. Funziona su firefox, tranne per il fatto che non carica i contenuti iframe (hai idea del perché?)

Ad ogni modo, per risolvere l'ultimo problema (4), l'unico modo per farlo è ascoltare eventi di sfocatura / messa a fuoco sull'iframe. Se hai un certo controllo sugli iframe, puoi usare l'API postMessage per farlo.

https://dl.dropboxusercontent.com/u/2683925/estante-components/visibility_test2.html

Non l'ho ancora provato con abbastanza browser. Se riesci a trovare maggiori informazioni su dove questo non funziona, per favore fatemi sapere nei commenti qui sotto.

var visibilityChange = (function (window) {
    var inView = false;
    return function (fn) {
        window.onfocus = window.onblur = window.onpageshow = window.onpagehide = function (e) {
            if ({focus:1, pageshow:1}[e.type]) {
                if (inView) return;
                fn("visible");
                inView = true;
            } else if (inView) {
                fn("hidden");
                inView = false;
            }
        };
    };
}(this));

visibilityChange(function (state) {
    console.log(state);
});

http://jsfiddle.net/ARTsinn/JTxQY/

questo funziona per me su Chrome 67, Firefox 67,

if(!document.hasFocus()) {
    // do stuff
}

puoi usare:

(function () {

    var requiredResolution = 10; // ms
    var checkInterval = 1000; // ms
    var tolerance = 20; // percent


    var counter = 0;
    var expected = checkInterval / requiredResolution;
    //console.log('expected:', expected);

    window.setInterval(function () {
        counter++;
    }, requiredResolution);

    window.setInterval(function () {
        var deviation = 100 * Math.abs(1 - counter / expected);
        // console.log('is:', counter, '(off by', deviation , '%)');
        if (deviation > tolerance) {
            console.warn('Timer resolution not sufficient!');
        }
        counter = 0;
    }, checkInterval);

})();

In HTML 5 puoi anche usare:

• onpageshow: Script da eseguire quando la finestra diventa visibile
• onpagehide: Script da eseguire quando la finestra è nascosta

Vedere:

• https://developer.mozilla.org/en-US/docs/Web/Events/pageshow
• https://developer.mozilla.org/en-US/docs/Web/Events/pagehide

Questo è un adattamento della risposta di Andy E.

Ciò eseguirà un'attività, ad esempio aggiorna la pagina ogni 30 secondi, ma solo se la pagina è visibile e focalizzata.

Se la visibilità non può essere rilevata, verrà utilizzata solo la messa a fuoco.

Se l'utente focalizza la pagina, si aggiornerà immediatamente

La pagina non verrà aggiornata di nuovo fino a 30 secondi dopo qualsiasi chiamata ajax

var windowFocused = true;
var timeOut2 = null;

$(function(){
  $.ajaxSetup ({
    cache: false
  });
  $("#content").ajaxComplete(function(event,request, settings){
       set_refresh_page(); // ajax call has just been made, so page doesn't need updating again for 30 seconds
   });
  // check visibility and focus of window, so as not to keep updating unnecessarily
  (function() {
      var hidden, change, vis = {
              hidden: "visibilitychange",
              mozHidden: "mozvisibilitychange",
              webkitHidden: "webkitvisibilitychange",
              msHidden: "msvisibilitychange",
              oHidden: "ovisibilitychange" /* not currently supported */
          };
      for (hidden in vis) {
          if (vis.hasOwnProperty(hidden) && hidden in document) {
              change = vis[hidden];
              break;
          }
      }
      document.body.className="visible";
      if (change){     // this will check the tab visibility instead of window focus
          document.addEventListener(change, onchange,false);
      }

      if(navigator.appName == "Microsoft Internet Explorer")
         window.onfocus = document.onfocusin = document.onfocusout = onchangeFocus
      else
         window.onfocus = window.onblur = onchangeFocus;

      function onchangeFocus(evt){
        evt = evt || window.event;
        if (evt.type == "focus" || evt.type == "focusin"){
          windowFocused=true; 
        }
        else if (evt.type == "blur" || evt.type == "focusout"){
          windowFocused=false;
        }
        if (evt.type == "focus"){
          update_page();  // only update using window.onfocus, because document.onfocusin can trigger on every click
        }

      }

      function onchange () {
        document.body.className = this[hidden] ? "hidden" : "visible";
        update_page();
      }

      function update_page(){
        if(windowFocused&&(document.body.className=="visible")){
          set_refresh_page(1000);
        }
      }


  })();
  set_refresh_page();
})

function get_date_time_string(){
  var d = new Date();
  var dT = [];
  dT.push(d.getDate());
  dT.push(d.getMonth())
  dT.push(d.getFullYear());
  dT.push(d.getHours());
  dT.push(d.getMinutes());
  dT.push(d.getSeconds());
  dT.push(d.getMilliseconds());
  return dT.join('_');
}

function do_refresh_page(){

// do tasks here

// e.g. some ajax call to update part of the page.

// (date time parameter will probably force the server not to cache)

//      $.ajax({
//        type: "POST",
//        url: "someUrl.php",
//        data: "t=" + get_date_time_string()+"&task=update",
//        success: function(html){
//          $('#content').html(html);
//        }
//      });

}

function set_refresh_page(interval){
  interval = typeof interval !== 'undefined' ? interval : 30000; // default time = 30 seconds
  if(timeOut2 != null) clearTimeout(timeOut2);
  timeOut2 = setTimeout(function(){
    if((document.body.className=="visible")&&windowFocused){
      do_refresh_page();
    }
    set_refresh_page();
  }, interval);
}

Per una soluzione senza jQuery, consulta Visibility.js che fornisce informazioni su tre stati di pagina

visible    ... page is visible
hidden     ... page is not visible
prerender  ... page is being prerendered by the browser

e anche wrapper per setInterval

/* Perform action every second if visible */
Visibility.every(1000, function () {
    action();
});

/* Perform action every second if visible, every 60 sec if not visible */
Visibility.every(1000, 60*1000, function () {
    action();
});

È disponibile anche un fallback per browser meno recenti (IE <10; iOS <7)

Un modo leggermente più complicato sarebbe usare setInterval()per controllare la posizione del mouse e confrontarlo con l'ultimo controllo. Se il mouse non si è spostato per un determinato periodo di tempo, l'utente è probabilmente inattivo.

Questo ha l'ulteriore vantaggio di dire se l'utente è inattivo, invece di controllare solo se la finestra non è attiva.

Come molte persone hanno sottolineato, questo non è sempre un buon modo per verificare se l'utente o la finestra del browser sono inattivi, poiché l'utente potrebbe anche non utilizzare il mouse o guardare un video o simili. Sto solo suggerendo un modo possibile per verificare la pigrizia.

Per angular.js, ecco una direttiva (basata sulla risposta accettata) che consentirà al controller di reagire a un cambiamento di visibilità:

myApp.directive('reactOnWindowFocus', function($parse) {
    return {
        restrict: "A",
        link: function(scope, element, attrs) {
            var hidden = "hidden";
            var currentlyVisible = true;
            var functionOrExpression = $parse(attrs.reactOnWindowFocus);

          // Standards:
          if (hidden in document)
            document.addEventListener("visibilitychange", onchange);
          else if ((hidden = "mozHidden") in document)
            document.addEventListener("mozvisibilitychange", onchange);
          else if ((hidden = "webkitHidden") in document)
            document.addEventListener("webkitvisibilitychange", onchange);
          else if ((hidden = "msHidden") in document)
            document.addEventListener("msvisibilitychange", onchange);
          else if ("onfocusin" in document) {
                // IE 9 and lower:
            document.onfocusin = onshow;
                document.onfocusout = onhide;
          } else {
                // All others:
            window.onpageshow = window.onfocus = onshow;
                window.onpagehide = window.onblur = onhide;
            }

          function onchange (evt) {
                //occurs both on leaving and on returning
                currentlyVisible = !currentlyVisible;
                doSomethingIfAppropriate();
          }

            function onshow(evt) {
                //for older browsers
                currentlyVisible = true;
                doSomethingIfAppropriate();
            }

            function onhide(evt) {
                //for older browsers
                currentlyVisible = false;
                doSomethingIfAppropriate();
            }

            function doSomethingIfAppropriate() {
                if (currentlyVisible) {
                    //trigger angular digest cycle in this scope
                    scope.$apply(function() {
                        functionOrExpression(scope);
                    });
                }
            }
        }
    };

});

Puoi usarlo come in questo esempio:, <div react-on-window-focus="refresh()">dove refresh()è una funzione scope nell'ambito di qualunque controller sia nell'ambito.

Ecco una soluzione solida e moderna. (Insomma un dolce 👌🏽)

document.addEventListener("visibilitychange", () => {
  console.log( document.hasFocus() )
})

Ciò imposterà un ascoltatore che si innescherà quando viene generato un evento di visibilità che potrebbe essere un focus o sfocatura.

Se si vuole agire su tutta la sfocatura del browser : Come ho commentato, se il browser perdere la concentrazione nessuno degli eventi del fuoco suggerito. La mia idea è di contare in un ciclo e azzerare il contatore in caso di incendio di un evento. Se il contatore raggiunge un limite, faccio un location.href in un'altra pagina. Questo funziona anche se lavori su dev-tools.

var iput=document.getElementById("hiddenInput");
   ,count=1
   ;
function check(){
         count++;
         if(count%2===0){
           iput.focus();
         }
         else{
           iput.blur();
         }
         iput.value=count;  
         if(count>3){
           location.href="http://Nirwana.com";
         }              
         setTimeout(function(){check()},1000);
}   
iput.onblur=function(){count=1}
iput.onfocus=function(){count=1}
check();

Questa è una bozza testata con successo su FF.