NodeJS Délai d'attente d'une Promesse si n'a pas pu terminer dans le temps

JavaScript natif promesses n'ont pas de mécanisme d'expiration.

La question au sujet de votre mise en œuvre serait probablement un meilleur ajustement pour http://codereview.stackexchange.com, mais un couple de notes:

1. Vous ne fournissez pas un moyen de réellement faire quelque chose dans la promesse, et

2. Il n'y a pas besoin de clearTimeout au sein de votre setTimeout rappel, depuis setTimeout les horaires d'une minuterie.

3. Depuis une promesse ne peut pas être résolu, rejetée une fois qu'il a été résolu, rejetée, vous n'avez pas besoin de vérifier.

Donc peut-être quelque chose le long de ces lignes:

function myPromise(ms, callback) {
    return new Promise(function(resolve, reject) {
        //Set up the real work
        callback(resolve, reject);

        //Set up the timeout
        setTimeout(function() {
            reject('Promise timed out after ' + ms + ' ms');
        }, ms);
    });
}

Utilisée comme ceci:

myPromise(2000, function(resolve, reject) {
    //Real work is here
});

(Ou vous peut voulez qu'il soit un peu plus compliqué, voir mise à jour sous la ligne ci-dessous.)

Je serais un peu préoccupé par le fait que la sémantique sont légèrement différents (pas de new, alors que vous ne l'utilisez new avec le Promise constructeur), de sorte que vous pouvez ajuster qui.

L'autre problème, bien sûr, est que la plupart du temps, vous ne voulez pas construire de nouvelles promesses, et donc ne pourrait pas utiliser les ci-dessus. La plupart du temps, vous avez une promesse déjà (à la suite d'une précédente then appel, etc.). Mais pour les situations où vous êtes vraiment à la construction d'une nouvelle promesse, vous pouvez utiliser quelque chose comme ci-dessus.

Vous pouvez traiter avec le new chose par sous-classement Promise:

class MyPromise extends Promise {
    constructor(ms, callback) {
        //We need to support being called with no milliseconds
        //value, because the various Promise methods (`then` and
        //such) correctly call the subclass constructor when
        //building the new promises they return.
        //This code to do it is ugly, could use some love, but it
        //gives you the idea.
        let haveTimeout = typeof ms === "number" && typeof callback === "function";
        let init = haveTimeout ? callback : ms;
        super((resolve, reject) => {
            init(resolve, reject);
            if (haveTimeout) {
                setTimeout(() => {
                    reject("Timed out");
                }, ms);
            }
        });
    }
}

Utilisation:

let p = new MyPromise(300, function(resolve, reject) {
    //...
});
p.then(result => {
})
.catch(error => {
});

Live Exemple:

JS:

//Uses var instead of let and non-arrow functions to try to be
//compatible with browsers that aren't quite fully ES6 yet, but
//do have promises...
(function() {
    "use strict";
    
    class MyPromise extends Promise {
        constructor(ms, callback) {
            var haveTimeout = typeof ms === "number" && typeof callback === "function";
            var init = haveTimeout ? callback : ms;
            super(function(resolve, reject) {
                init(resolve, reject);
                if (haveTimeout) {
        	        setTimeout(function() {
    	                reject("Timed out");
	                }, ms);
                }
            });
        }
    }
    
    var p = new MyPromise(100, function(resolve, reject) {
        //We never resolve/reject, so we test the timeout
    });
    p.then(function(result) {
    	snippet.log("Resolved: " + result);
    }).catch(function(reject) {
        snippet.log("Rejected: " + reject);
    });
})();

HTML:

<!-- Script provides the `snippet` object, see http://meta.stackexchange.com/a/242144/134069 -->
<script src="http://tjcrowder.github.io/simple-snippets-console/snippet.js"></script>

---

À la fois de ceux qui vont appeler reject lorsque le délai expire, même si le rappel appelle resolve ou reject premier. C'est très bien, une promesse de partage de l'état ne peut pas être modifiée une fois qu'elle est, et la spécification définit les appels à resolve ou reject sur une promesse qui est déjà réglés comme des faire-riens qui ne soulèvent pas une erreur.

Mais si cela vous dérange, vous pouvez envelopper resolve et reject. Voici myPromise fait de cette façon:

function myPromise(ms, callback) {
    return new Promise(function(resolve, reject) {
        //Set up the timeout
        let timer = setTimeout(function() {
            reject('Promise timed out after ' + ms + ' ms');
        }, ms);
        let cancelTimer = _ => {
            if (timer) {
                clearTimeout(timer);
                timer = 0;
            }
        };

        //Set up the real work
        callback(
            value => {
                cancelTimer();
                resolve(value);
            },
            error => {
                cancelTimer();
                reject(error);
            }
        );
    });
}

Vous pouvez tourner que sur 18 façons différentes, mais le concept de base est que le resolve et reject nous passons la promesse exécuteur nous recevons sont des wrappers qui claire de la minuterie.

Mais, qui crée les fonctions et les fonctions supplémentaires des appels que vous n'avez pas besoin. La spécification est clair sujet de ce que la résolution des fonctions ne lorsque la promesse est déjà résolu; ils ont quitté très tôt.

C'est un peu vieille question, mais je suis tombé sur ça quand j'étais à la recherche comment en attente d'une promesse.

Alors que toutes les réponses sont grands, j'ai trouvé à l'aide de bluebird mise en œuvre des Promesses comme le moyen le plus facile de manipulation des délais d'attente:

var Promise = require('bluebird');
var p = new Promise(function(reject, resolve) { /.../ });
p.timeout(3000) //make the promise timeout after 3000 milliseconds
 .then(function(data) { /handle resolved promise/ })
 .catch(Promise.TimeoutError, function(error) { /handle timeout error/ })
 .catch(function(error) { /handle any other non-timeout errors/ });

Comme vous pouvez le voir c'est donc beaucoup moins de travail que les autres solutions proposées. J'ai pensé que je vais le mettre ici pour le rendre plus facile pour les gens à trouver 🙂

Btw, je ne suis pas par tous les moyens impliqués dans le projet bluebird, juste trouvé cette solution très soignée.

Alors que les réponses données ici sont valables, vous ne devriez pas essayer de réinventer la roue et d'utiliser l'une des dizaines de paquets disponibles sur NPM pour l'auto-résolution de la promesse.

Voici un exemple de MNP:

const { TimeoutResolvePromise, TimeoutRejectPromise } = require('nodejs-promise-timeout');
const TIMEOUT_DELAY = 2000;

//This promise will reject after 2 seconds:
let promise1 = new TimeoutRejectPromise(TIMEOUT_DELAY, (resolve, reject) => {
  //Do something useful here, then call resolve() or reject()
});