Wacht 5 seconden voordat u de volgende regel uitvoert

Deze functie hieronder werkt niet zoals ik zou willen; omdat ik een JS-beginner ben, begrijp ik niet waarom.

Ik wil dat het 5 seconden wacht voordat ik kan controleren of de newState-1is.

Momenteel wacht het niet, het controleert gewoon meteen.

function stateChange(newState) {
  setTimeout('', 5000);
  if(newState == -1) {
    alert('VIDEO HAS STOPPED');
  }
}

Antwoord 1, autoriteit 100%

U moet uw code invoeren in de terugbelfunctie die u aan setTimeoutverstrekt:

function stateChange(newState) {
    setTimeout(function () {
        if (newState == -1) {
            alert('VIDEO HAS STOPPED');
        }
    }, 5000);
}

Elke andere code wordt onmiddellijk uitgevoerd.

Antwoord 2, autoriteit 77%

Hier is een oplossing met behulp van de nieuweasync/waitsyntaxis.

Controleer de browserondersteuningaangezien dit een taalfunctie is die is geïntroduceerd met ECMAScript 6.

Hulpfunctie:

const delay = ms => new Promise(res => setTimeout(res, ms));

Gebruik:

const yourFunction = async () => {
  await delay(5000);
  console.log("Waited 5s");
  await delay(5000);
  console.log("Waited an additional 5s");
};

Het voordeel van deze aanpak is dat uw code eruitziet en zich gedraagt als synchrone code.

Antwoord 3, autoriteit 55%

Je zou dit echt niet moeten doen, het juiste gebruik van time-out is de juiste tool voor het probleem van de OP en elke andere gelegenheid waarbij je na verloop van tijd gewoon iets wilt uitvoeren. Joseph Silber heeft dat goed aangetoond in zijn antwoord. Als u echter in een niet-productiegeval echtde hoofdlijn voor een bepaalde tijd wilt laten hangen, is dit voldoende.

function wait(ms){
   var start = new Date().getTime();
   var end = start;
   while(end < start + ms) {
     end = new Date().getTime();
  }
}

Met uitvoering in de vorm:

console.log('before');
wait(7000);  //7 seconds in milliseconds
console.log('after');

Ik ben hier terechtgekomen omdat ik een eenvoudige testcase aan het bouwen was voor het sequencen van een mix van asynchrone bewerkingen rond langlopende blokkeringsbewerkingen (d.w.z. dure DOM-manipulatie) en dit is mijn gesimuleerde blokkeringsbewerking. Het past goed bij dat werk, dus ik dacht ik post het voor iedereen die hier arriveert met een soortgelijk gebruik. Toch maakt het een Date()-object in een while-lus, die de GC erg kan overweldigen als het lang genoeg duurt. Maar ik kan het niet genoeg benadrukken, dit is alleen geschikt om te testen, voor het bouwen van daadwerkelijke functionaliteit moet je het antwoord van Joseph Silber raadplegen.

Antwoord 4, autoriteit 20%

Als u een async-functieje kunt het gewoon in één regel doen:

console.log(1);
await new Promise(resolve => setTimeout(resolve, 3000)); // 3 sec
console.log(2);

fyi , als doel NODEJS is, kunt u dit gebruiken als u wilt (het is een vooraf gedefinieerde prominsifed SetTimeout-functie):

await setTimeout[Object.getOwnPropertySymbols(setTimeout)[0]](3000) // 3 sec

Antwoord 5, Autoriteit 12%

Gebruik een vertragingsfunctie als volgt:

var delay = ( function() {
    var timer = 0;
    return function(callback, ms) {
        clearTimeout (timer);
        timer = setTimeout(callback, ms);
    };
})();

Gebruik:

delay(function(){
    // do stuff
}, 5000 ); // end delay

Credits: Hoe de .Keyup () handler uit te stellen totdat de gebruiker stopt met typen?

Antwoord 6, Autoriteit 11%

