Script uitvoeren na specifieke vertraging met JavaScript

Is er een JavaScript-methode vergelijkbaar met de jQuery delay()of wait()(om de uitvoering van een script voor een bepaalde tijd uit te stellen)?

Antwoord 1, autoriteit 100%

Om toe te voegen aan wat iedereen heeft gezegd over setTimeout:
Als u in de toekomst een functie met een parameter wilt aanroepen, moet u enkele anonieme functieaanroepen instellen.

Je moet de functie als argument doorgeven om deze later te kunnen aanroepen. In feite betekent dit zonder haakjes achter de naam. Het volgende roept de waarschuwing meteen op en er wordt ‘Hallo wereld’ weergegeven:

var a = "world";
setTimeout(alert("Hello " + a), 2000);

Om dit op te lossen kun je ofwel de naam van een functie invoeren (zoals Flubba heeft gedaan) of je kunt een anonieme functie gebruiken. Als u een parameter moet doorgeven, moet u een anonieme functie gebruiken.

var a = "world";
setTimeout(function(){alert("Hello " + a)}, 2000);
a = "Stack Overflow";

Maar als je die code uitvoert, zul je merken dat na 2 seconden de pop-up ‘Hallo Stack Overflow’ zal zeggen. Dit komt omdat de waarde van de variabele a in die twee seconden is veranderd. Om hem na twee seconden ‘Hallo wereld’ te laten zeggen, moet je het volgende codefragment gebruiken:

function callback(a){
    return function(){
        alert("Hello " + a);
    }
}
var a = "world";
setTimeout(callback(a), 2000);
a = "Stack Overflow";

Het wacht 2 seconden en verschijnt dan ‘Hallo wereld’.

Antwoord 2, autoriteit 79%

Er is het volgende:

setTimeout(function, milliseconds);

functie die kan worden doorgegeven na hoeveel tijd de functie wordt uitgevoerd.

Zie: Venster setTimeout()-methode.

Antwoord 3, autoriteit 16%

Om een ​​beetje uit te breiden… U kunt code rechtstreeks uitvoeren in de setTimeout-aanroep, maar als @patrickzegt dat je normaal gesproken een callback-functie toewijst, zoals deze. De tijd is milliseconden

setTimeout(func, 4000);
function func() {
    alert('Do stuff here');
}

Antwoord 4, autoriteit 11%

Als je echt een blokkerende (synchrone) delay-functie wilt hebben (voor wat dan ook), waarom zou je dan niet zoiets doen:

<script type="text/javascript">
    function delay(ms) {
        var cur_d = new Date();
        var cur_ticks = cur_d.getTime();
        var ms_passed = 0;
        while(ms_passed < ms) {
            var d = new Date();  // Possible memory leak?
            var ticks = d.getTime();
            ms_passed = ticks - cur_ticks;
            // d = null;  // Prevent memory leak?
        }
    }
    alert("2 sec delay")
    delay(2000);
    alert("done ... 500 ms delay")
    delay(500);
    alert("done");
</script>

Antwoord 5, autoriteit 6%

Je moet setTimeoutgebruiken en een callback-functie doorgeven. De reden dat je slaap niet in javascript kunt gebruiken, is omdat je in de tussentijd de hele pagina zou blokkeren. Geen goed plan. Gebruik het gebeurtenismodel van Javascript en blijf tevreden. Vecht er niet tegen!

Antwoord 6, autoriteit 6%

U kunt ook window.setInterval()gebruiken om enkele code herhaaldelijk met regelmatige tussenpozen.

Antwoord 7, autoriteit 5%

Als aanvulling op de eerdere opmerkingen, wil ik het volgende zeggen:

De functie setTimeout()in JavaScript pauzeert de uitvoering van het script niet per se, maar vertelt de compiler alleen dat de code ergens in de toekomst moet worden uitgevoerd.

Er is geen functie die de uitvoering daadwerkelijk kan pauzeren, ingebouwd in JavaScript. U kunt echter uw eigen functie schrijven die zoiets doet als een onvoorwaardelijke lus totdat de tijd is bereikt door de functie Date()te gebruiken en het benodigde tijdsinterval toe te voegen.

Antwoord 8, autoriteit 5%

Als u alleen een vertraging hoeft te testen, kunt u dit gebruiken:

function delay(ms) {
   ms += new Date().getTime();
   while (new Date() < ms){}
}

En als je dan 2 seconden wilt uitstellen, doe je:

delay(2000);

Misschien niet het beste voor productie. Meer daarover in de reacties

Antwoord 9, autoriteit 2%

waarom kun je de code niet achter een belofte plaatsen? (uit mijn hoofd getypt)

new Promise(function(resolve, reject) {
  setTimeout(resolve, 2000);
}).then(function() {
  console.log('do whatever you wanted to hold off on');
});

setTimeout(
    function () {
        x = 1;
    }, 1000);

setTimeout(window.history.back(), 3000);

setTimeout(function() {window.history.back()}, 3000);

//  Show current seconds and milliseconds
//  (I know there are other ways, I was aiming for minimal code
//  and fixed width.)
function secs()
{
    var s = Date.now() + ""; s = s.substr(s.length - 5);
  return s.substr(0, 2) + "." + s.substr(2);
}
//  Log we're loading
console.log("Loading: " + secs());
//  Create a list of commands to execute
var cmds = 
[
    function() { console.log("A: " + secs()); },
    function() { console.log("B: " + secs()); },
    function() { console.log("C: " + secs()); },
    function() { console.log("D: " + secs()); },
    function() { console.log("E: " + secs()); },
  function() { console.log("done: " + secs()); }
];
//  Run each command with a second delay in between
var ms = 1000;
cmds.forEach(function(cmd, i)
{
    setTimeout(cmd, ms * i);
});
// Log we've loaded (probably logged before first command)
console.log("Loaded: " + secs());

Loading: 03.077
Loaded: 03.078
A: 03.079
B: 04.075
C: 05.075
D: 06.075
E: 07.076
done: 08.076

function executeWithDelay(anotherFunction) {
    setTimeout(anotherFunction, delayInMilliseconds);
}

/**
 * delay or pause for some time
 * @param {number} t - time (ms)
 * @return {Promise<*>}
 */
const delay = async t => new Promise(resolve => setTimeout(resolve, t));

await delay(1000);

function delay(milisecondDelay) {
   milisecondDelay += Date.now();
   while(Date.now() < milisecondDelay){}
}
alert('Ill be back in 5 sec after you click OK....');
delay(5000);
alert('# Im back # date:' +new Date());