Cómo abrir y cerrar ventanas emergentes automáticamente con cierto período de tiempo

Estoy haciendo una página web, en el que tengo que abrir una ventana emergente y debe permanecer abierto durante un período de tiempo de 8 segundos(8000 ms).

Después de este período de tiempo que emergente debe ser cerrado. Luego otra vez después de 4 segundos necesito para abrir la misma ventana emergente para otro 8 segundos.

Quiero poner un poco de retraso(4 segundos) antes de que una ventana emergente se abre y se cierra automáticamente, y la ventana emergente debe permanecer abierto durante 8 segundos

Aquí está mi código:

<html>
<head>
    <script>
        function call()
        {
            popup = window.open('http://www.google.co.in');         
            setInterval(function() {wait();},4000);
        }   
        function caller()
        {
            setInterval(function() {call();},5000);
        }
        function wait()
        {
            popup.close();
        }
    </script>
</head>
<body onload="caller();">
</body>
</html> 

Estoy familiarizado con java script funciona como setInterval() y setTimeout() pero me he encontrado a ninguno de ellos útiles en este caso.
También me he permitido que mi navegador para abrir pop-ups, pero este script abre una ventana emergente y se cierra tan rápido como pasa el tiempo.
Por favor, ayúdame a encontrar el error en mi código.

Gracias.

InformationsquelleAutor Prateek | 2013-05-29

5 Kommentare

  1. 4

    El código se ve bien en el formato, pero tratar de poner algunos esfuerzos en el código.

    Tratar de usarlo como se indica a continuación, Aquí es todo tu código, yo lo he probado en mi sistema, y es de trabajo.

    <html>
    <head>
        <script>
            function call()
            {
                popup = window.open('http://www.google.co.in');         
                setTimeout(wait, 8000);
            }   
            function caller()
            {
                setInterval(call, 12000);
            }
            function wait()
            {
                popup.close();
            }
        </script>
    </head>
    <body onload="caller();">
    </body>
    </html>
  2. 2

    Pruebe estos:

    function call() {
        popup = window.open('http://www.google.co.in');         
        setTimeout(wait, 8000); //closes the pop-up after 8 secs delay
    }
    
    function caller(){
        setInterval(call, 12000); //opens a pop-up on every 12th second
    }

    Su actual call() crea un intervalo de nuevo cada vez que se ejecuta.

  3. 1

    Que no son la asignación de los intervalos a ninguna de las variables, sin tener una referencia a estos intervalos se continuarán ejecutando de forma indefinida y no hay forma de borrarlos. Un método de hacer lo que usted desea probablemente sería mejor con setTimeout como los períodos de apertura /cierre y vuelva a abrir todos somos diferentes, también no tiene problemas con el funcionamiento constante de los intervalos. El siguiente código crea un bucle que se ejecutará indefinidamente hasta que quieres que se detenga.

    var popup = {
        open : function()
        {
            //Open popup
            this.popupWindow = window.open('http://www.google.co.in');
    
            //Return a timeout function
            return setTimeout(function() {
                //run close function on completion of timeout
                popup.close();
            }, 8000);
        },
        close : function()
        {
            this.popupWindow.close();
            //Assign timeout to local variable
            this.timeout = this.loop();
        },
        loop : function()
        {
            var self = this;
    
            //On first run open popup immediately, or wait 4 seconds and restart
            //the loop
            if (self.active === true)
            {
                return setTimeout(function() {
                    self.timeout = self.open();
                }, 4000);
            }
            else
            {
                self.active = true;
                self.timeout = self.open();
            }
        },
        clearLoop : function()
        {
            clearTimeout(this.timeout);
            this.active = false;
        }
    };
    
    popup.loop();

    para detener el bucle en cualquier momento usted puede llamar

    popup.clearLoop();
  4. 1

    Hola que usted puede cerrar la ventana emergente después de un intervalo concreto utilizando este código de abajo,

     <button class="btn btn-success" type="submit" id="spk_button" onclick="javascript:setTimeout(function(){window.close()},3000);">Save</button>
  5. 0

    Usted puede escribir como un «escenario»:

    function next(state) {
      switch(state) {
        case 0:
          showPopup();
          setTimeout("next(1);",8000);
        break;
        case 1:
          hidePopup();
          setTimeout("next(2);",4000);
        break;
        case 2:
          showPopup();
          setTimeout("next(3);",8000);
        break;
    
        ...etc...
    
      }
    }
    
    /* this you have to call at start */
    function init() {
      next(0);
    }

    Si usted necesita un poco de paso a repetir el ciclo, por supuesto, puedes utilizar la siguiente(0).

    Y, por supuesto, tienen que ser las funciones showPopup y hidePopup

    • Esta solución es muy redundante. No estoy seguro de que es una muy buena idea ! El Teemu respuesta parece mejor y evitar la realización de una gran cantidad de no se necesitan pruebas. Usted puede leer esto si quieres : james.padolsey.com/javascript/how-to-avoid-switch-case-syndrome de todos Modos, usted sabe exactamente lo que es el siguiente «caso» de que el interruptor que serán llamados, por lo que no creo que la instrucción switch es el bueno para este caso.
    • Estoy de acuerdo, esta es redundante, pero es universal. Por supuesto, se puede escribir mejor, donde f.e. pasos del escenario se declaran como matriz o un objeto…

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea