javascript - then - ¿Hay una versión de setTimeout que devuelve una promesa de ES6?

promises javascript w3schools

Question

Similar a esta pregunta , pero en lugar de preguntar cómo funcionan las promesas en general, quiero saber específicamente:

¿Cuál es la forma estándar / mejor de envolver setTimeout en algo que devuelve una Promise ? Estoy pensando en algo como la función de $timeout Angular, pero no específica de Angular.

Answer 1

En los navegadores

En primer lugar, no, no hay ninguna incorporada para esto. Un montón de bibliotecas que mejoran las promesas de ES2015 como el azote de Bluebird con él.

Creo que la otra respuesta combina la ejecución de la función y un retraso, también crea tiempos de espera que son imposibles de cancelar. Lo escribiría simplemente como:

function delay(ms){
    var ctr, rej, p = new Promise(function (resolve, reject) {
        ctr = setTimeout(resolve, ms);
        rej = reject;
    });
    p.cancel = function(){ clearTimeout(ctr); rej(Error("Cancelled"))};
    return p; 
}

Entonces puedes hacer:

delay(1000).then(/* ... do whatever */);

O

 doSomething().then(function(){ return delay(1000); }).then(doSomethingElse);

Si solo queremos la funcionalidad básica en ES2015, es aún más simple como:

let delay = ms => new Promise(r => setTimeout(r, ms));

En Nodo

Puede usar util.promisify en setTimeout para obtener una función de delay , lo que significa que ya no tiene que usar el new Promise constructor new Promise .

Answer 2

Así es como lo implementaría:

function delay(duration, func) {
  var args = Array.prototype.slice.call(arguments, 2);

  return new Promise(function (resolve) {
    setTimeout(function () {
      resolve(func.apply(null, args));
    }, duration);
  });
}

(ES5-sintaxis elegida intencionalmente)

Pero tal vez hay una biblioteca común que ya hace esto, o una mejor manera de hacerlo.

Answer 3

Si necesita la cancelación adecuada del tiempo de espera prometido similar a clearTimeout , no es conveniente devolver la promesa directamente desde setTimeout . Especialmente cuando se usa con ES7 async / await en el try...finally bloque try...finally . Es mejor tener una variable separada para la manipulación del tiempo de espera. He implementado este enfoque como un pequeño paquete de await-timeout . Funciona de la siguiente manera:

import Timeout from ''await-timeout'';

async function foo() {
  const timeout = new Timeout();
  try {
    const fetchPromise = fetch(''https://example.com'');
    const timerPromise = timeout.set(1000).then(() => console.log(''Timeout!''));
    await Promise.race([fetchPromise, timerPromise]);
  } finally {
    timeout.clear();
  }
}

En este ejemplo, el tiempo de espera definitivamente se borrará en caso de éxito de búsqueda o cualquier error y no se llamará console.log(''Timeout!'') .