Come modificare dinamicamente il tempo di intervallo in For Loop in base al numero indice / iterazione?

Dal momento che non ho potuto commentare, sono costretto a scrivere questo post. Ho ottenuto il codice seguente che ritarda / attende esattamente 1 secondo o 1000 millisecondi -

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

Ma come posso ritardare i * 1000 secondi anziché i fissi 1000 millisecondi, quindi l'attesa dipende dal numero di iterazione?

Ad esempio, se n = 5, quindi voglio il ritardo del loop di 1 secondo nella prima iterazione. 2 secondi nella seconda iterazione e così via .. il ritardo finale sarà di 5 secondi.

Ecco una funzione che verrà mostrata immediatamente, quindi 1 secondo dopo, 2 secondi dopo, 3 secondi dopo ecc. Nessuna matematica speciale, nessuna promessa necessaria

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

Sebbene questo compito possa essere risolto con promesse, flussi reattivi e altri strumenti interessanti (ehi, nessuno ha ancora suggerito di usare i lavoratori!), Può anche essere risolto con un po 'di aritmetica.

Quindi vuoi timeout in una sequenza: 1s, il precedente + 2s, il precedente + 3s e così via. Questa sequenza è: 1, 3, 6, 10, 15 ... e la sua formula è a[n] = n * (n + 1) / 2. Sapendo ciò...

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

Puoi provare a usare async / await (Promises), per serializzare il tuo codice:

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>

Mi ci è voluto del tempo per decifrare la tua domanda xD, ma è questo quello che vuoi?

Questo continuerà a sparare console.log con i * 1000 di ritardo ogni volta. quindi la prima volta sarà lunga 1 secondo (1 * 1000), poi saranno 2 secondi e così via.

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

Il loop non attende il completamento della funzione di timeout. Pertanto, quando il ciclo viene eseguito, pianifica l'avviso per ciascun indice.

È possibile utilizzare una funzione che verrà eseguita in base all'indice ma pianificata allo stesso tempo. Puoi sentire la differenza di 3 secondi.

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

Usa chiamate ricorsive invece che per loop

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