Implementierung des Golang-Defer-Konzepts in Javascript

In Go verschiebt eine Defer-Anweisung die Ausführung einer Funktion, bis die umgebende Funktion zurückkehrt. Hier ist ein einfaches Beispiel:

package main

import "fmt"


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

In diesem Beispiel wird die Hauptfunktion normal ausgeführt, alle verzögerten Funktionen werden jedoch in umgekehrter Reihenfolge ausgeführt, wenn die Funktion beendet wird. Die Ausgabe lautet also:

start
end
defer 2
defer 1

Das Hinzufügen des Schlüsselworts „defer“ zu JavaScript erfordert viel Arbeit. Aber das ist es, was ich an JS liebe – es ist so vielseitig, dass Sie Funktionen aus anderen Programmiersprachen implementieren können, ohne den Compiler anfassen zu müssen.

Aber zuerst: Warum sollten wir das brauchen?

Es gibt viele nützliche Anwendungsfälle für eine aufschiebende Funktionalität in der Programmierung, wie zum Beispiel:

• Ressourcenbereinigung: Bereinigen Sie Ressourcen wie Dateihandles.
• Transaktionale Vorgänge: Machen Sie Änderungen im Fehlerfall rückgängig, z. B. das Zurücksetzen einer Datenbank oder eine Statusaktualisierung.
• Protokollierung: Protokollierung am Ende eines Vorgangs hinzufügen.
• UI-Statusverwaltung: Status nach einem Prozess zurücksetzen.

Und die Liste geht weiter...

Jetzt tauchen wir in den unterhaltsamen Teil ein: unsere Implementierung von defer in 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)

Ausgabe:

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

Wie erwartet werden die verzögerten Funktionen in umgekehrter Reihenfolge ausgeführt, nachdem die Hauptfunktion abgeschlossen wurde.

Danke,

Ahmed

Das obige ist der detaillierte Inhalt vonImplementierung des Golang-Defer-Konzepts in Javascript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!