Maison > développement back-end > Golang > Qu'est-ce qui est le plus rapide dans Go : `append()` ou affectation de tranche ?

Qu'est-ce qui est le plus rapide dans Go : `append()` ou affectation de tranche ?

DDD
Libérer: 2024-11-11 01:49:02
original
762 Les gens l'ont consulté

Which is faster in Go: `append()` or slice assignment?

Comparaison des performances de l'ajout et de l'affectation de tranches dans Go

Dans Go, le découpage joue un rôle important dans la gestion efficace des données. Cependant, des questions se posent concernant les différences de performances entre deux opérations de tranche couramment utilisées : l'ajout et l'affectation.

Append vs. Assign

L'opération append() étend la tranche existante avec des éléments supplémentaires, tandis que l'opérateur d'affectation (=), lorsqu'il est appliqué aux tranches, écrase simplement les éléments existants par de nouvelles valeurs.

Performance Analyse

L'analyse comparative du code suivant démontre l'écart de performances :

func BenchmarkSliceAppend(b *testing.B) {
    a := make([]int, 0, b.N)
    for i := 0; i < b.N; i++ {
        a = append(a, i)
    }
}

func BenchmarkSliceSet(b *testing.B) {
    a := make([]int, b.N)
    for i := 0; i < b.N; i++ {
        a[i] = i
    }
}
Copier après la connexion

Les résultats de l'analyse comparative indiquent que "a[i] = i" (affectation) surpasse systématiquement "a = append( un, je)" (ajouter) :

BenchmarkSliceAppend    200000000                7.87 ns/op            8 B/op          0 allocs/op
BenchmarkSliceSet       300000000                5.76 ns/op            8 B/op
Copier après la connexion

Explication

La performance plus rapide de "a[i] = i" peut être attribuée à sa nature d'affectation directe. Il attribue simplement la valeur i à l'élément correspondant dans la tranche.

En revanche, "a = append(a, i)" implique une série d'opérations :

  1. Copier le en-tête de tranche existant.
  2. Créez une tranche temporaire pour les paramètres variadiques (i).
  3. Recoupez a si la capacité est suffisante (fourni dans le benchmark).
  4. Attribuer i au dernier élément de a.
  5. Mettre à jour l'en-tête de tranche dans une variable locale (a).

Ces des étapes supplémentaires introduisent une surcharge par rapport à l'affectation directe dans "a[i] = i".

Conclusion

Comprendre les différences de performances entre les opérations de tranche est crucial pour optimiser l'efficacité du code. Pour une attribution de valeur simple, "a[i] = i" s'avère être un choix plus efficace. Cependant, lorsque l'expansion de la tranche est nécessaire, "a = append(a, i)" reste l'approche appropriée.

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!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal