Was ist die JavaScript-Version von sleep ()?

Gibt es eine bessere Möglichkeit, eine sleepin JavaScript zu erstellen als die folgende pausecompFunktion ( von hier übernommen )?

function pausecomp(millis)
{
    var date = new Date();
    var curDate = null;
    do { curDate = new Date(); }
    while(curDate-date < millis);
}

Dies ist kein Duplikat von Sleep in JavaScript - Verzögerung zwischen Aktionen ; Ich möchte einen echten Schlaf mitten in einer Funktion und keine Verzögerung, bevor ein Teil des Codes ausgeführt wird.

Update 2017 - 2019

Seit 2009, als diese Frage gestellt wurde, hat sich JavaScript erheblich weiterentwickelt. Alle anderen Antworten sind jetzt veraltet oder zu kompliziert. Hier ist die aktuelle Best Practice:

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function demo() {
  console.log('Taking a break...');
  await sleep(2000);
  console.log('Two seconds later, showing sleep in a loop...');

  // Sleep in loop
  for (let i = 0; i < 5; i++) {
    if (i === 3)
      await sleep(2000);
    console.log(i);
  }
}

demo();

Das ist es. await sleep(<duration>).

Oder als Einzeiler:

await new Promise(r => setTimeout(r, 2000));

Beachten Sie, dass,

1. awaitkann nur in Funktionen ausgeführt werden, denen das asyncSchlüsselwort vorangestellt ist , oder in einigen Umgebungen (z. B. der Chrome DevTools-Konsole oder Runkit) auf der obersten Ebene Ihres Skripts.
2. awaitpausiert nur die aktuelle asyncFunktion

Zwei neue JavaScript-Funktionen haben beim Schreiben dieser "Schlaf" -Funktion geholfen:

• Versprechen, eine native Funktion von ES2015 (auch bekannt als ES6). Wir verwenden auch Pfeilfunktionen bei der Definition der Schlaffunktion.
• Mit dieser async/awaitFunktion kann der Code explizit auf die Erfüllung eines Versprechens warten (auflösen oder ablehnen).

Kompatibilität

• Versprechen werden unterstützt in Knoten v0.12 + und weit verbreitet in Browsern unterstützt , außer IE
• async/ awaitlandete in V8 und ist seit Chrome 55 (veröffentlicht im Dezember 2016) standardmäßig aktiviert.
  • es landete im Oktober 2016 auf Knoten 7
  • und landete auch in Firefox Nightly im November 2016

Wenn aus irgendeinem seltsamen Grund , den Sie verwenden Knoten älter als 7 (was erreicht hat Ende des Lebens ), oder alte Browser zielen, async/ awaitnoch über verwendet werden Babel (ein Werkzeug , das wird transpile JavaScript + neue Funktionen in plain old JavaScript) mit dem transform-async-to-generatorPlugin.

(Siehe die aktualisierte Antwort für 2016 )

Ich denke, es ist völlig vernünftig, eine Aktion ausführen zu wollen, zu warten und dann eine andere Aktion auszuführen. Wenn Sie es gewohnt sind, in Multithread-Sprachen zu schreiben, haben Sie wahrscheinlich die Idee, die Ausführung für einen festgelegten Zeitraum zu ermöglichen, bis Ihr Thread aufwacht.

Das Problem hierbei ist, dass JavaScript ein ereignisbasiertes Single-Thread-Modell ist. Während es in einem bestimmten Fall schön sein kann, den gesamten Motor einige Sekunden warten zu lassen, ist dies im Allgemeinen eine schlechte Praxis. Angenommen, ich wollte Ihre Funktionen nutzen, während ich meine eigenen schreibe? Wenn ich Ihre Methode aufrief, froren alle meine Methoden ein. Wenn JavaScript den Ausführungskontext Ihrer Funktion irgendwie beibehalten, irgendwo speichern, dann zurückbringen und später fortfahren könnte, könnte der Ruhezustand eintreten, aber das wäre im Grunde ein Threading.

Sie bleiben also ziemlich bei dem, was andere vorgeschlagen haben - Sie müssen Ihren Code in mehrere Funktionen aufteilen.

Ihre Frage ist also eine falsche Wahl. Es gibt keine Möglichkeit, so zu schlafen, wie Sie es möchten, und Sie sollten auch nicht die von Ihnen vorgeschlagene Lösung verfolgen.

In JavaScript schreibe ich jede Funktion neu, damit sie so schnell wie möglich beendet werden kann. Sie möchten, dass der Browser wieder die Kontrolle hat, damit er Ihre DOM-Änderungen vornehmen kann.

