Pièges et bonnes pratiques des pointeurs de fonctions Golang

Pièges du pointeur de fonction et meilleures pratiques dans Go : Piège : pointeur pointant vers une fonction indisponible Meilleure pratique : utilisez des variables locales ou des fermetures pour capturer les valeurs de fonction. Piège : modifier la fonction pointée par le pointeur Bonne pratique : conserver le pointeur de fonction non modifiable et créer une nouvelle fonction dans une autre fermeture. Cas pratique : fonction de rappel Par exemple, utilisez un pointeur de fonction pour créer une fonction de journalisation qui prend le message de journalisation et le niveau de gravité comme paramètres de la fonction de rappel.

Pièges et meilleures pratiques des pointeurs de fonction dans Go

Dans Go, les pointeurs de fonction sont un mécanisme puissant pour transmettre des fonctions en tant que valeurs. Cependant, il y a quelques pièges à prendre en compte lors de l'utilisation de pointeurs de fonction :

Piège 1 : Le pointeur de fonction pointe vers une fonction indisponible

Une erreur de pointeur suspendu se produit lorsqu'un pointeur de fonction pointe vers une fonction qui n'est plus disponible :

func newFunc() {
    // ...
}

func main() {
    newFuncPtr := newFunc // 将函数 newFunc 赋值给指针 newFuncPtr
    newFunc = nil        // 将 newFunc 设为 nil，使其不可用
    newFuncPtr()        // 这会触发悬空指针错误
}

Meilleure pratique : capturez les valeurs de fonction à l'aide de variables locales ou de fermetures

Pour éviter les pointeurs suspendus, capturez les valeurs de fonction dans des variables locales ou des fermetures :

func main() {
    newFunc := newFunc
    newFunc() // 仍然有效，因为它捕获了 newFunc 的副本
}

Piège 2 : modifiez la fonction pointée par le pointeur

Pour les fonctions La modification de la fonction pointée par le pointeur peut entraîner des conséquences inattendues :

type API interface {
    Call()
}

func makeAPI() API {
    return func() {
        fmt.Println("Hello")
    }
}

func main() {
    apiPtr := makeAPI()
    apiPtr = func() {
        fmt.Println("Goodbye")
    }
    apiPtr.Call() // 输出 "Goodbye"
}

Bonne pratique : gardez les pointeurs de fonction non modifiables

Si vous devez modifier le comportement de la fonction, créez une nouvelle fonction dans une autre fermeture :

func main() {
    api := makeAPI()
    api = func(a API) API {
        return func() {
            fmt.Println("Goodbye")
            a.Call()
        }
    }(api)
    api.Call() // 输出 "Hello", 然后是 "Goodbye"
}

Cas pratique : fonction de rappel

La fonction de rappel est un exemple courant de pointeur de fonction, qui est utilisé pour avertir l'appelant lorsqu'un événement se produit.

Par exemple, nous pouvons utiliser un pointeur de fonction pour créer une fonction de journalisation qui prend le message de journal et le niveau de gravité comme arguments de la fonction de rappel :

import "fmt"
import "log"

type Severity string

const (
    Info    Severity = "INFO"
    Warning Severity = "WARNING"
    Error   Severity = "ERROR"
)

func Log(severity Severity, message string) {
    log.Println(fmt.Sprintf("%s: %s", severity, message))
}

// 获取 severity 为 Info 的日志函数
func InfoLogger() func(string) {
    return func(message string) {
        Log(Info, message)
    }
}

Nous pouvons ensuite utiliser la fonction de rappel pour envoyer le message de journal à la fonction de journalisation :

func main() {
    infoLogger := InfoLogger()
    infoLogger("Hello, world!") // 输出：INFO: Hello, world!
}

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!