Introduction aux fonctions et méthodes du langage Go

Si vous rencontrez une déclaration de fonction sans corps de fonction, cela signifie que la fonction n'est pas implémentée dans Go.

package math
func Sin(x float64) float //implemented in assembly language

Si un nom de variable est défini pour chaque valeur de retour d'une fonction, il sera initialisé avec la valeur zéro correspondante et l'opérande sera omis dans l'instruction return de la fonction. retour.

La gestion des erreurs dans go est habituelle pour effectuer d'abord une série de vérifications d'initialisation, en traitant d'abord le code qui gère la logique d'échec, puis la logique réelle de la fonction. Cela rend le code plus concis et évite trop de choses. Hiérarchie.

Lors de la définition d'une fonction, vous pouvez utiliser le type de fonction comme paramètre ou comme type de retour N'est-ce pas un peu comme un délégué pour implémenter la fermeture ? Il existe également des fonctions anonymes, similaires aux expressions lambda. La fonction strings.Map peut être utilisée à des fins d’expérimentation.

func squares() func() int {
    var x int
    return func() int {
        x++
        return x * x
    }
}
func main() {
    f := squares()
    fmt.Println(f()) // "1"
    fmt.Println(f()) // "4"
    fmt.Println(f()) // "9"
    fmt.Println(f()) // "16"
}

Il existe des références variables dans les fonctions et les carrés anonymes. C'est pourquoi les valeurs de fonction sont des types de référence et les valeurs de fonction ne sont pas comparables. Go utilise la technologie de fermeture pour implémenter les valeurs de fonction, et les programmeurs Go appellent également des fermetures de valeurs de fonction.

Faites attention à l'exemple de programme dans la section des fonctions anonymes de la Bible Golang.

La fonction de paramètre variable du langage Go est très simple à utiliser. Vous pouvez passer plusieurs paramètres du même type, ou vous pouvez passer directement une tranche de ce type (notez qu'il faut utiliser le .. . lors du passage dans la tranche. Je pense qu'il devrait s'agir de distinguer les mêmes paramètres de tranche, après tout, les deux sont encore quelque peu différents). Si vous souhaitez utiliser différents types de paramètres variables, utilisez l'interface universelle {}. , et analysez simplement les paramètres variables dans le corps de la fonction comme une tranche.

La fonction après le defer ne sera pas exécutée tant que la fonction contenant l'instruction defer n'est pas exécutée, que la fonction contenant l'instruction defer se termine normalement par return ou se termine anormalement en raison d'une panique. Vous pouvez exécuter plusieurs instructions defer dans une fonction, et leur ordre d'exécution est opposé à l'ordre de déclaration

var mu sync.Mutex
var m = make(map[string]int)
func lookup(key string) int {
    mu.Lock()
    defer mu.Unlock()
    return m[key]
}

Lors du débogage de programmes complexes, le mécanisme defer est également souvent utilisé pour enregistrer quand entrer et sortir d'une fonction.

func bigSlowOperation() {
    defer trace("bigSlowOperation")() // don't forget the
    extra parentheses
    // ...lots of work…
    time.Sleep(10 * time.Second) // simulate slow
    operation by sleeping
}
func trace(msg string) func() {
    start := time.Now()
    log.Printf("enter %s", msg)
    return func() { 
        log.Printf("exit %s (%s)", msg,time.Since(start)) 
    }
}

Nous devons d'abord nommer la valeur de retour de double, puis ajouter une instruction defer. Nous pouvons afficher les paramètres et renvoyer la valeur à chaque fois que double est appelé.

func double(x int) (result int) {
    defer func() { fmt.Printf("double(%d) = %d\n", x,result) }()
    return x + x
}
_ = double(4)
// Output:
// "double(4) = 8"

Pour faciliter le diagnostic des problèmes, le package d'exécution permet aux programmeurs de générer des informations sur la pile. Dans l'exemple suivant, nous générons des informations sur la pile en retardant l'appel à printStack dans la fonction principale.

gopl.io/ch5/defer2
func main() {
    defer printStack()
    f(3)
}
func printStack() {
    var buf [4096]byte
    n := runtime.Stack(buf[:], false)
    os.Stdout.Write(buf[:n])
}

Vous ne pouvez pas définir des noms de champs et des noms de méthodes avec le même nom pour une structure, ce qui est un peu étrange.

Pointeur de fonction : il existe en fait des pointeurs de fonction dans go. Utilisons le langage go pour implémenter le mode piloté par table.

package main

import (
    "fmt"
)

func add(a int, b int) int {
    return a + b 
}

func sub(a int, b int) int {
    return a - b 
}

func main() {
    fm := make(map[int]func(int, int) int)
    fm[1001] = add 
    fm[1002] = sub 
    protocol := 2001
    i := 1
    j := 2
    if func_handle, ok := fm[protocol]; ok {
        println(func_handle(i, j)) 
    } else {
        fmt.Printf("protocol: %d not register!", protocol)
    }   
}

Renvoyer le pointeur de variable locale :

Contrairement au langage C, les fonctions GO peuvent renvoyer des pointeurs de changement locaux, et le compilateur utilisera l'analyse d'échappement pour décider s'il doit allouer de la mémoire sur le tas.

Vous pouvez désactiver l'inlining de fonction via le paramètre -gcflags "-l -m" lors de la compilation. L'inlining de fonction aura un certain impact sur l'allocation de mémoire, mais les détails ne sont pas clairs.

Il n'y a pas de passage de référence des paramètres de fonction, ils sont tous passés par valeur. La différence est uniquement de savoir si l'objet copié ou le pointeur est passé. En langage C, il est généralement recommandé de passer des paramètres de pointeur pour éviter de copier des objets et améliorer l'efficacité.

Mais au fur et à mesure, le pointeur copié prolongera le cycle de vie de l'objet cible et peut également provoquer son allocation sur le tas. La consommation de performances s'ajoutera au coût d'allocation de mémoire du tas et de garbage collection. , en go La copie de petits objets sur la pile est en fait très rapide, donc si l'objet n'est pas particulièrement grand ou si l'objet d'origine a vraiment besoin d'être modifié, il n'est généralement pas nécessaire de transmettre les paramètres du pointeur. En programmation concurrente, l'utilisation d'objets immuables (en lecture seule ou copiés) est également préconisée, ce qui peut éliminer les problèmes de synchronisation des données.

Ce qui suit allouera de la mémoire sur le tas. Lors de la compilation, passez -gcflags "-m" pour afficher le code assembleur :

func test(p *int) {
    go func() {
        println(p)
    }() 
}

func main() {
    x := 100 
    p := &x
    test(p)
}

Utilisez les paramètres sortants, il est recommandé d'utiliser les valeurs de retour, vous pouvez également utiliser deux pointeurs de niveau :

func test(p **int) {
    x := 100
    *p = &x
}

func main() {
    var p *int
    test(&p)
    println(*p)
}

Pour plus de connaissances sur le langage Go, veuillez faire attention à la colonne Tutoriel sur le langage Go sur le site Web PHP chinois.

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!