Bonne façon d'initialiser vide tranche

Pour déclarer un vide tranche, avec une absence de taille fixe,
est-il mieux à faire:

mySlice1 := make([]int, 0)

ou:

mySlice2 := []int{}

Juste demander quel est le bon chemin.

Vous dites "non-taille fixe", mais les tranches sont jamais ont une taille fixe. À moins que tu veux dire avec zéro de la capacité. Remarque, si vous avez une idée/guess/indice de ce que la capacité dont vous pourriez avoir besoin, puis en utilisant les trois argument version est la bonne. E. g. pour construire une tranche de la carte clés: keys := make([]int, 0, len(m)); for k, v := range m { keys := append(keys,k) }
Double Possible de Déclarer tranche ou tranche de faire?

InformationsquelleAutor eouti | 2015-03-20

arrays go slice

211

Les deux alternatives que vous avez donné sont sémantiquement identiques, et je suppose qu'ils produisent les mêmes instructions de montage.

Pour éviter une inutile de répartition, dans le cas où vous ne finissent pas à l'aide de la tranche, vous pouvez vous en sortir avec une nil valeur:
```
var myslice []int
```
Comme écrit dans le Golang.org blog:

un néant tranche est fonctionnellement équivalent à une longueur nulle tranche, même si elle pointe vers rien. Il a une longueur de zéro et peut être ajouté, avec l'allocation.
- Également mentionner sur le wiki github.com/golang/go/wiki/...
- Attention: json.Marshal() sera de retour null pour var myslice []int et [] pour initialisé tranche myslice := []int{}
- Attention également: reflect.DeepEqual fait une distinction entre nil tranches et les non-nul tranches: a := []int{}, var b []int, reflect.DeepEqual(a, b) // returns false
InformationsquelleAutor ANisus
50

Ils sont équivalents. Voir ce code:
```
mySlice1 := make([]int, 0)
mySlice2 := []int{}
fmt.Println("mySlice1", cap(mySlice1))
fmt.Println("mySlice2", cap(mySlice2))
```
De sortie:
```
mySlice1 0
mySlice2 0
```
Les deux tranches ont 0 capacité qui implique les deux tranches ont 0 longueur (ne peut pas être plus grande que la capacité) qui implique les deux tranches ont pas d'éléments. Cela signifie que les 2 tranches sont identiques dans tous les aspects.

Voir les mêmes questions:

Quel est l'intérêt d'avoir néant tranche et vide tranche dans golang?

nul tranches vs non-nul tranches vs vide tranches dans le langage Go

InformationsquelleAutor icza
31

Comme un complément à @ANisus' réponse...

ci-dessous quelques informations de la "Aller dans l'action" livre, qui je pense vaut la peine de mentionner

Différence entre nil & empty tranches

Si nous considérons une tranche comme ceci:
```
[pointer] [length] [capacity]
```
alors:
```
nil slice:   [nil][0][0]
empty slice: [addr][0][0] //points to an address
```
néant tranche

Ils sont utiles lorsque vous souhaitez représenter une tranche qui n'existe pas, comme lorsqu'une exception se produit dans une fonction qui renvoie une tranche.
```
//Create a nil slice of integers.
var slice []int
```
vide tranche

Vide tranches sont utiles lorsque vous souhaitez représenter un regroupement vide, comme lorsqu'une base de données de la requête renvoie des résultats nuls.
```
//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{}
```
Peu importe si vous êtes à l'aide d'un néant tranche ou un vide tranche, les fonctions intégrées append, len, et cap fonctionner de la même.
Aller de l'aire de jeux exemple:
```
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))

}
```
imprime:
```
true 0 0
false 0 0
```
- Pouvons-nous obtenir l'adresse de vide tranche en une seule étape à l'aide de make?
- Si nous prenons un coup d'oeil à la fonction signature, make ne semble pas renvoyer l'adresse. Je crois que vous ne pouvez pas le faire en une seule étape.
InformationsquelleAutor tgogos
11

Vide tranche et le néant tranche sont initialisés différemment en Aller:
```
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 tous trois tranches, len et cap sont 0.
- make([]int, 0) est le meilleur parce que Jetbrains GoLand ne se plaignent pas d'être "inutile", comme il le fait dans le cas de []int{}. Ceci est utile dans l'écriture de tests unitaires.
InformationsquelleAutor Joe.CK

Vous devez vous connecter pour publier un commentaire.

Différence entre nil & empty tranches

néant tranche

vide tranche

Différence entre `nil` & `empty` tranches