Partage d'exemples d'application de fermeture de fonction Golang

Golang est un langage de programmation privilégié par de plus en plus de développeurs pour sa simplicité, son efficacité, sa sécurité de concurrence et d'autres fonctionnalités. Les fonctions de Golang sont des types valeur, très flexibles et extensibles, et peuvent facilement implémenter des fonctions de fermeture.

La fermeture est l'une des techniques couramment utilisées dans les fonctions. Elle permet à une fonction d'accéder à une variable définie dans la portée externe et de renvoyer une référence à cette variable. Ensuite, cet article expliquera l'application de fermeture des fonctions Golang à travers différents exemples.

1. Calculatrice

La calculatrice est une application de fermeture courante. Elle utilise des fermetures pour réaliser l'auto-incrémentation ou l'auto-décrémentation du compteur, permettant aux programmeurs de gérer facilement le compteur. statut du compteur.

Ce qui suit est un exemple :

func Calculator(number int) func() int {
    return func() int {
        number += 1
        return number
    }
}

// 使用
cal := Calculator(0)
fmt.Println(cal()) // 1
fmt.Println(cal()) // 2
fmt.Println(cal()) // 3

Dans cet exemple, la fonction Calculatrice renvoie une fermeture qui accède en interne au numéro de variable défini dans la fonction Calculatrice, et a implémenté l'auto- fonction d'incrémentation.

2. Itération de boucle

Dans Golang, comme il n'y a pas de boucle while, une boucle for est généralement utilisée pour implémenter l'itération. Cependant, dans certains cas, il est plus pratique de parcourir une boucle à l’aide d’une fermeture.

Voici un exemple :

func Iteration() {
    items := []string{"apple", "banana", "cherry"}

    for _, item := range items {
        func() {
            fmt.Printf("%s
", item)
        }()
    }
}

// 使用
Iteration()

Dans cet exemple, la fonction Itération est une fonction d'itération de boucle qui utilise une fermeture pour imprimer chaque élément du tableau.

3. Appel différé

L'appel différé est une fonction couramment utilisée dans Golang, qui permet au programme d'effectuer un travail de finition avant la fin de la fonction. Lors des fermetures, vous pouvez utiliser des appels différés pour réaliser des opérations élégantes.

Ce qui suit est un exemple :

func DeferCall() {
    fmt.Println("start")

    func() {
        defer func() {
            fmt.Println("end")
        }()
    }()
}

// 使用
DeferCall()

Dans cet exemple, une fonction DeferCall est définie, une fermeture est définie dans la fonction et defer est utilisé à l'intérieur de la fermeture pour appeler une fonction Anonyme. L'instruction defer ici sera exécutée à la sortie de la fonction pour implémenter certaines fonctions spécifiques, telles que la libération des ressources, la journalisation, etc.

4. Contrôle de la concurrence

Dans Golang, il est très pratique d'utiliser goroutine pour obtenir la concurrence. Cependant, dans certains cas, un contrôle de concurrence spécial doit être mis en œuvre, ce qui peut être résolu à l'aide de fermetures.

Voici un exemple :

func ConcurrencyControl() {
    var wg sync.WaitGroup
    ch := make(chan bool, 2)

    for i := 1; i <= 2; i++ {
        wg.Add(1)

        go func(id int) {
            defer func() {
                wg.Done()
            }()

            ch <- true

            defer func() {
                <-ch
            }()

            time.Sleep(time.Second * time.Duration(2))
            fmt.Printf("id=%d
", id)
        }(i)
    }
    wg.Wait()
}

// 使用
ConcurrencyControl()

Dans cet exemple, une fonction ConcurrencyControl est définie, qui utilise WaitGroup et chan pour contrôler l'ordre d'exécution de deux threads simultanés. Parmi eux, les appels différés dans les fermetures sont utilisés pour mettre en œuvre certaines opérations spécifiques.

Résumé

Les exemples ci-dessus montrent quatre aspects d'application des fermetures de fonctions Golang, mais pas tous. Dans le développement réel, les programmeurs peuvent choisir différentes méthodes d'application de fermeture pour répondre à différents besoins.

En général, la fermeture des fonctions de Golang est une fonctionnalité très utile et puissante. Elle peut non seulement améliorer l'efficacité et l'évolutivité du programme, mais également permettre aux programmeurs d'écrire du code plus facilement. Il est recommandé aux programmeurs de maîtriser cette compétence et de l'appliquer au développement réel.

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!