Wie ändere ich die Intervallzeit dynamisch in der For-Schleife entsprechend der Index- / Iterationsnummer?

Da ich keinen Kommentar abgeben konnte, bin ich gezwungen, diesen Beitrag zu schreiben. Ich habe den folgenden Code erhalten, der genau 1 Sekunde oder 1000 Millisekunden verzögert / wartet -

let n = 5;
for (let i=1; i<n; i++)
{
  setTimeout( function timer()
  {
      console.log("hello world");
  }, i*1000 );
}

Aber wie kann ich es auf 1000 Sekunden anstatt auf 1000 Millisekunden verzögern, damit das Warten von der Iterationsnummer abhängt?

Wenn zum Beispiel n = 5 ist, möchte ich die Schleifenverzögerung 1 Sekunde in der 1. Iteration. 2 Sekunden in der zweiten Iteration und so weiter. Die endgültige Verzögerung beträgt 5 Sekunden.

Hier ist eine Funktion, die sofort angezeigt wird, dann 1 Sekunde später, 2 Sekunden danach, 3 Sekunden danach usw. Keine spezielle Mathematik, keine Versprechen erforderlich

const n = 5;
let cnt=0;

function show() {
  console.log("call "+cnt,"delay: ",cnt,"sec");
  cnt++;
  if (cnt > n) return; // we are done
  setTimeout(show, cnt*1000 ); // cnt seconds later
}
show()

Während diese Aufgabe mit Versprechungen, reaktiven Streams und anderen coolen Tools gelöst werden könnte (hey, noch hat niemand vorgeschlagen, Arbeiter einzusetzen!), Kann sie auch mit ein wenig Arithmetik gelöst werden.

Sie möchten also Zeitüberschreitungen in einer Sequenz: 1s, die vorherige + 2s, die vorherige + 3s und so weiter. Diese Sequenz lautet: 1, 3, 6, 10, 15 ... und ihre Formel lautet a[n] = n * (n + 1) / 2. Wissend, dass...

let n = 6;
console.log(new Date().getSeconds());

for (let i = 1; i < n; i++) {
  setTimeout(function timer() {
    console.log(new Date().getSeconds());
  }, 1000 * i * (i + 1) / 2);
}

Sie können versuchen, mit async / await (Promises) Ihren Code zu serialisieren:

const waitSeconds = seconds => new Promise(resolve => setTimeout(resolve, seconds))

async function main () {
 let oldDate = new Date()
 let newDate
 
 /* 
  * If you put 'await' inside the loop you can synchronize the async code, and simulate
  * a sleep function
  */
 for (let i=1; i<5; i++) {
    await waitSeconds(i*1000)
    newDate = new Date()   
    console.log(`Loop for i=${i}, elapsed=${moment(newDate).diff(oldDate, 'seconds')} seconds`)
    oldDate = newDate
 }
 
 console.log('End')
}

main()

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.24.0/moment.min.js"></script>

Ich habe einige Zeit gebraucht, um Ihre Frage xD zu entschlüsseln, aber ist es das, was Sie wollen?

Dadurch wird console.log jedes Mal mit einer Verzögerung von i * 1000 ausgelöst . Das erste Mal ist es 1 Sekunde lang (1 * 1000), das nächste Mal 2 Sekunden und so weiter.

let i = 0;
loop = () => {
  setTimeout(() => {
    console.log(new Date()); // for clarity
    i++;
    if (i < 10) {
      loop();
    }
  }, i * 1000)
};
loop();

Die Schleife wartet nicht auf den Abschluss der Timeout-Funktion. Wenn die Schleife ausgeführt wird, wird Ihre Warnung für jeden Index geplant.

Sie können eine Funktion verwenden, die gemäß Ihrem Index ausgeführt wird, aber gleichzeitig geplant ist. Sie können den Unterschied von 3 Sekunden fühlen.

function test(i){
    setTimeout( function timer(){
        console.log("hello world" + i);
    }, i*3000);
}
for (let i=1; i<4; i++) {
   test(i);
}

Verwenden Sie rekursive Aufrufe anstelle der for-Schleife

let i=1;
function a(i) {
  if (i > 5)
    return
  else
    b("message", i)
}

function b(s, f) {
  setTimeout(function timer() {
    console.log(s + " " + f + " seconds");
  }, f * 1000);
  a(++i);
}
a(i);