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

les promesses JavaScript natives n'ont pas de mécanisme de temporisation.

La question à propos de votre mise en œuvre serait probablement un meilleur ajustement pour http://codereview.stackexchange.com, mais quelques remarques:

1. vous ne fournissez pas un moyen de réellement faire quoi que ce soit dans la promesse, et

2. Il n'y a pas besoin de clearTimeout dans votre setTimeout rappel, depuis setTimeout horaires un one-off minuterie.

3. Puisqu'une promesse ne peut pas être résolue/rejetée une fois qu'elle a été résolue/rejetée, vous n'avez pas besoin de cette vérification.

alors peut-être quelque chose dans ce sens:

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

utilise comme ceci:

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

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

je serais légèrement préoccupé par le fait que la sémantique sont légèrement différents (Non new, alors que vous ne l'utilisez newPromise constructeur), donc vous pouvez ajuster cela.

l'autre problème, bien sûr, est que la plupart du temps, vous ne voulez pas construire de nouvelles promesses, et donc ne pouvait pas utiliser ce qui précède. La plupart du temps, vous avez déjà une promesse (le résultat d'un précédent then appel, etc.). Mais pour les situations où vous construisez vraiment une nouvelle promesse, vous pourriez utiliser quelque chose comme ce qui précède.

Vous peut faire face à la new chose subclassing 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 Example:

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

<!-- 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>

les deux appelleront reject quand le timer expire même si le callback appelle resolve ou reject en premier. C'est très bien, l'état d'une promesse ne peut pas être modifié une fois qu'elle est définie, et le spec définit les appels à resolve ou reject sur une promesse de déjà réglé comme un rien qui ne soulève pas d'erreur.

Mais si cela vous dérange, vous pouvez envelopper resolve et reject. Ici myPromise fait de cette manière:

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 le faire de 18 façons différentes, mais le concept de base est que le resolve et reject nous transmettons l'exécuteur de la promesse que nous recevons sont des enveloppes qui libèrent le minuteur.

Mais, qui crée des fonctions et des appels de fonctions supplémentaires dont vous n'avez pas besoin. La spec est clair sur ce que les fonctions de résolution font lorsque la promesse est déjà résolue; ils quittent assez tôt.