Implémentation du concept de report Golang en Javascript

Dans Go, une instruction defer diffère l'exécution d'une fonction jusqu'au retour de la fonction environnante. Voici un exemple simple :

package main

import "fmt"


func main() {
    fmt.Println("start")
    defer fmt.Println("defer 1")
    defer fmt.Println("defer 2")
    fmt.Println("end")
}

Dans cet exemple, la fonction principale s'exécute normalement, mais toutes les fonctions différées sont exécutées dans l'ordre inverse lorsque la fonction se termine. DONC le résultat sera :

start
end
defer 2
defer 1

Maintenant, ajouter le mot-clé defer à JavaScript nécessite beaucoup de travail. Mais c’est ce que j’aime dans JS : il est si polyvalent que vous pouvez implémenter des fonctionnalités d’autres langages de programmation sans avoir à toucher au compilateur.

Mais d’abord, pourquoi aurions-nous besoin de ça ?

Il existe de nombreux cas d'utilisation utiles pour une fonctionnalité de type différé en programmation, tels que :

• Nettoyage des ressources : nettoyez les ressources telles que les descripteurs de fichiers.
• Opérations transactionnelles : annulez les modifications en cas d'erreur, comme l'annulation d'une base de données ou une mise à jour d'état.
• Logging : Ajouter une journalisation à la fin d'une opération.
• Gestion de l'état de l'interface utilisateur : Réinitialiser l'état après un processus.

Et la liste est longue...

Plongeons maintenant dans la partie amusante : notre implémentation de defer en JavaScript.

class Deferer {
  static stack = [];
  static wrapped = false;
  static defer(fn) {
    this.stack.push(fn);
    if (!this.wrapped) {
        throw new Error("can't call defer wihtout wrapping the function with Deferer.wrapper")
    }
  }

  static execute() {
    while (this.stack.length > 0) {
      const fn = this.stack.pop();
      try {
        fn();
      } catch (err) {
        throw new Error('Error in deferred function:', err);
      } 
    }
    this.wrapped = false;
  }

  static wrapper = (cp) => (...args) => {
        if(this.wrapped) throw new Error("nested deferers are not supported");
        this.wrapped = true;
        try {
         const v = cp(...args)
         this.execute()
         return v;
        } finally {
          this.wrapped = false;
        }

  }

}

const myDeferedFunction =Deferer.wrapper((a, b, c) => {
  console.log("Start of function", a, b, c);

  Deferer.defer(() => console.log("Deferred: Function 1"));
  Deferer.defer(() => console.log("Deferred: Function 2"));

  console.log("End of function", a, b, c);
});

myDeferedFunction(8,8,8)

Sortie :

Start of function 8 8 8
End of function 8 8 8
Deferred: Function 2
Deferred: Function 1

Comme prévu, les fonctions différées s'exécutent une fois la fonction principale terminée, dans l'ordre inverse.

Merci,

Ahmed

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!