¿Cuál es la versión de JavaScript de sleep()?
¿Existe una mejor manera de programar un sleep en JavaScript que la siguiente función pausecomp (tomada de aquí)?
function pausecomp(millis)
{
var date = new Date();
var curDate = null;
do { curDate = new Date(); }
while(curDate-date < millis);
}
Esto no es un duplicado de Sleep en JavaScript - retraso entre acciones; quiero un sueño real en medio de una función, y no un retraso antes de que se ejecute un fragmento de código.
Respuesta #1
Actualización 2017 — 2021
Desde 2009, cuando se hizo esta pregunta, JavaScript ha evolucionado significativamente. Todas las demás respuestas ahora están obsoletas o son demasiado complicadas. Aquí está la mejor práctica actual:
function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
O como una sola línea:
await new Promise(r => setTimeout(r, 2000));
Como una función:
const sleep = ms => new Promise(r => setTimeout(r, ms));
o en Typescript:
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
úsalo como:
await sleep(<duration>);
Demostración :
function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
async function demo() {
for (let i = 0; i < 5; i++) {
console.log(`Waiting ${i} seconds...`);
await sleep(i * 1000);
}
console.log('Done');
}
demo();Tenga en cuenta que,
awaitsolo se puede ejecutar en funciones prefijadas con la palabra claveasync, o en el nivel superior de tu script en un número creciente de entornos.awaitsolo pausa laasyncfunción actual. Esto significa que no bloquea la ejecución del resto del script, lo cual es lo que quieres en la gran mayoría de los casos. Si deseas una construcción bloqueante, consulta esta respuesta usandoAtomics.wait, pero ten en cuenta que la mayoría de los navegadores no lo permitirá en el hilo principal del navegador.
Dos nuevas características de JavaScript (a partir de 2017) ayudaron a escribir esta función de "sleep":
- Promises, una característica nativa de ES2015 (también conocido como ES6). También usamos funciones flecha en la definición de la función sleep.
- La característica
async/awaitpermite que el código espere explícitamente a que una promesa se resuelva (resolve o reject).
Compatibilidad
- las promesas están soportadas en Node v0.12+ y ampliamente soportadas en navegadores, excepto IE
async/awaitllegaron a V8 y se han habilitado por defecto desde Chrome 55 (lanzado en diciembre de 2016)- aterrizó en el Nodo 7 en octubre de 2016
- y también llegó a Firefox Nightly en noviembre de 2016
Si por alguna razón estás usando Node anterior a la versión 7 (que llegó al final de su vida útil en 2017), o estás apuntando a navegadores antiguos, async/await todavía se pueden usar a través de Babel (una herramienta que transpilará JavaScript + nuevas funciones en JavaScript clásico), con el plugin transform-async-to-generator.
Respuesta #2
(Vea la respuesta actualizada para 2016)
Creo que es perfectamente razonable querer realizar una acción, esperar y luego realizar otra acción. Si estás acostumbrado a programar en lenguajes multihilo, probablemente tengas la idea de ceder la ejecución por un período de tiempo determinado hasta que tu hilo se despierta.
El problema aquí es que JavaScript es un modelo de eventos de un solo hilo. Aunque en un caso específico podría ser agradable que todo el motor esperara unos segundos, en general es una mala práctica. ¿Supongamos que quisiera hacer uso de tus funciones mientras escribo las mías propias? Cuando llamara a tu método, todos mis métodos se congelarían. Si JavaScript de alguna manera pudiera preservar el contexto de ejecución de tu función, almacenarlo en algún lugar, y luego recuperarlo y continuar más tarde, entonces el sueño podría ocurrir, pero eso básicamente sería subprocesamiento.
Así que básicamente estás atrapado con lo que otros han sugerido: necesitarás dividir tu código en múltiples funciones.
Entonces, tu pregunta es un poco una elección falsa. No hay manera de dormir de la forma que quieres, ni deberías seguir la solución que sugieres.
Respuesta #3
En JavaScript, reescribo cada función para que pueda terminar lo antes posible. Quieres que el navegador recupere el control para que pueda realizar tus cambios en el DOM.
Cada vez que he querido dormir en medio de mi función, he refactorizado para usar un setTimeout().
Editar
La infame función de dormir, o de retraso, dentro de cualquier lenguaje es muy debatida. Algunos dirán que siempre debería haber una señal o callback para activar una funcionalidad determinada, otros argumentarán que a veces un momento arbitrario de retraso es útil. Yo digo que cada quien tiene lo suyo y una regla nunca puede dictar nada en esta industria.
Escribir una función de sueño es sencillo y se vuelve aún más útil con las Promesas de JavaScript:
// sleep time expects milliseconds
function sleep (time) {
return new Promise((resolve) => setTimeout(resolve, time));
}
// Usage!
sleep(500).then(() => {
// Do something after the sleep!
});
Si estás dentro de una función async, puedes hacer un paso de espera adecuado con la definición anterior de sleep():
// Available inside async functions:
await sleep(500);
// Do something after the sleep…
Respuesta #4
En Firebug (y probablemente en otras consolas de JavaScript), no sucede nada después de presionar enter, solo después de la duración de sueño especificada (...)
function sleepFor(sleepDuration){
var now = new Date().getTime();
while(new Date().getTime() < now + sleepDuration){ /* Do nothing */ }
}
Ejemplo de uso:
function sleepFor(sleepDuration){
var now = new Date().getTime();
while(new Date().getTime() < now + sleepDuration){
/* Do nothing */
}
}
function sleepThenAct(){
sleepFor(2000);
console.log("Hello, JavaScript sleep!");
}
sleepThenAct()Nota: Sólo para depuración y desarrollo
Respuesta #5
Estoy de acuerdo con los otros comentaristas. Tener un sueño ocupado es simplemente una mala idea.
Sin embargo, setTimeout no detiene la ejecución. Ejecuta la siguiente línea de la función inmediatamente después de que se establece el tiempo de espera, no después de que expira el tiempo de espera, por lo que eso no realiza la misma tarea que realizaría un sleep.
La manera de hacerlo es descomponer tu función en partes de antes y después.
function doStuff()
{
// Do some things
setTimeout(continueExecution, 10000) // Wait ten seconds before continuing
}
function continueExecution()
{
// Finish doing things after the pause
}
Asegúrate de que los nombres de tus funciones sigan describiendo con precisión lo que hace cada parte (es decir, GatherInputThenWait y CheckInput, en lugar de funcPart1 y funcPart2)
Este método logra el propósito de no ejecutar las líneas de código que decida hasta después de su tiempo de espera, mientras aún devuelve el control a la PC del cliente para ejecutar lo que tenga en cola.
Como se señaló en los comentarios, esto absolutamente no funcionará en un bucle. Podrías hacer algunos trucos elegantes (feos) para que funcione en un bucle, pero en general eso solo hará que el código sea un desastre enredado.
Respuesta #6
Por el amor de $DEITY, por favor no hagas una función de sueño con espera ocupada. setTimeout y setInterval hacen todo lo que necesitas.
var showHide = document.getElementById('showHide');
setInterval(() => {
showHide.style.visibility = "initial";
setTimeout(() => {
showHide.style.visibility = "hidden"
}, 1000);
}, 2000); <div id="showHide">Hello! Goodbye!</div>Cada intervalo de dos segundos oculta el texto durante un segundo. Esto muestra cómo usar setInterval y setTimeout para mostrar y ocultar texto cada segundo.
Respuesta #7
Si (como yo) estás usando JavaScript con Rhino, puedes usar...
try
{
java.lang.Thread.sleep(timeInMilliseconds);
}
catch (e)
{
/*
* This will happen if the sleep is woken up - you might want to check
* if enough time has passed and sleep again if not - depending on how
* important the sleep time is to you.
*/
}
Respuesta #8
Usar :
await new Promise(resolve => setTimeout(resolve, 2000));
dentro de una función asincrónica.
Respuesta #9
Si estás usando jQuery, alguien en realidad creó un complemento llamado "delay" que no es más que un envoltorio para setTimeout:
// Delay Plugin for jQuery
// - http://www.evanbot.com
// - © 2008 Evan Byrne
jQuery.fn.delay = function(time,func){
this.each(function(){
setTimeout(func,time);
});
return this;
};
Entonces puedes usarlo en una fila de llamadas a funciones como se espera:
$('#warning')
.addClass('highlight')
.delay(1000)
.removeClass('highlight');
Respuesta #10
JavaScript estándar:
Define la función
async sleep:const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))y úsalo:
await sleep(1000) // Sleep for 1 second
Bun.js ha implementado de forma nativa la función anterior:
await Bun.sleep(1000) // Sleep for 1 secondVer: https://bun.sh/guides/util/sleep
Node.js:
Desde Node.js 16+ está disponible una nueva versión promisificada de
setTimeout():import {setTimeout} from 'timers/promises' await setTimeout(1000) // Sleep for 1 secondVer: https://nodejs.org/api/timers.html#timerspromisessettimeoutdelay-value-options
Respuesta #11
También he buscado una solución para dormir (no para código de producción, solo para desarrollo y pruebas) y encontré este artículo:
JavaScript sleep() o wait()
...y aquí hay otro artículo con soluciones del lado del cliente: JavaScript sleep
Además, cuando llamas a alert(), tu código también se pausará mientras se muestra la alerta; necesitas encontrar una manera de no mostrar la alerta, pero obtener el mismo efecto. :)
Respuesta #12
Aquí tienes. Como dice el código, no seas un mal desarrollador y no uses esto en sitios web. Es una función de utilidad para desarrollo.
// Basic sleep function based on ms.
// DO NOT USE ON PUBLIC FACING WEBSITES.
function sleep(ms) {
var unixtime_ms = new Date().getTime();
while(new Date().getTime() < unixtime_ms + ms) {}
}
Respuesta #13
Aquí hay una solución simple usando un XMLHttpRequest síncrono:
function sleep(n){
var request = new XMLHttpRequest();
request.open('GET', '/sleep.php?n=' + n, false); // `false` makes the request synchronous
request.send(null);
}
Contenido del archivo sleep.php:
<?php sleep($_GET['n']);
Ahora llámalo con:
sleep(5);
Usando una implementación de servidor existente
Si no tienes tu propio servidor de aplicaciones (para el script PHP anterior), podrías usar algún servicio en línea en su lugar. Por ejemplo:
function sleep(n) {
var request = new XMLHttpRequest();
request.open('GET', 'http://httpstat.us/200?sleep=' + n, false);
request.send(null);
};
sleep(1000);
console.log("one second delay completed.");Soporte
Acerca de pasar false para el parámetro asynchronous, mdn señala:
Las solicitudes síncronas en el hilo principal pueden ser fácilmente disruptivas para la experiencia del usuario y deben evitarse; de hecho, muchos navegadores han eliminado por completo el soporte de XHR síncrono en el hilo principal. Las solicitudes síncronas están permitidas en los Workers.
El retraso real
El número de milisegundos que se pasa como argumento será el tiempo que el servidor espera entre recibir la solicitud y enviar la respuesta. El retraso causado por la transmisión y la carga del servidor se sumará a eso.
Respuesta #14
Actualización 2019 usando Atomics.wait
Debería funcionar en Node.js 9.3 o superior.
Necesitaba un temporizador bastante preciso en Node.js y funciona muy bien para eso.
Sin embargo, parece que hay un soporte extremadamente limitado en los navegadores.
let ms = 10000;
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);Ejecutó algunas pruebas de temporizador de 10 segundos.
Con setTimeout obtengo un error de hasta 7000 microsegundos (7 ms).
Con Atómicos, mi error parece mantenerse por debajo de 600 microsegundos (0,6 ms)
Actualización 2020: En Resumen
function sleep(millis){ // Need help of a server-side page
let netMillis = Math.max(millis-5, 0); // Assuming 5 ms overhead
let xhr = new XMLHttpRequest();
xhr.open('GET', '/sleep.jsp?millis=' + netMillis + '&rand=' + Math.random(), false);
try{
xhr.send();
}catch(e){
}
}
function sleepAsync(millis){ // Use only in async function
let netMillis = Math.max(millis-1, 0); // Assuming 1 ms overhead
return new Promise((resolve) => {
setTimeout(resolve, netMillis);
});
}
function sleepSync(millis){ // Use only in worker thread, currently Chrome-only
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, millis);
}
function sleepTest(){
console.time('sleep');
sleep(1000);
console.timeEnd('sleep');
}
async function sleepAsyncTest(){
console.time('sleepAsync');
await sleepAsync(1000);
console.timeEnd('sleepAsync');
}
function sleepSyncTest(){
let source = `${sleepSync.toString()}
console.time('sleepSync');
sleepSync(1000);
console.timeEnd('sleepSync');`;
let src = 'data:text/javascript,' + encodeURIComponent(source);
console.log(src);
var worker = new Worker(src);
}
de la cual la página del lado del servidor, p. ej. sleep.jsp, se ve así:
<%
try{
Thread.sleep(Long.parseLong(request.getParameter("millis")));
}catch(InterruptedException e){}
%>
Respuesta #15
Un inliner:
(async () => await new Promise(resolve => setTimeout(resolve, 500)))();
500 aquí es el tiempo en milisegundos que la VM esperará antes de pasar a la siguiente línea de código.
Un poco de resumen;
Básicamente, cuando creas una promesa, esta devuelve un observable mientras que en la creación proporciona una referencia de resolve en un callback destinado a entregar datos/respuesta una vez que estén disponibles. Aquí, resolve se llama mediante setTimeOut después de 500 ms, y hasta que resolve no se ejecute, el ámbito externo está esperando para continuar, creando así un bloqueo falso. Es completamente diferente que el no bloqueante (o llamado sleep que no reserva hilo disponible en otros lenguajes), ya que el hilo y muy probablemente la interfaz de usuario y cualquier otra tarea en curso de la aplicación web/node estarán bloqueados y el hilo principal se utilizará exclusivamente para esperar la resolución de la promesa.
Respuesta #16
Primero :
Define una función que quieras ejecutar así:
function alertWorld(){
alert("Hello, World!");
}
Luego programa su ejecución con el método setTimeout:
setTimeout(alertWorld, 1000)
Observa dos cosas
- el segundo argumento es el tiempo en milisegundos
- como primer argumento, tienes que pasar solo el nombre (referencia) de la función, sin los paréntesis
Respuesta #17
La solución más corta sin ninguna dependencia:
await new Promise(resolve => setTimeout(resolve, 5000));
Respuesta #18
Una mejor solución para hacer que las cosas se vean como lo que la mayoría de la gente quiere es usar una función anónima:
alert('start');
var a = 'foo';
// Lots of code
setTimeout(function(){ // Beginning of code that should run AFTER the timeout
alert(a);
// Lots more code
}, 5000); // Put the timeout here
Esto es probablemente lo más cercano que conseguirás a algo que simplemente haga lo que quieres.
Ten en cuenta que, si necesitas múltiples procesos de sueño, esto puede volverse complicado rápidamente y en realidad podrías necesitar reconsiderar tu diseño.
Respuesta #19
El setTimeout es parte de los métodos asincrónicos de JavaScript (métodos que comienzan a ejecutarse y cuyo resultado se colocará en una cola llamada cola de callbacks en algún momento en el futuro, para ser ejecutado más tarde)
Lo que probablemente quieras hacer es envolver la función setTimeout dentro de una Promesa.
ejemplo de promesa:
const sleep = time => new Promise(res => setTimeout(res, time, "done sleeping"));
// using native promises
sleep(2000).then(msg => console.log(msg));ejemplo de async/await:
const sleep = time => new Promise(res => setTimeout(res, time, "done sleeping"));
// using async/await in top level
(async function(){
const msg = await sleep(2000);
console.log(msg);
})();Lee más sobre setTimeout
Respuesta #20
Una sola línea usando Promises
const wait = t => new Promise(s => setTimeout(s, t, t));
Typescript con señal de aborto
const wait = (x: number, signal?: AbortSignal): Promise<number> => {
return new Promise((s, f) => {
const id = setTimeout(s, x, x);
signal?.addEventListener('abort', () => {
clearTimeout(id);
f('AbortError');
});
});
};
Demostración
const wait = t => new Promise(s => setTimeout(s, t));
// Usage
async function demo() {
// Count down
let i = 6;
while (i--) {
await wait(1000);
console.log(i);
}
// Sum of numbers 0 to 5 using by delay of 1 second
const sum = await [...Array(6).keys()].reduce(async (a, b) => {
a = await a;
await wait(1000);
const result = a + b;
console.log(`${a} + ${b} = ${result}`);
return result;
}, Promise.resolve(0));
console.log("sum", sum);
}
demo();Respuesta #21
Encapsularía setTimeOut en una Promesa para mantener la consistencia del código con otras tareas asincrónicas: Demostración en Fiddle
function sleep(ms)
{
return(new Promise(function(resolve, reject) {
setTimeout(function() { resolve(); }, ms);
}));
}
Se utiliza así:
sleep(2000).then(function() {
// Do something
});
Es fácil recordar la sintaxis si estás acostumbrado a usar Promesas.
Respuesta #22
¡Esta respuesta es para Node 18 y versiones más recientes!
En lugar de hacer:
await new Promise(resolve => setTimeout(resolve, 2000));
Ahora podemos hacer:
const { setTimeout } = require('timers/promises');
await setTimeout(3000); // sleep 3 seconds
Respuesta #23
Para los navegadores, estoy de acuerdo en que setTimeout y setInterval son el camino a seguir.
Pero para el código del lado del servidor, puede requerir una función bloqueante (por ejemplo, para que puedas tener efectivamente sincronización de hilos).
Si estás usando Node.js y Meteor, es posible que te hayas encontrado con las limitaciones de usar setTimeout en una fibra. Aquí está el código para dormir del lado del servidor.
var Fiber = require('fibers');
function sleep(ms) {
var fiber = Fiber.current;
setTimeout(function() {
fiber.run();
}, ms);
Fiber.yield();
}
Fiber(function() {
console.log('wait... ' + new Date);
sleep(1000);
console.log('ok... ' + new Date);
}).run();
console.log('back in main');
Ver: Node.js Fibers, Sleep
Respuesta #24
La mayoría de las respuestas aquí están equivocadas o, como mínimo, desactualizadas. No hay razón para que JavaScript tenga que ser de un solo hilo, y de hecho no lo es. Hoy en día, todos los navegadores principales soportan workers. Antes de que esto fuera así, otros entornos de ejecución de JavaScript como Rhino y Node.js soportaban la multitarea.
«JavaScript es de un solo hilo» no es una respuesta válida. Por ejemplo, ejecutar una función de espera dentro de un trabajador no bloquearía ningún código que se esté ejecutando en el hilo de la interfaz de usuario.
En las versiones más recientes del entorno de ejecución que admiten generadores y yield, se podría llevar una funcionalidad similar a la función sleep en un entorno de un solo hilo:
// This is based on the latest ES6 drafts.
// JavaScript 1.7+ (SpiderMonkey/Firefox 2+) syntax is slightly different
// Run code you want to sleep here (omit star if using JavaScript 1.7)
function* main(){
for (var i = 0; i < 10; i++) {
// To sleep for 10 milliseconds 10 times in a row
yield 10;
}
yield 5;
console.log('I just slept 5 milliseconds!');
}
// Resume the given generator after ms milliseconds
function resume(ms, generator){
setTimeout(function(){
// Omit .value if using JavaScript 1.7
var nextSleep = generator.next().value;
resume(nextSleep, generator);
}, ms);
}
// Initialize a generator and get first sleep for the recursive function
var
generator = main(),
firstSleep = generator.next().value;
// Initialize recursive resume function
resume(firstSleep, generator);
Esta imitación del sueño es diferente de una función de sueño verdadera ya que no bloquea el hilo. Simplemente es un azúcar añadido a la función setTimeout actual de JavaScript. Este tipo de funcionalidad ha been implementado en Task.js y debería funcionar hoy en Firefox.
Respuesta #25
ACTUALIZACIÓN 2022 :
Simplemente usa este fragmento de código.
await new Promise(resolve => setTimeout(resolve, 2000));
Respuesta #26
Desde Node.js 7.6, puedes combinar la función promisify del módulo utils con setTimeout.
const sleep = require('util').promisify(setTimeout)
Uso general
async function main() {
console.time("Slept for")
await sleep(3000)
console.timeEnd("Slept for")
}
main()
Uso de preguntas
async function asyncGenerator() {
while (goOn) {
var fileList = await listFiles(nextPageToken);
await sleep(3000)
var parents = await requestParents(fileList);
}
}
Respuesta #27
He buscado/googled bastantes páginas web sobre dormir/esperar en JavaScript... y no hay ninguna respuesta si quieres que JavaScript "EJECUTE, ESPERE, EJECUTE"... lo que la mayoría de la gente encontró fue, o bien, "EJECUTA, EJECUTA (cosas inútiles), EJECUTA" o "EJECUTA, EJECUTA + EJECUTA con retraso"...
Pensé: aquí hay una solución que funciona... pero tienes que dividir tus códigos en ejecución...: Sí, lo sé, esto es solo una refactorización más fácil de leer... aun así...
Ejemplo 1:
<html>
<body>
<div id="id1">DISPLAY</div>
<script>
// JavaScript sleep by "therealdealsince1982"; copyrighted 2009
// setInterval
var i = 0;
function run() {
// Pieces of codes to run
if (i == 0){document.getElementById("id1").innerHTML= "<p>code segment " + i + " is ran</p>"; }
if (i == 1){document.getElementById("id1").innerHTML= "<p>code segment " + i + " is ran</p>"; }
if (i == 2){document.getElementById("id1").innerHTML= "<p>code segment " + i + " is ran</p>"; }
if (i >2){document.getElementById("id1").innerHTML= "<p>code segment " + i + " is ran</p>"; }
if (i == 5){document.getElementById("id1").innerHTML= "<p>all code segment finished running</p>"; clearInterval(t); } // End interval, stops run
i++; // Segment of code finished running, next...
}
run();
t = setInterval("run()", 1000);
</script>
</body>
</html>
Ejemplo 2:
<html>
<body>
<div id="id1">DISPLAY</div>
<script>
// JavaScript sleep by "therealdealsince1982"; copyrighted 2009
// setTimeout
var i = 0;
function run() {
// Pieces of codes to run, can use switch statement
if (i == 0){document.getElementById("id1").innerHTML= "<p>code segment " + i + " ran</p>"; sleep(1000);}
if (i == 1){document.getElementById("id1").innerHTML= "<p>code segment " + i + " ran</p>"; sleep(2000);}
if (i == 2){document.getElementById("id1").innerHTML= "<p>code segment " + i + " ran</p>"; sleep(3000);}
if (i == 3){document.getElementById("id1").innerHTML= "<p>code segment " + i + " ran</p>";} //stops automatically
i++;
}
function sleep(dur) {t=setTimeout("run()", dur);} // Starts flow control again after 'dur'
run(); // Starts
</script>
</body>
</html>
Ejemplo 3:
<html>
<body>
<div id="id1">DISPLAY</div>
<script>
// JavaScript sleep by "therealdealsince1982"; copyrighted 2009
// setTimeout
var i = 0;
function flow() {
run(i);
i++; // Code segment finished running, increment i; can put elsewhere
sleep(1000);
if (i == 5) {clearTimeout(t);} // Stops flow, must be after sleep()
}
function run(segment) {
// Pieces of codes to run, can use switch statement
if (segment == 0){document.getElementById("id1").innerHTML= "<p>code segment " + segment + " is ran</p>"; }
if (segment == 1){document.getElementById("id1").innerHTML= "<p>code segment " + segment + " is ran</p>"; }
if (segment == 2){document.getElementById("id1").innerHTML= "<p>code segment " + segment + " is ran</p>"; }
if (segment >2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
}
function sleep(dur) {t=setTimeout("flow()", dur);} // Starts flow control again after 'dur'
flow(); // Starts flow
</script>
</body>
</html>
Ejemplo 4:
<html>
<body>
<div id="id1">DISPLAY</div>
<script>
// JavaScript sleep by "therealdealsince1982"; copyrighted 2009
// setTimeout, switch
var i = 0;
function flow() {
switch(i)
{
case 0:
run(i);
sleep(1000);
break;
case 1:
run(i);
sleep(2000);
break;
case 5:
run(i);
clearTimeout(t); // Stops flow
break;
default:
run(i);
sleep(3000);
break;
}
}
function run(segment) {
// Pieces of codes to run, can use switch statement
if (segment == 0){document.getElementById("id1").innerHTML= "<p>code segment " + segment + " is ran</p>"; }
if (segment == 1){document.getElementById("id1").innerHTML= "<p>code segment " + segment + " is ran</p>"; }
if (segment == 2){document.getElementById("id1").innerHTML= "<p>code segment " + segment + " is ran</p>"; }
if (segment >2){document.getElementById("id1").innerHTML= "<p>code segment " + segment + " is ran</p>"; }
i++; // Current segment of code finished running, next...
}
function sleep(dur) {t=setTimeout("flow()", dur);} // Starts flow control again after 'dur'
flow(); // Starts flow control for first time...
</script>
</body>
</html>
Respuesta #28
function sleep(milliseconds) {
var start = new Date().getTime();
for (var i = 0; i < 1e7; i++) {
if ((new Date().getTime() - start) > milliseconds){
break;
}
}
}
Respuesta #29
Si quieres funciones menos torpes que setTimeout y setInterval, puedes envolverlas en funciones que simplemente inviertan el orden de los argumentos y les den nombres agradables:
function after(ms, fn){ setTimeout(fn, ms); }
function every(ms, fn){ setInterval(fn, ms); }
Versiones de CoffeeScript:
after = (ms, fn)-> setTimeout fn, ms
every = (ms, fn)-> setInterval fn, ms
Luego puedes usarlas de manera agradable con funciones anónimas:
after(1000, function(){
console.log("it's been a second");
after(1000, function(){
console.log("it's been another second");
});
});
Ahora se lee fácilmente como "después de N milisegundos, ..." (o "cada N milisegundos, ...")