Jedes Mal, wenn ich mitten in meiner Funktion schlafen wollte, überarbeitete ich die Verwendung von a setTimeout().

Bearbeiten

Die berüchtigte Schlaf- oder Verzögerungsfunktion in jeder Sprache wird viel diskutiert. Einige werden sagen, dass es immer ein Signal oder einen Rückruf geben sollte, um eine bestimmte Funktionalität auszulösen, andere werden argumentieren, dass manchmal ein beliebiger Moment der Verzögerung nützlich ist. Ich sage, dass jeder seine eigene und eine Regel niemals etwas in dieser Branche diktieren kann.

Das Schreiben einer Schlaffunktion ist einfach und mit JavaScript Promises noch benutzerfreundlicher:

// sleep time expects milliseconds
function sleep (time) {
  return new Promise((resolve) => setTimeout(resolve, time));
}

// Usage!
sleep(500).then(() => {
    // Do something after the sleep!
});

Nur für Debug / Dev poste ich dies, wenn es für jemanden nützlich ist

Interessantes, in Firebug (und wahrscheinlich auch in anderen js-Konsolen) passiert nichts, nachdem Sie die Eingabetaste gedrückt haben, nur nach der angegebenen Schlafdauer (...)

function sleepFor( sleepDuration ){
    var now = new Date().getTime();
    while(new Date().getTime() < now + sleepDuration){ /* do nothing */ } 
}

Anwendungsbeispiel:

function sleepThenAct(){ sleepFor(2000); console.log("hello js sleep !"); }

Ich stimme den anderen Postern zu, ein geschäftiger Schlaf ist nur eine schlechte Idee.

SetTimeout verzögert jedoch nicht die Ausführung, sondern führt die nächste Zeile der Funktion unmittelbar nach dem Einstellen des Timeouts aus, nicht nach Ablauf des Timeouts, sodass nicht dieselbe Aufgabe ausgeführt wird, die ein Sleep ausführen würde.

Der Weg, dies zu tun, besteht darin, Ihre Funktion in vor und nach Teilen aufzuteilen.

function doStuff()
{
  //do some things
  setTimeout(continueExecution, 10000) //wait ten seconds before continuing
}

function continueExecution()
{
   //finish doing things after the pause
}

Stellen Sie sicher, dass Ihre Funktionsnamen immer noch genau beschreiben, was jedes Teil tut (IE GatherInputThenWait und CheckInput anstelle von funcPart1 und funcPart2).

Bearbeiten

Mit dieser Methode wird der Zweck erreicht, die von Ihnen festgelegten Codezeilen erst nach Ablauf Ihrer Zeitüberschreitung auszuführen, während die Steuerung weiterhin an den Client-PC zurückgegeben wird, um alle anderen Warteschlangen auszuführen.

Weitere Bearbeitung

Wie in den Kommentaren erwähnt, wird dies absolut NICHT in einer Schleife funktionieren. Sie könnten ein ausgefallenes (hässliches) Hacking durchführen, damit es in einer Schleife funktioniert, aber im Allgemeinen führt dies nur zu katastrophalem Spaghetti-Code.

Aus Liebe zu $ ​​DEITY machen Sie bitte keine Funktion zum Warten auf viel zu tun. setTimeoutund setIntervalmach alles was du brauchst.

var showHide = document.getElementById('showHide');
setInterval(() => {
    showHide.style.visibility = "initial";
    setTimeout(() => {
        showHide.style.visibility = "hidden"
    }, 1000);
    ;
}, 2000);   

<div id="showHide">Hello! Goodbye!</div>

Alle zwei Sekunden wird der Text eine Sekunde lang ausgeblendet. Dies zeigt, wie Sie mit setInterval und setTimeout jede Sekunde Text ein- und ausblenden.

Ich weiß, dass dies eine alte Frage ist, aber wenn Sie (wie ich) Javascript mit Rhino verwenden, können Sie ...

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.
   */
}

Wenn Sie jQuery verwenden, hat jemand tatsächlich ein "Delay" -Plugin erstellt, das nichts weiter als ein Wrapper für setTimeout ist:

// 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;
};

Sie können es dann wie erwartet in einer Reihe von Funktionsaufrufen verwenden:

$('#warning')
.addClass('highlight')
.delay(1000)
.removeClass('highlight');

Ich habe auch nach Schlaflösung gesucht (nicht nach Produktionscode, nur nach Entwicklern / Tests) und diesen Artikel gefunden:

