Introduction aux fonctionnalités et fonctions de la dernière version des fonctions et fermetures anonymes de Golang

Les nouvelles fonctionnalités des fonctions anonymes et des fermetures dans le langage Go incluent : la syntaxe lambda (=>), l'inférence de type simplifiée, la portée au niveau du bloc et le stockage local goroutine. Ces fonctionnalités améliorent la flexibilité, la lisibilité et la maintenabilité du code. Des cas pratiques démontrent l'utilisation de fonctions et de fermetures anonymes, notamment le fractionnement de chaînes et les compteurs simultanés.

Les dernières fonctionnalités et capacités des fonctions et fermetures anonymes en langage Go

Introduction

Les fonctions et fermetures anonymes sont des outils puissants en langage Go qui permettent aux développeurs de créer des morceaux de code flexibles et réutilisables. Dans la dernière version du langage Go, les fonctions et fermetures anonymes ont été considérablement améliorées, offrant de nouvelles fonctionnalités et capacités qui les rendent plus puissantes et plus faciles à utiliser.

Fonctions anonymes

Les fonctions anonymes sont des fonctions non liées qui peuvent être affectées en tant que variables ou transmises en tant qu'arguments à d'autres fonctions. Elles sont créées à l'aide du mot-clé func et d'une signature de fonction anonyme : func 关键字和匿名函数签名来创建：

func(parameters) return_type {
    // 函数体
}

最新版本的 Go 语言中引入了以下匿名函数的新特性：

• lambda 语法：现在可以通过 =>

  // 计算两个数字的和
  sum := func(x, y int) int {
      return x + y
  }

Les nouvelles fonctionnalités suivantes des fonctions anonymes ont été introduites dans la dernière version du langage Go :

• Syntaxe lambda : Désormais disponible via la notation < code>=>, elle crée des fonctions anonymes, similaires à d'autres langages de programmation :

// 将字符串转换为大写
toUpper := func(s string) string {
    return strings.ToUpper(s)
}

Inférence de type simplifiée :

Pour certaines fonctions anonymes, le compilateur Go peut déduire le type de retour, ainsi simplifier le code :

for i := 0; i < 3; i++ {
    // 创建一个闭包，捕获循环变量 i 的值
    f := func() { fmt.Println(i) }
    go f() // 并行执行闭包
}

Closures

• Une fermeture est une fonction qui contient des variables libres accessibles même après avoir dépassé sa portée déclarée. Ce sont des outils puissants pour créer des fonctions de sauvegarde d’état et gérer des tâches asynchrones.
Les nouvelles fonctionnalités suivantes des fermetures ont été introduites dans la dernière version du langage Go :

• Portée au niveau du bloc : Vous pouvez désormais utiliser la portée au niveau du bloc (accolades) pour contrôler la portée des variables libres dans un Closure, améliorant ainsi la lisibilité et la maintenabilité du code :

// 创建 goroutine 本地变量
var myData int64

// 使用闭包访问局部变量
f := func() {
    atomic.AddInt64(&myData, 1)
}

stockage local goroutine :

Le langage Go prend désormais en charge le stockage local goroutine, permettant aux fermetures de stocker et de récupérer des données privées dans le cadre d'une seule goroutine. Ceci est très utile pour créer du parallélisme et du code thread-safe :

// 使用 lambda 语法创建匿名函数，将字符串分割为单词
splitFunc := func(s string) []string {
    return strings.Fields(s)
}

// 使用闭包和 goroutine 本地存储实现并发计数器
type Counter struct {
    count int64 // goroutine 本地变量
}

func (c *Counter) Inc() {
    atomic.AddInt64(&c.count, 1)
}

func main() {
    // 使用匿名函数并行处理一个字符串列表
    words := []string{"Hello", "World", "Go"}
    fmt.Println(strings.Join(Map(words, splitFunc), " "))

    // 使用闭包创建并发计数器
    c := &Counter{}
    for i := 0; i < 1000; i++ {
        go c.Inc()
    }
    time.Sleep(time.Second) // 等待所有 goroutine 完成
    fmt.Println("Count:", c.count)
}

Un exemple pratique

Montrons les dernières fonctionnalités des fonctions anonymes et des fermetures à travers un exemple pratique :

rrreee🎜🎜Conclusion🎜🎜🎜En langage Go Les dernières caractéristiques et fonctionnalités des fonctions et fermetures anonymes améliorent considérablement la puissance et la facilité d’utilisation de ces outils. La syntaxe Lambda, l'inférence de type simplifiée, la portée au niveau des blocs et le stockage local goroutine permettent aux développeurs d'écrire du code plus flexible et plus robuste. Ces améliorations rendent le langage Go plus adapté à la gestion des tâches de concurrence et de gestion d'état, fournissant ainsi une base puissante et flexible pour créer des logiciels efficaces et maintenables. 🎜

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!