web-dev-qa-db-fra.com

Manière correcte d'initialiser la tranche vide

Pour déclarer une tranche vide, de taille non fixée, vaut-il mieux faire:

mySlice1 := make([]int, 0)

ou:

mySlice2 := []int{}

Je me demandais quelle était la bonne façon.

arraysgoslice
172
eouti

Les deux alternatives que vous avez données sont sémantiquement identiques et je suppose qu'elles produisent les mêmes instructions d'assemblage.

Pour éviter une allocation inutile, au cas où vous n'utiliseriez pas la tranche, vous pouvez la laisser avec une valeur nil:

var myslice []int

Comme écrit dans le blog Golang.org :

fonctionnellement, une tranche nulle équivaut à une tranche de longueur nulle, même si elle ne pointe à rien. Il a une longueur de zéro et peut être ajouté, avec attribution.

215
ANisus

Ils sont équivalents. Voir ce code:

mySlice1 := make([]int, 0)
mySlice2 := []int{}
fmt.Println("mySlice1", cap(mySlice1))
fmt.Println("mySlice2", cap(mySlice2))

Sortie:

mySlice1 0
mySlice2 0

Les deux tranches ont la capacité 0, ce qui implique que les deux tranches ont la longueur 0 (ne peut pas être supérieure à la capacité), ce qui implique que les deux tranches ne contiennent aucun élément. Cela signifie que les 2 tranches sont identiques dans tous les aspects.

Voir des questions similaires:

Quel est l'intérêt d'avoir une tranche nulle et une tranche vide dans le golang?

tranches nulles vs tranches non nuls vs tranches vides en langue Go

51
icza

En complément de @ ANisus ' répondre ...

vous trouverez ci-dessous des informations tirées du livre "Passez à l'action" , qui mérite à mon avis d'être mentionné:

Différence entre les tranches nil & empty

Si nous pensons à une tranche comme celle-ci:

[pointer] [length] [capacity]

ensuite:

nil slice:   [nil][0][0]
empty slice: [addr][0][0] // points to an address

tranche nulle

Ils sont utiles lorsque vous souhaitez représenter une tranche qui n’existe pas, par exemple lorsqu’une exception se produit dans une fonction qui renvoie une tranche.

// Create a nil slice of integers.
var slice []int

tranche vide

Les tranches vides sont utiles lorsque vous souhaitez représenter une collection vide, par exemple lorsqu'une requête de base de données ne renvoie aucun résultat.

// Use make to create an empty slice of integers.
slice := make([]int, 0)

// Use a slice literal to create an empty slice of integers.
slice := []int{}

Que vous utilisiez une tranche nulle ou vide, les fonctions intégrées append, len et cap fonctionnent de la même manière.

Exemple de terrain de je :

package main

import (
    "fmt"
)

func main() {

    var nil_slice []int
    var empty_slice = []int{}

    fmt.Println(nil_slice == nil, len(nil_slice), cap(nil_slice))
    fmt.Println(empty_slice == nil, len(empty_slice), cap(empty_slice))

}

impressions:

true 0 0
false 0 0
33
tgogos

La tranche vide et la tranche nulle sont initialisées différemment dans Go:

var nilSlice []int 
emptySlice1 := make([]int, 0)
emptySlice2 := []int{}

fmt.Println(nilSlice == nil)    // true
fmt.Println(emptySlice1 == nil) // false
fmt.Println(emptySlice2 == nil) // false

Comme pour les trois tranches, len et cap sont 0.

12
Joe.CK