http://narayanraman.blogspot.com/2005/12/javascript-sleep-or-wait.html

... und hier ist ein weiterer Link zu clientseitigen Lösungen: http://www.devcheater.com/

Wenn Sie anrufen alert(), wird auch Ihr Code angehalten, während die Warnung angezeigt wird. Sie müssen einen Weg finden, um die Warnung nicht anzuzeigen, aber den gleichen Effekt zu erzielen. :) :)

Hier ist eine einfache Lösung mit einem synchronen XMLHttpRequest:

function sleep(n){
  var request = new XMLHttpRequest();
  request.open('GET', '/sleep.php?n=' + n, false);  // `false` makes the request synchronous
  request.send(null);
}

Inhalt von sleep.php:

<?php sleep($_GET['n']);

Nennen Sie es jetzt mit: sleep (5);

Bitte schön. Wie der Code sagt, sei kein schlechter Entwickler und benutze dies auf Websites. Es ist eine Entwicklungsdienstprogrammfunktion.

// 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) {}
}

Ich persönlich mag das einfache:

function sleep(seconds){
    var waitUntil = new Date().getTime() + seconds*1000;
    while(new Date().getTime() < waitUntil) true;
}

dann:

sleep(2); // Sleeps for 2 seconds

Ich benutze es die ganze Zeit, um falsche Ladezeiten zu erstellen, während ich Skripte in P5js erstelle

Zuerst:

Definieren Sie eine Funktion, die Sie wie folgt ausführen möchten:

function alertWorld(){
  alert("Hello World");
}

Planen Sie dann die Ausführung mit der setTimeout-Methode:

setTimeout(alertWorld,1000)

Beachten Sie zwei Dinge

• Das zweite Argument ist die Zeit in Millisekunden
• Als erstes Argument müssen Sie nur den Namen (die Referenz) der Funktion ohne die Klammer übergeben

  await new Promise(resolve => setTimeout(resolve, 2000));

Stellen Sie sicher, dass Ihre aufrufende Funktion asynchron ist

verifiziert und funktioniert gut

Eine bessere Lösung, um die Dinge so aussehen zu lassen, wie es die meisten Menschen wollen, ist die Verwendung einer anonymen Funktion:

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

Dies ist wahrscheinlich der nächste Schritt zu etwas, das einfach das tut, was Sie wollen.

Hinweis: Wenn Sie mehrere Schlafplätze benötigen, kann dies in Eile hässlich werden und Sie müssen möglicherweise Ihr Design überdenken.

Für Browser stimme ich zu, dass setTimeout und setInterval der richtige Weg sind.

Für serverseitigen Code ist möglicherweise eine Blockierungsfunktion erforderlich (z. B. um eine effektive Thread-Synchronisierung durchzuführen).

Wenn Sie node.js und meteor verwenden, sind Sie möglicherweise auf die Einschränkungen bei der Verwendung von setTimeout in einer Glasfaser gestoßen. Hier ist der Code für den serverseitigen Ruhezustand.

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');

Siehe: https://github.com/laverdet/node-fibers#sleep

Ich würde setTimeOut in ein Versprechen für Codekonsistenz mit anderen asynchronen Aufgaben einkapseln: Demo in Fiddle

function sleep(ms)
{
    return(new Promise(function(resolve, reject) {        
        setTimeout(function() { resolve(); }, ms);        
    }));    
}

So verwendet:

sleep(2000).then(function() { 
   // Do something
});

Es ist leicht, sich die Syntax zu merken, wenn Sie Promises verwendet haben.

2019 Update mit Atomics.wait

Sollte in Knoten 9.3 oder höher funktionieren.

Ich brauchte einen ziemlich genauen Timer in Node.js und es funktioniert großartig dafür. Es scheint jedoch, dass die Unterstützung in Browsern äußerst begrenzt ist.

let ms = 10000;
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);

Lief ein paar 10-Sekunden-Timer-Benchmarks.

Mit setTimeout erhalte ich einen Fehler von bis zu 7000 Mikrosekunden. (7 ms)

Mit Atomics scheint mein Fehler unter 600 Mikrosekunden zu bleiben. (0,6 ms)

Update 2020: Zusammenfassend

function sleep(millis){ // need help of a server-side page
  let netMillis=Math.max(millis-5,0); //assuming 5ms 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 1ms 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);
}

davon sleep.jspsieht die serverseitige Seite zB aus

<%
try{
  Thread.sleep(Long.parseLong(request.getParameter("millis")));
}catch(InterruptedException e){}
%>

