Was ist die JavaScript-Version von sleep()?

Question

Gibt es einen besseren Weg zur Entwicklung einer sleep in JavaScript als die folgenden pausecomp Funktion ( entnommen von hier )?

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

Es handelt sich nicht um ein Duplikat von Sleep in JavaScript - Verzögerung zwischen Aktionen Ich möchte eine echter Schlaf in der Mitte einer Funktion und nicht eine Verzögerung, bevor ein Teil des Codes ausgeführt wird.

Answer 1

Ich habe auch nach einer Lösung für den Ruhezustand gesucht (nicht für Produktionscode, nur für Entwicklung und Tests) und diesen Artikel gefunden:

JavaScript sleep() oder wait()

...und hier ist ein weiterer Artikel mit clientseitigen Lösungen: JavaScript-Schlaf

Auch wenn Sie die alert() Ihr Code wird ebenfalls angehalten, während die Warnung angezeigt wird - Sie müssen einen Weg finden, um die Warnung nicht anzuzeigen, aber den gleichen Effekt zu erzielen :)

Answer 2

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 verwende es ständig, um beim Erstellen von Skripten in p5.js .

Answer 3

Bitte sehr. Wie der Code schon sagt, seien Sie kein schlechter Entwickler und verwenden Sie dies auf Websites. Es ist eine Hilfsfunktion für die Entwicklung.

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

Answer 4

Hier ist eine einfache Lösung mit einer 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 der Datei schlafen.php :

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

Rufen Sie es jetzt mit an:

sleep(5);

Verwendung einer bestehenden Serverimplementierung

Wenn Sie keinen eigenen Anwendungsserver haben (für das obige PHP-Skript), können Sie stattdessen einen Online-Dienst nutzen. Zum Beispiel:

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.");

Unterstützung

Über das Bestehen false für die asynchronous Parameter, mdn Anmerkungen:

Synchrone Anfragen auf dem Haupt-Thread können die Benutzererfahrung leicht stören und sollten vermieden werden; tatsächlich haben viele Browser die synchrone XHR-Unterstützung auf dem Haupt-Thread vollständig veraltet. Synchrone Anfragen sind in Workern erlaubt.

Die tatsächliche Verzögerung

Die Anzahl der Millisekunden, die als Argument übergeben wird, ist die Zeit, die der Server zwischen dem Erhalt der Anfrage und dem Senden der Antwort wartet. Die Verzögerung, die durch die Übertragung und die Serverlast entsteht, beträgt hinzugefügt. dazu.

Answer 5

Update 2019 mit Atomics.wait

Es sollte funktionieren in Node.js 9.3 oder höher.

Ich brauchte einen ziemlich genauen Timer in Node.js, und dafür funktioniert er hervorragend.

Es scheint jedoch, dass die Unterstützung in den Browsern äußerst begrenzt ist.

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

Ich habe ein paar 10-Sekunden-Timer-Benchmarks durchgeführt.

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

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

Update 2020: Zusammenfassung

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

von denen die serverseitige Seite, z. B. sleep.jsp Sieht so aus:

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