Quelle est la relation entre le report et la panique en langage Go ?

Le langage

Go est un nouveau langage de programmation qui a ajouté une syntaxe et des fonctionnalités uniques, parmi lesquelles le report et la panique sont deux fonctionnalités très importantes. Cet article présentera la relation entre le report et la panique dans le langage Go ainsi que leur utilisation et leurs caractéristiques.

Utilisation de defer

L'instruction defer en langage Go est utilisée pour enregistrer une fonction Lorsque l'exécution de cette fonction se termine ou que la portée actuelle se termine, la fonction enregistrée sera. fonction exécutée automatiquement. defer peut être utilisé dans plusieurs scénarios tels que la libération des ressources, le déverrouillage du verrou et la gestion des erreurs.

Ce qui suit est un exemple de libération différée des ressources :

func main() {
    file, err := os.Open("myfile.txt")
  // 在函数结束时，会自动关闭文件
    defer file.Close()
  
    if err != nil {
        fmt.Println("Failed to open file.")
        return
    }
    // ...
}

La fonction Close() du fichier différé est enregistrée et le fichier sera automatiquement fermé lors de l'exécution de la fonction se termine.

Ce qui suit est un exemple de déverrouillage d'un verrou différé :

func main() {
    var lock sync.Mutex
    lock.Lock()
  // 当函数执行结束时，会自动解锁
    defer lock.Unlock()
  
    // ...
}

La fonction Unlock() sera automatiquement appelée pour déverrouiller le verrou à la fin de l'exécution de la fonction.

L'ordre d'exécution du defer est de l'arrière vers l'avant, ce qui signifie que si plusieurs instructions defer sont enregistrées, elles seront exécutées dans l'ordre inverse. L'exemple suivant affichera Defer 2 puis Defer 1. Defer 2，然后输出Defer 1。

func main() {
    defer fmt.Println("Defer 1")
    defer fmt.Println("Defer 2")
    fmt.Println("Hello")
}

panic 的用法

Go 语言中的 panic 关键字用于抛出一个异常，并终止当前函数或者程序的执行。 panic 会沿着函数调用堆栈向上传递，直到被 recover() 函数捕捉到为止。如果没有被捕捉到，整个程序会被退出，并输出一个调用堆栈。

下面示例代码中，当输入的字符串长度小于 5 时，会触发 panic，终止程序的执行。

func hello(name string) {
    if len(name) < 5 {
        panic("Name is too short.")
    }
    fmt.Println("Hello", name)
}

func main() {
    hello("Tom")
    hello("Bob")
    hello("me")
}

输出结果如下：

Hello Tom
Hello Bob
panic: Name is too short.

goroutine 1 [running]:
main.hello(...)
    /Users/user/goland/src/main.go:4
main.main()
    /Users/user/goland/src/main.go:10 +0x81
exit status 2

这里我们可以看到当输入的 name 为me

func main() {
    defer fmt.Println("Defer 1")
    defer fmt.Println("Defer 2")
    
    panic("Oops! Something went wrong.")
}

Utilisation de panic

Le mot-clé panic en langage Go est utilisé pour lever une exception et terminer l'exécution de la fonction ou du programme en cours. Panic propagera la pile d'appels de fonction jusqu'à ce qu'elle soit interceptée par la fonction recovery(). S'il n'est pas détecté, le programme entier est quitté et une pile d'appels est imprimée.

Dans l'exemple de code ci-dessous, lorsque la longueur de la chaîne d'entrée est inférieure à 5, une panique sera déclenchée et l'exécution du programme sera terminée.

Defer 2
Defer 1
panic: Oops! Something went wrong.

goroutine 1 [running]:
main.main()
    /Users/user/goland/src/main.go:7 +0x81
exit status 2

Le résultat de sortie est le suivant :

func init() {
    fmt.Println("Init 1")
}

func init() {
    fmt.Println("Init 2")
}

func main() {
    defer fmt.Println("Defer 1")
    
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("Recovered:", err)
        }
    }()
    
    defer fmt.Println("Defer 2")
    
    panic("Oops! Something went wrong.")
}

Ici, nous pouvons voir que lorsque le nom d'entrée est me, une panique sera déclenchée et l'exécution du programme sera interrompue.

La relation entre le report et la panique

panic joue le rôle de terminer immédiatement l'exécution du programme, ce qui signifie qu'elle peut être déclenchée à tout moment, y compris avant la fin de l'exécution de la fonction. Afin de garantir que le programme peut libérer des ressources à temps et effectuer certains travaux de nettoyage nécessaires, le langage Go introduit le mécanisme de report, qui permet à la fonction d'effectuer certaines opérations de nettoyage avant de quitter.

Lorsqu'une panique est déclenchée dans une fonction, elle se terminera immédiatement et exécutera toutes les fonctions différées enregistrées avant la fonction en cours. L'exemple de code suivant déclenche manuellement une panique et exécute la fonction de report deux fois avant de quitter.

Init 1
Init 2
Defer 2
Recovered: Oops! Something went wrong.
Defer 1

Le résultat est le suivant :

rrreee

Nous pouvons voir qu'après le déclenchement de la panique, les deux fonctions de report sont exécutées dans l'ordre inverse.

En plus d'enregistrer la fonction de report à la fin de la fonction, le langage Go permet également d'enregistrer plusieurs fonctions de report dans la fonction. Cela signifie que s'il y a plusieurs fonctions de report dans une fonction, même si l'une des fonctions de report déclenche une panique, les autres fonctions de report peuvent toujours être exécutées. #🎜🎜##🎜🎜#L'exemple de code suivant démontre que lorsqu'une fonction enregistre plusieurs instructions defer, l'une des fonctions defer déclenche une panique, mais les autres fonctions defer sont toujours exécutées. #🎜🎜#rrreee#🎜🎜#Le résultat de sortie est le suivant : #🎜🎜#rrreee#🎜🎜#Nous pouvons voir que la fonction exécute d'abord deux fonctions init, puis exécute trois fonctions defer en séquence. Lorsque l'un des différés déclenche une panique, mais est intercepté par l'autre différé et que le programme reprend, les deux fonctions de report s'exécutent finalement normalement. #🎜🎜##🎜🎜#Dans le développement réel, defer et panic sont souvent utilisés par paires, defer est utilisé pour libérer des ressources et effectuer des opérations de nettoyage, et panic est utilisé pour gérer les exceptions. Lorsqu'une fonction doit effectuer plusieurs opérations de nettoyage avant de se terminer, nous pouvons utiliser une fonction defer wrapper au début de la fonction et utiliser la fonction recovery() pour empêcher la fonction de se terminer prématurément. Cette façon d’écrire est très courante et nous offre une forte garantie d’écrire des programmes robustes. #🎜🎜#

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!