Die meisten Antworten hier sind falsch oder zumindest veraltet. Es gibt keinen Grund, warum Javascript Single-Threaded sein muss, und das ist es auch nicht. Heute unterstützen alle gängigen Browser Worker, bevor dies der Fall war, unterstützten andere Javascript-Laufzeiten wie Rhino und Node.js Multithreading.

'Javascript is single threaded' ist keine gültige Antwort. Wenn Sie beispielsweise eine Sleep-Funktion in einem Worker ausführen, wird der im UI-Thread ausgeführte Code nicht blockiert.

In neueren Laufzeiten, die Generatoren und Ertrag unterstützen, könnte man der Sleep-Funktion in einer Umgebung mit einem Thread ähnliche Funktionen hinzufügen:

// This is based on the latest ES6 drafts.
// js 1.7+ (SpiderMonkey/Firefox 2+) syntax is slightly different

// run code you want to sleep here (ommit star if using js 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(){
        // ommit .value if using js 1.7
        var nextSleep = generator.next().value;
        resume(nextSleep, generator);
    }, ms);
}

// initialize generator and get first sleep for recursive function
var
    generator = main(),
    firstSleep = generator.next().value;

// initialize recursive resume function
resume(firstSleep, generator);

Diese Nachahmung des Schlafes unterscheidet sich von einer echten Schlaffunktion, da sie den Thread nicht blockiert. Es ist einfach Zucker zusätzlich zu der aktuellen setTimeout-Funktion von Javascript. Dieser Funktionstyp wurde in Task.js implementiert und sollte heute in Firefox funktionieren.

Ich habe einige Webseiten über Javascript Sleep / Wait durchsucht / gegoogelt ... und es gibt KEINE Antwort, wenn Sie möchten, dass Javascript "RUN, DELAY, RUN" ist ... was die meisten Leute auch bekamen, war "RUN, RUN" (nutzlos) Zeug), RUN "oder" RUN, RUN + verzögert RUN "....

Also habe ich ein paar Burger gegessen und mir Gedanken gemacht ::: Hier ist eine Lösung, die funktioniert ... aber du musst deine laufenden Codes zerhacken ... ::: Ja, ich weiß, das ist nur ein einfacher zu lesendes Refactoring. . immer noch...

//......................................... //Beispiel 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>

// .................................... // Beispiel2:

<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>

// ................. Beispiel3:

<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>

// .............. Beispiel4:

<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>

function sleep(milliseconds) {
  var start = new Date().getTime();
  for (var i = 0; i < 1e7; i++) {
    if ((new Date().getTime() - start) > milliseconds){
      break;
    }
  }
}

Die kürzeste Lösung ohne Abhängigkeiten:

await new Promise(resolve => setTimeout(resolve, 5000));

In JavaScript kann man so nicht schlafen, oder eher nicht. Wenn Sie eine Schlaf- oder eine while-Schleife ausführen, bleibt der Browser des Benutzers hängen, bis die Schleife abgeschlossen ist.

Verwenden Sie einen Timer, wie in dem Link angegeben, auf den Sie verwiesen haben.

Ein Szenario, in dem Sie möglicherweise eine sleep () - Funktion anstelle von setTimeout () wünschen, besteht darin, dass Sie eine Funktion haben, die auf einen Benutzerklick reagiert und letztendlich ein neues Popup-Fenster öffnet, und dass Sie eine Verarbeitung eingeleitet haben, die einen kurzen Zeitraum erfordert zu vervollständigen, bevor das Popup angezeigt wird. Wenn Sie das geöffnete Fenster in einen geschlossenen Zustand verschieben, wird es normalerweise vom Browser blockiert.

Ich kann den Zweck einer Schlaffunktion verstehen, wenn Sie sich mit synchroner Ausführung befassen müssen. Die Funktionen setInterval und setTimeout erstellen einen parallelen Ausführungsthread, der die Ausführungssequenz an das Hauptprogramm zurückgibt. Dies ist unwirksam, wenn Sie auf ein bestimmtes Ergebnis warten müssen. Natürlich kann man Ereignisse und Handler verwenden, aber in einigen Fällen ist dies nicht beabsichtigt.

Meine zwei Bits hinzufügen. Ich musste zu Testzwecken warten. Ich wollte den Code nicht aufteilen, da dies eine Menge Arbeit bedeuten würde.

for (var i=0;i<1000000;i++){                    
     //waiting
  }