U moet niet alleen proberen om 5 seconden in JavaScript te pauzeren. Het werkt niet op die manier. U kunt een functie van de code plannen om 5 seconden vanaf nu uit te voeren, maar u moet de code plaatsen die u later wilt uitvoeren in een functie en de rest van uw code na die functie zal onmiddellijk worden uitgevoerd.

Bijvoorbeeld:

function stateChange(newState) {
    setTimeout(function(){
        if(newState == -1){alert('VIDEO HAS STOPPED');}
    }, 5000);
}

Maar, als u als volgt hebt:

stateChange(-1);
console.log("Hello");

De instructie console.log()wordt onmiddellijk uitgevoerd. Het zal niet wachten tot nadat de time-out is geactiveerd in de functie stateChange(). Je kunt de uitvoering van javascript niet zomaar voor een vooraf bepaalde tijd pauzeren.

In plaats daarvan moet elke code waarvan u vertragingen wilt gebruiken zich binnen de setTimeout()-callback-functie bevinden (of vanuit die functie worden aangeroepen).

Als je zou proberen te “pauzeren” door een lus te maken, dan zou je de Javascript-interpreter in wezen voor een bepaalde tijd “hangen”. Omdat Javascript uw code in slechts een enkele thread uitvoert, kan niets anders worden uitgevoerd wanneer u een lus uitvoert (geen andere gebeurtenishandlers kunnen worden aangeroepen). Dus lussen wachten tot een variabele wordt gewijzigd, zal nooit werken, omdat er geen andere code kan worden uitgevoerd om die variabele te wijzigen.

Antwoord 7, autoriteit 3%

Deze oplossing is afkomstig van React Native’s documentatie voor een verversingsbesturing:

function wait(timeout) {
    return new Promise(resolve => {
        setTimeout(resolve, timeout);
    });
}

Om dit toe te passen op de vraag van de OP, zou je deze functie kunnen gebruiken in samenwerking met await:

await wait(5000);
if (newState == -1) {
    alert('Done');
}

Antwoord 8, autoriteit 2%

Probeer dit:

//the code will execute in 1 3 5 7 9 seconds later
function exec() {
    for(var i=0;i<5;i++) {
        setTimeout(function() {
            console.log(new Date());   //It's you code
        },(i+i+1)*1000);
    }
}

Antwoord 9, autoriteit 2%

De beste manier om een functie als deze te maken, wacht in milliseconden, deze functie wacht milliseconden die zijn opgegeven in het argument:

function waitSeconds(iMilliSeconds) {
    var counter= 0
        , start = new Date().getTime()
        , end = 0;
    while (counter < iMilliSeconds) {
        end = new Date().getTime();
        counter = end - start;
    }
}

const addNSecondsDelay = (n) => {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve();
    }, n * 1000);
  });
}
const asyncFunctionCall = async () {
  console.log("stpe-1"); 
  await addNSecondsDelay(5);
  console.log("step-2 after 5 seconds delay"); 
}
asyncFunctionCall();

function videoStopped(newState){
   if (newState == -1) {
       alert('VIDEO HAS STOPPED');
   }
}

function wait(milliseconds, foo, arg){
    setTimeout(function () {
        foo(arg); // will be executed after the specified time
    }, milliseconds);
}

wait(5000, videoStopped, newState);

setTimeout(function() {
     $('.message').hide();
}, 5000);

$timeout(function(){
if(yourvariable===-1){
doSomeThingAfter5Seconds();
}
},5000)

function sleep(delay) {
        var start = new Date().getTime();
        while (new Date().getTime() < start + delay);
      }

####Some code
 sleep(1000);
####Next line

   <html>
    <body>
    <a href="E:\game\game.exe" name="game" onmouseout="waitclose(7000);"> game
    <img src="game.jpg" width="100%" height="97%" ></a>
    <script>
    function waitclose(ms){
     var start = new Date().getTime();var end=start;
     while(end < start + ms) {end = new Date().getTime();}
    window.open('', '_self', ''); window.close();
    }
    </script>
    </body>
    </html>