Programmation fonctionnelle Golang : explorer les concepts de Lambdas et de fermetures

Dans Golang, utilisez des expressions lambda pour implémenter la programmation fonctionnelle : Expressions lambda : fonctions anonymes, passant des fonctions en paramètres, utilisées pour simplifier l'utilisation de fonctions d'ordre supérieur ; fermetures : fonctions qui capturent les données des fonctions environnantes, accèdent aux variables de l'environnement de création. Cas pratiques : Traitement simultané : utilisez des expressions lambda pour traiter des tâches en parallèle afin d'améliorer les performances ; utilisez des fermetures pour créer des fonctions contenant l'état, suivre et maintenir à travers les appels ou les modules.

Programmation fonctionnelle Golang : exploration du concept de lambdas et de fermetures

Introduction

La programmation fonctionnelle est un paradigme de programmation qui met l'accent sur les fonctions de citoyens de première classe. Dans Golang, les expressions lambda et les fermetures nous permettent d'écrire du code dans un style fonctionnel. Cet article explorera les deux concepts et leur application dans des projets réels.

Expressions Lambda

Les expressions lambda sont des fonctions anonymes qui nous permettent de passer des fonctions comme arguments de manière concise. Ils sont souvent utilisés pour transmettre des fonctionnalités à des fonctions d'ordre supérieur comme map 或 filter.

Syntaxe :

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

Exemple :

numbers := []int{1, 2, 3, 4, 5}

// 使用 lambda 表达式来平方每个数字
squaredNumbers := map(numbers, func(x int) int {
    return x * x
})

Fermetures

Une fermeture est une fonction qui capture les données de sa fonction environnante. Les fermetures nous permettent d'accéder aux variables dans l'environnement dans lequel elles ont été créées, même après le retour de la fonction contenant.

Syntaxe :

func outerFunc(x int) func() {
    // 捕获 x
    return func() {
        fmt.Println(x) // 内部函数可以访问 x
    }
}

Exemples :

// 表示一个计数器
increment := outerFunc(0)

// 每次调用都会对计数进行递增
for i := 0; i < 5; i++ {
    increment() // 输出 1, 2, 3, 4, 5
}

Exemples pratiques

Utilisation des expressions lambda et de la concurrence

Les expressions lambda peuvent être utilisées avec concurrence pour traiter des tâches en parallèle, améliorant ainsi les performances. Par exemple :

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    resultChan := make(chan int)

    // 使用 lambda 并行处理任务
    for _, number := range numbers {
        go func(num int) {
            resultChan <- num * num
        }(number)
    }

    // 收集并输出结果
    for i := 0; i < len(numbers); i++ {
        fmt.Println(<-resultChan)
    }
}

Implémentation de la gestion d'état à l'aide de fermetures

Les fermetures peuvent être utilisées pour créer des fonctions qui contiennent un état même après le retour de la fonction contenant. Ceci est utile dans les situations où vous devez suivre ou maintenir l’état sur plusieurs appels ou modules.

func makeCounter() func() int {
    var counter int

    // 内部函数捕获 counter
    return func() int {
        counter++
        return counter
    }
}

func main() {
    // 创建两个计数器
    counterA := makeCounter()
    counterB := makeCounter()

    // 调用计数器以递增状态
    for i := 0; i < 5; i++ {
        fmt.Println("Counter A:", counterA())
        fmt.Println("Counter B:", counterB())
    }
}

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!