Comment puis-je intégrer « setTimeout » avec des promesses pour les opérations asynchrones ?

Relier setTimeout avec les promesses

Dans le monde de la programmation asynchrone, les promesses règnent en maître comme moyen de gérer le flux asynchrone des événements . Cependant, accepter les promesses dans toutes les situations peut s'avérer intimidant, en particulier lorsqu'il s'agit de fonctions telles que setTimeout qui manquent intrinsèquement d'une interface basée sur les promesses.

Pour intégrer de manière transparente setTimeout dans le domaine alimenté par les promesses, envisagez l'approche suivante :

Promesse de base : créer un Delay

Supposons que nous souhaitions explorer les bases de la création d'une promesse à partir de setTimeout. Une implémentation simple pourrait ressembler à ceci :

function setTimeoutPromise(delay) {
    return new Promise((resolve) => {
        setTimeout(resolve, delay);
    });
}

Ici, nous exploitons le constructeur Promise pour initialiser une promesse qui encapsule l'exécution retardée de setTimeout.

Amélioration avec valeur : passage une valeur de résolution

Améliorer notre promesse de transmettre une valeur de résolution est également simple dans les environnements prenant en charge des arguments supplémentaires pour setTimeout. Voici comment nous pourrions y parvenir :

function setTimeoutValuePromise(delay, value) {
    return new Promise((resolve) => {
        setTimeout(resolve, delay, value); // Ensure that 'delay' comes before 'value' in argument order
    });
}

Annulabilité : introduction du contrôle sur les promesses

Les promesses sont intrinsèquement immuables, mais nous pouvons étendre notre implémentation pour fournir plus de flexibilité en introduisant un délai annulable. En enveloppant la promesse dans un objet, nous obtenons la possibilité d'annuler le délai d'attente si nécessaire.

function cancellableSetTimeout(delay, value) {
    let timer;
    let reject;
    const promise = new Promise((resolve, _reject) => {
        reject = _reject;
        timer = setTimeout(() => resolve(value), delay);
    });
    return {
        promise,
        cancel() {
            if (timer) {
                clearTimeout(timer);
                timer = null;
                reject();
                reject = null;
            }
        },
    };
}

Cette implémentation permet l'annulation du retard, offrant un niveau de contrôle qui n'est pas intrinsèquement disponible avec les seules promesses.

Démonstration en direct : présentation de promesses infusées setTimeout

Pour être témoin du pouvoir des promesses en action, considérons cet exemple interactif :

// Create a cancellable setTimeout
const cancellableTimeout = cancellableSetTimeout(100, "Message from timeout");

// Handle the promise resolution
cancellableTimeout.promise
    .then((result) => console.log(result)) // Log the resolved value
    .catch(() => console.log("Timeout cancelled")); // Log if the timeout was cancelled

// Simulate cancellation
setTimeout(() => {
    cancellableTimeout.cancel(); // Cancel the timeout after a brief delay
}, 50);

Cette démonstration présente l'approche basée sur les promesses, mettant en évidence à la fois la valeur de résolution et la fonctionnalité d'annulation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!