Deux astuces efficaces en langage Go

Cet article partagera avec vous deux conseils efficaces en langage Go : l'un consiste à ne pas utiliser + et fmt.Sprintf pour faire fonctionner des chaînes ; l'autre consiste à utiliser une structure temporaire pour les paires clé-valeur de champs fixes. ]interface{}.

1. N'utilisez pas + et fmt.Sprintf pour faire fonctionner des chaînes.

+ est très pratique pour faire fonctionner des chaînes, mais il est vraiment lent. L'utilisation de + en langage Go entraînera l'exécution de votre programme. plus rapide C'est peut-être mieux qu'un langage de script. Si vous n'y croyez pas, vous pouvez faire un test vous-même. Utilisez l'opération + et itérez 100 000 fois Python et Javascript sont beaucoup plus rapides que Go (beaucoup, pas un peu) <.>

func TestStr(t *testing.T) {
    str := ""
    for i := 0; i < 100000; i++ {
        str += "test"
    }
}

Résultat du test

PASS : TestStr (3,32 s)

str=""
for i in range(100000):
    str+="test"

Résultat du test :

~/» time python test.py                                                              1 % CPU 0,078 total

En tant que langage statique, l'efficacité d'exécution de Go sur un morceau de code aussi simple est 100 fois plus lente que celle de Python. N'est-ce pas incroyable ? Ce n'est pas un problème Go, mais utiliser + pour traiter des chaînes dans Go nécessite beaucoup de performances, et Python aurait dû surcharger l'optimisation de la chaîne de l'opération +. (Javascript + chaînes d'exploitation est également rapide)

Tutoriels associés :

aller au didacticiel vidéo

Le moyen le plus efficace est d'utiliser le tampon

strBuf := bytes.NewBufferString("")
for i := 0; i < 100000; i++ {
    strBuf.WriteString("test")
}

Les résultats peuvent être testés par vous-même et vous serez surpris

Certains d'entre eux doivent simplement combiner deux chaînes. Utiliser Buffer est un peu plus compliqué. La chose la plus simple à penser est d'utiliser fmt. Combinaison .Sprintf(), le code source de nombreux packages est également écrit de cette manière. En fait, le Sprintf de fmt est également très lent. S'il n'y a pas de sortie de conversion de type complexe, les performances d'utilisation de strings.Join seront beaucoup plus élevées

func TestStr(t *testing.T) {
    a, b := "Hello", "world"
    for i := 0; i < 1000000; i++ {
        fmt.Sprintf("%s%s", a, b)
        //strings.Join([]string{a, b}, "")
    }
}

PASS : TestStr (0,29s)

func TestStr(t *testing.T) {
    a, b := "Hello", "world"
    for i := 0; i < 1000000; i++ {
        //fmt.Sprintf("%s%s", a, b)
        strings.Join([]string{a, b}, "")
    }
}

<🎜. >PASS : TestStr (0,09 s)

À en juger par les résultats, strings.Join est environ 4 fois plus rapide que l'utilisation de Sprint.

2. Pour les paires clé-valeur de champs fixes, utilisez une structure temporaire au lieu de map[string]interface{}

Donnez un exemple simple

func TestData(t *testing.T) {

    for i := 0; i < 100000000; i++ {
        var a struct {
            Name string
            Age  int
        }
        a.Name = "Hello"
        a.Age = 10
    }
}

PASS : TestData ( 0,04s)

func TestData2(t *testing.T) {

    for i := 0; i < 100000000; i++ {
        var a = map[string]interface{}{}
        a["Name"] = "Hello"
        a["Age"] = 10
    }
}

PASS : TestData2 (38,30s)

L'efficacité est des milliers de fois différente !

Lorsque les champs sont connus, l'utilisation de Struct temporaire ne nécessite pas d'allocation dynamique de contenu pendant l'exécution, et il n'est pas nécessaire de vérifier l'index comme la carte, la vitesse sera donc beaucoup plus rapide.

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!