Ich sehe keinen Nachteil darin und es hat den Trick für mich getan.

Dies kann mit der Schlafmethode von Java erfolgen. Ich habe es in FF und IE getestet und es sperrt den Computer nicht, zerkaut keine Ressourcen und verursacht keine endlosen Server-Treffer. Scheint mir eine saubere Lösung zu sein.

Zuerst müssen Sie Java auf die Seite laden und seine Methoden verfügbar machen. Um das zu tun, habe ich Folgendes getan:

<html>
<head>

<script type="text/javascript">

  function load() {
    var appletRef = document.getElementById("app");
    window.java = appletRef.Packages.java;
  } // endfunction

</script>

<body onLoad="load()">

<embed id="app" code="java.applet.Applet" type="application/x-java-applet" MAYSCRIPT="true" width="0" height="0" />

Dann müssen Sie nur noch Folgendes tun, wenn Sie eine schmerzlose Pause in Ihrem JS wünschen:

java.lang.Thread.sleep(xxx)

Wobei xxx die Zeit in Millisekunden ist. In meinem Fall (zur Rechtfertigung) war dies Teil der Erfüllung von Back-End-Bestellungen in einem sehr kleinen Unternehmen, und ich musste eine Rechnung drucken, die vom Server geladen werden musste. Dazu habe ich die Rechnung (als Webseite) in einen iFrame geladen und dann den iFrame gedruckt. Natürlich musste ich warten, bis die Seite vollständig geladen war, bevor ich drucken konnte, also musste der JS pausieren. Dies wurde erreicht, indem die Rechnungsseite (im iFrame) mit dem Ereignis onLoad ein ausgeblendetes Formularfeld auf der übergeordneten Seite änderte. Und der Code auf der übergeordneten Seite zum Drucken der Rechnung sah folgendermaßen aus (irrelevante Teile aus Gründen der Übersichtlichkeit):

var isReady = eval('document.batchForm.ready');
isReady.value=0;

frames['rpc_frame'].location.href=url;

while (isReady.value==0) {
  java.lang.Thread.sleep(250);
} // endwhile

window.frames['rpc_frame'].focus();
window.frames['rpc_frame'].print();

Der Benutzer drückt also die Taste, das Skript lädt die Rechnungsseite, wartet, überprüft jede Viertelsekunde, ob die Rechnungsseite vollständig geladen ist, und öffnet dann den Druckdialog, damit der Benutzer sie an den Drucker senden kann. QED.

Viele der Antworten beantworten die Frage nicht (direkt) und diese auch nicht ...

Hier sind meine zwei Cent (oder Funktionen):

Wenn Sie weniger klobige Funktionen als setTimeoutund möchten setInterval, können Sie sie in Funktionen einschließen, die nur die Reihenfolge der Argumente umkehren und ihnen nette Namen geben:

function after(ms, fn){ setTimeout(fn, ms); }
function every(ms, fn){ setInterval(fn, ms); }

CoffeeScript-Versionen:

after = (ms, fn)-> setTimeout fn, ms
every = (ms, fn)-> setInterval fn, ms

Sie können sie dann mit anonymen Funktionen gut verwenden:

after(1000, function(){
    console.log("it's been a second");
    after(1000, function(){
        console.log("it's been another second");
    });
});

Jetzt liest es sich leicht als "nach N Millisekunden, ..." (oder "alle N Millisekunden, ...")

Für den speziellen Fall, dass eine Reihe von Aufrufen, die von einer Schleife ausgeführt werden, entfernt werden sollen, können Sie mit dem Prototyp den folgenden Code verwenden. Ohne Prototyp können Sie die Verzögerungsfunktion durch setTimeout ersetzen.

function itemHandler(item)
{
    alert(item);
}

var itemSet = ['a','b','c'];

// Each call to itemHandler will execute
// 1 second apart
for(var i=0; i<itemSet.length; i++)
{
    var secondsUntilExecution = i;
    itemHandler.delay(secondsUntilExecution, item)
}

Wenn Sie sich auf node.js befinden, können Sie sich die Fasern ansehen - eine native C-Erweiterung für Node, eine Art Multithreading-Simulation.

Es ermöglicht Ihnen, eine echte zu tun sleep auf eine Weise zu erstellen, die die Ausführung in einer Faser blockiert, aber im Hauptfaden und anderen Fasern nicht blockiert.

Hier ist ein Beispiel, das frisch aus ihrer eigenen Readme stammt:

// sleep.js

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');

- und die Ergebnisse sind:

$ node sleep.js
wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)