Einführung in Go Defer (Go-Delay-Funktion)

Die Verzögerung von

Go-Sprache gilt als neue Funktion der Sprache, zumindest im Vergleich zu den heutigen Mainstream-Programmiersprachen.

Die Defer-Anweisung ruft eine Funktion auf, bis die periphere Funktion zurückkehrt oder die periphere Funktion bis zum Ende ausgeführt wird oder die entsprechende Goroutine in Panik gerät

Wann immer defer ist ausgeführt, es Der nachfolgende Funktionswert (in Go ist die Funktion ein Referenztyp, ein Bürger erster Klasse und kann einer Variablen zugewiesen werden) und Funktionsparameter werden ausgewertet, aber die Funktion wird erst sofort aufgerufen ( ↑ ) treten die oben genannten drei Situationen auf. Dies ist der gesamte Inhalt von defer, weg, der Rest ist die beste Praxis von defer

Die Funktion wird nicht sofort aufgerufen

Beginnen wir mit der einfachsten:

func readFile(fileName string){
    f,err := os.Open(fileName)
    if err!=nil {
        return
    }
    defer f.Close()
    var content [1024]byte
    f.Read(content[:])
    fmt.Printf("%s",content)
}
func main() {
    readFile("test.data")
}

Das Programm gibt die ersten 1024 Bytes von test.data aus. Es ist erwähnenswert, dass Open/Close-Pairing-Operationen wie diese die idiomatische Verwendung von defer darstellen. Dieses Beispiel erklärt die zweite Hälfte des obigen Satzes

„Aber die Funktion wird nicht aufgerufen“

Denn wenn f.Close() nach der Verzögerung nicht verzögert wird, dann ist der Dateideskriptor Wenn sie sind alle geschlossen, es wird nichts gelesen.

Funktionswert und Funktionsparameter werden ausgewertet, aber die Funktion wird nicht sofort aufgerufen

Das folgende Beispiel erklärt die erste Hälfte, sie stammt aus <> , leichte Modifikation:

func trace(funcName string) func(){
    start := time.Now()
    fmt.Printf("function %s enter\n",funcName)
    return func(){
        log.Printf("function %s exit (elapsed %s)",funcName,time.Since(start))
    }
}
 
func foo(){
    defer trace("foo()")()
    time.Sleep(5*time.Second)
}
func main(){
    foo()
    foo()
}
/*
OUTPUT:
function foo() enter
function foo() exit (elapsed 5.0095471s)
function foo() enter
function foo() exit (elapsed 5.0005382s)
*/

Warum wird die Ausgabe von foo eingegeben und dann etwa fünf Sekunden gewartet, bevor die Ausgabe beendet wird? Denn wie gesagt, die Funktionswerte und Parameter nach

defer werden ausgewertet aber die eigentliche Funktion Der Aufruf muss bis zum Ende warten

Der Funktionswert ist hier die anonyme Funktion, die von Trace() zurückgegeben wird. Der Funktionsparameter ist natürlich der String-Literalwert „foo()“. Von Trace("foo()") wird die Ausgabefunktion foo() eingegeben, der eigentliche Funktionsaufruf von Trace("foo()")(), das heißt, die Ausgabefunktion foo() exit(elapsed x.x) wird verschoben bis Return-Ausführung (wenn Return die Rückgabewertvariable aktualisiert, wird sie nach der Aktualisierung ausgeführt, bevor die Defer-Funktion ausgeführt wird).

Verschiedenes

Ein bisschen mehr: Wenn mehrere Defer-Anweisungen vorhanden sind, ist die Ausführungsreihenfolge der letzten Defer-Funktion entgegengesetzt zu der Reihenfolge, in der Defer angezeigt wird, z :

func main() {
    func1 := func(){
        fmt.Println("func1() execution deferred")
    }
    func2 := func(){
        fmt.Println("func2() execution deferred")
    }
    defer func1()
    defer func2()
    fmt.Println("strat\nworking...")
}
/*
OUTPUT:
strat
working...
func2() execution deferred
func1() execution deferred
*/

Das obige ist der detaillierte Inhalt vonEinführung in Go Defer (Go-Delay-Funktion). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!