Guide de rédaction de fonctions efficaces Golang

Suivez ces directives pour écrire des fonctions Go efficaces : évitez d'utiliser des variables globales. Passer par valeur pour les types de petites valeurs ; passer par pointeur pour les types de grandes valeurs. Attribuez des valeurs uniquement lorsque cela est nécessaire. Utilisez des fonctions en ligne. Réduisez le nombre de paramètres.

Guide pour écrire des fonctions efficaces dans Go

Des fonctions efficaces sont la clé pour écrire des programmes Go efficaces. En suivant ces directives, vous pouvez écrire des fonctions à la fois efficaces et lisibles.

1. Évitez les variables globales

Les variables globales rendent le code difficile à maintenir et à tester car il peut être modifié depuis n'importe où dans le programme. Au lieu de cela, limitez les variables à des fonctions ou des types spécifiques.

2. Utiliser le passage de valeur

Les fonctions dans Go sont transmises par valeur par défaut. Cela signifie qu'une copie de la variable passée à la fonction sera transmise à la fonction. Ceci est plus efficace pour les petits types de valeur tels que int, float ou string. Pour les types de grandes valeurs, tels que les tableaux ou les tranches, le passage de pointeur doit être utilisé à la place.

3. Utiliser le passage de pointeurs

Le passage de grandes valeurs via des pointeurs permet aux fonctions de modifier directement la valeur d'origine, évitant ainsi la surcharge liée à la copie de la valeur entière. Lorsqu'une valeur doit être modifiée dans une fonction, utilisez le passage de pointeur.

4. Réduisez le nombre de paramètres

Plus une fonction a de paramètres, plus la lisibilité et la débogage du programme seront mauvaises. Si une fonction nécessite plusieurs paramètres, envisagez de créer une structure ou de combiner les paramètres associés en une seule valeur.

5. Évitez les allocations inutiles

L'attribution de nouvelles valeurs entraînera une surcharge de performances. Attribuez des valeurs uniquement lorsque cela est nécessaire. Par exemple, utilisez un tampon dans une boucle au lieu d'attribuer de nouvelles valeurs à chaque itération.

6. Utiliser des fonctions en ligne

Les fonctions en ligne insèrent le corps de la fonction directement dans le point d'appel. Cela peut réduire la surcharge des appels de fonction, en particulier lorsque le corps de la fonction est petit.

Cas pratique :

L'exemple suivant compare les performances du passage par valeur et du passage par pointeur :

package main

import "testing"

type Data struct {
    Value int
}

func passByValue(d Data) {
    d.Value += 1
}

func passByPointer(d *Data) {
    d.Value += 1
}

func BenchmarkPassByValue(b *testing.B) {
    d := Data{Value: 0}
    for i := 0; i < b.N; i++ {
        passByValue(d)
    }
}

func BenchmarkPassByPointer(b *testing.B) {
    d := Data{Value: 0}
    for i := 0; i < b.N; i++ {
        passByPointer(&d)
    }
}

Les résultats du benchmark montrent que le passage par pointeur est beaucoup plus rapide que le passage par valeur :

BenchmarkPassByValue-8              10000000               148 ns/op
BenchmarkPassByPointer-8           100000000                24.2 ns/op

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!