Comment puis-je utiliser Allez ajouter deux []byte tranches ou des tableaux?

Récemment, j'ai essayé en ajoutant deux tableau d'octets en tranches en Aller et suis tombé sur quelques erreurs bizarres. Mon code est:

one:=make([]byte, 2)
two:=make([]byte, 2)
one[0]=0x00
one[1]=0x01
two[0]=0x02
two[1]=0x03

log.Printf("%X", append(one[:], two[:]))

three:=[]byte{0, 1}
four:=[]byte{2, 3}

five:=append(three, four)

Et les erreurs sont:

cannot use four (type []uint8) as type uint8 in append
cannot use two[:] (type []uint8) as type uint8 in append

Dont la prise en compte de la prétendue robustesse de Go tranches ne devrait pas être un problème:

http://code.google.com/p/go-wiki/wiki/SliceTricks

Ce que je fais mal, et comment dois-je aller sur l'ajout de deux tableaux d'octets?

InformationsquelleAutor ThePiachu | 2011-12-11

43

La Spécification De Langage De Programmation Go

Ajout et la copie des tranches

Les variadic fonction append ajoute zéro ou plusieurs valeurs x à s de
type S, qui doit être un type de tranche, et renvoie la tranche obtenue,
également de type S. Les valeurs x sont passés à un paramètre de type ...T
où T est le type de l'élément de S et le passage de paramètres
les règles s'appliquent.

append(s S, x ...T) S //T is the element type of S

Passage d'arguments à ... paramètres

Si le dernier argument est assignable à un type de tranche []T, il peut être
adopté sans modification en tant que valeur pour un ...T paramètre si l'argument est
suivi par ....

Vous devez utiliser []T... pour le dernier argument.

Pour votre exemple, avec l'argument final type de tranche []byte, l'argument est suivi par ...,
```
package main

import "fmt"

func main() {
    one := make([]byte, 2)
    two := make([]byte, 2)
    one[0] = 0x00
    one[1] = 0x01
    two[0] = 0x02
    two[1] = 0x03
    fmt.Println(append(one[:], two[:]...))

    three := []byte{0, 1}
    four := []byte{2, 3}
    five := append(three, four...)
    fmt.Println(five)
}
```
Aire de jeux: https://play.golang.org/p/2jjXDc8_SWT

De sortie:
```
[0 1 2 3]
[0 1 2 3]
```
InformationsquelleAutor peterSO
5

append() prend une tranche de type []T, puis un nombre variable de valeurs du type de la membre de la tranche T. En d'autres termes, si vous passez un []uint8 que la tranche de append() alors il veut chaque argument à un uint8.

La solution pour cela est d'utiliser la slice... syntaxe pour le passage d'une tranche à la place d'un varargs argument. Votre code devrait ressembler à
```
log.Printf("%X", append(one[:], two[:]...))
```
et
```
five:=append(three, four...)
```
InformationsquelleAutor Lily Ballard

Vous devez vous connecter pour publier un commentaire.