Verketten Sie zwei Scheiben in Go

Ich versuche, die Scheibe [1, 2]und die Scheibe zu kombinieren[3, 4] . Wie kann ich das in Go machen?

Ich habe es versucht:

append([]int{1,2}, []int{3,4})

aber bekam:

cannot use []int literal (type []int) as type int in append

Die Dokumentation scheint jedoch darauf hinzudeuten, dass dies möglich ist. Was fehlt mir?

slice = append(slice, anotherSlice...)

Fügen Sie nach der zweiten Scheibe Punkte hinzu:

//---------------------------vvv
append([]int{1,2}, []int{3,4}...)

Dies ist genau wie bei jeder anderen variadischen Funktion.

func foo(is ...int) {
    for i := 0; i < len(is); i++ {
        fmt.Println(is[i])
    }
}

func main() {
    foo([]int{9,8,7,6,5}...)
}

Anhängen an und Kopieren von Slices

Die Variadic-Funktion appendhängt null oder mehr Werte xan den s Typ an S, der ein Slice-Typ sein muss, und gibt das resultierende Slice zurück, ebenfalls vom Typ S. Die Werte xwerden an einen Parameter vom Typ übergeben, ...Twobei Tder Elementtyp von Sund die jeweiligen Regeln für die Parameterübergabe gelten. Als Sonderfall akzeptiert append auch ein erstes Argument, das dem Typ zugewiesen werden kann, gefolgt von []byteeinem zweiten Argument vom stringTyp .... Dieses Formular hängt die Bytes der Zeichenfolge an.

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

s0 := []int{0, 0}
s1 := append(s0, 2)        // append a single element     s1 == []int{0, 0, 2}
s2 := append(s1, 3, 5, 7)  // append multiple elements    s2 == []int{0, 0, 2, 3, 5, 7}
s3 := append(s2, s0...)    // append a slice              s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}

Argumente an ... Parameter übergeben

Wenn fes mit dem endgültigen Parametertyp variadisch ...Tist, entspricht das Argument innerhalb der Funktion einem Parameter vom Typ []T. Bei jedem Aufruf von fist das an den letzten Parameter übergebene Argument ein neues Slice vom Typ, []Tdessen aufeinanderfolgende Elemente die tatsächlichen Argumente sind, die alle dem Typ zuweisbar sein müssen T. Die Länge des Slice ist daher die Anzahl der Argumente, die an den letzten Parameter gebunden sind, und kann für jede Aufrufstelle unterschiedlich sein.

Die Antwort auf Ihre Frage finden Sie s3 := append(s2, s0...)in der Go-Programmiersprachenspezifikation . Zum Beispiel,

s := append([]int{1, 2}, []int{3, 4}...)

Nichts gegen die anderen Antworten, aber ich fand die kurze Erklärung in den Dokumenten leichter verständlich als die Beispiele in ihnen:

func anhängen

func append(slice []Type, elems ...Type) []TypeDie integrierte Funktion zum Anhängen hängt Elemente an das Ende eines Slice an. Wenn die Kapazität ausreichend ist, wird das Ziel neu aufgeteilt, um die neuen Elemente aufzunehmen. Ist dies nicht der Fall, wird ein neues zugrunde liegendes Array zugewiesen. Anhängen gibt das aktualisierte Slice zurück. Es ist daher notwendig, das Ergebnis des Anhängens zu speichern, häufig in der Variablen, die das Slice selbst enthält:

slice = append(slice, elem1, elem2)
slice = append(slice, anotherSlice...)

Als Sonderfall ist es zulässig, eine Zeichenfolge wie folgt an ein Byte-Slice anzuhängen:

slice = append([]byte("hello "), "world"...)

Ich denke, es ist wichtig darauf hinzuweisen und zu wissen, dass, wenn das Ziel-Slice (das Slice, an das Sie anhängen) über eine ausreichende Kapazität verfügt, das Anhängen "an Ort und Stelle" erfolgt, indem das Ziel neu aufgeteilt wird (erneutes Schneiden, um seine Länge zu erhöhen, um zu sein) in der Lage, die anhängbaren Elemente aufzunehmen).

Dies bedeutet, dass wenn das Ziel durch Schneiden eines größeren Arrays oder Slice erstellt wurde, das zusätzliche Elemente enthält, die über die Länge des resultierenden Slice hinausgehen, diese möglicherweise überschrieben werden.

Zur Demonstration sehen Sie dieses Beispiel:

a := [10]int{1, 2}
fmt.Printf("a: %v\n", a)

x, y := a[:2], []int{3, 4}
fmt.Printf("x: %v, y: %v\n", x, y)
fmt.Printf("cap(x): %v\n", cap(x))

x = append(x, y...)
fmt.Printf("x: %v\n", x)

fmt.Printf("a: %v\n", a)

Ausgabe (versuchen Sie es auf dem Go-Spielplatz ):

a: [1 2 0 0 0 0 0 0 0 0]
x: [1 2], y: [3 4]
cap(x): 10
x: [1 2 3 4]
a: [1 2 3 4 0 0 0 0 0 0]

Wir haben ein "Backing" -Array amit Länge erstellt 10. Dann erstellen wir das xZiel-Slice, indem wir dieses aArray aufteilen. Das ySlice wird mit dem zusammengesetzten Literal erstellt []int{3, 4}. Nun , wenn wir anhängen yzu x, ist das Ergebnis der erwartete [1 2 3 4], aber was werden kann , überraschend ist , dass die Träger Array aauch geändert, weil Kapazität xheißt , 10die ausreicht, anhängen , yum es, so xwird Resliced , die auch die gleiche verwenden aTrägeranordnung und append()kopiert dort Elemente von y.

Wenn Sie dies vermeiden möchten, können Sie einen vollständigen Slice-Ausdruck verwenden, der die Form hat

a[low : high : max]

Dadurch wird ein Slice erstellt und die Kapazität des resultierenden Slice durch Festlegen auf gesteuert max - low.

Siehe das modifizierte Beispiel (der einzige Unterschied ist , dass wir schaffen xwie folgt aus : x = a[:2:2]:

a := [10]int{1, 2}
fmt.Printf("a: %v\n", a)

x, y := a[:2:2], []int{3, 4}
fmt.Printf("x: %v, y: %v\n", x, y)
fmt.Printf("cap(x): %v\n", cap(x))

x = append(x, y...)
fmt.Printf("x: %v\n", x)

fmt.Printf("a: %v\n", a)

Ausgabe (probieren Sie es auf dem Go Playground )

a: [1 2 0 0 0 0 0 0 0 0]
x: [1 2], y: [3 4]
cap(x): 2
x: [1 2 3 4]
a: [1 2 0 0 0 0 0 0 0 0]

Wie Sie sehen können, erhalten wir das gleiche xErgebnis, aber das Hintergrundarray ahat sich nicht geändert, da die Kapazität von x"nur" war 2(dank des vollständigen Slice-Ausdrucks a[:2:2]). Zum Anhängen wird ein neues Hintergrundarray zugewiesen, in dem die Elemente von beiden xund gespeichert werden können y, das sich von unterscheidet a.

Ich möchte die Antwort von @icza hervorheben und ein wenig vereinfachen, da es sich um ein entscheidendes Konzept handelt. Ich gehe davon aus, dass der Leser mit Slices vertraut ist .

c := append(a, b...)

Dies ist eine gültige Antwort auf die Frage. ABER wenn Sie die Slices 'a' und 'c' später im Code in einem anderen Kontext verwenden müssen, ist dies nicht die sichere Methode, um Slices zu verketten.

Lesen wir zur Erklärung den Ausdruck nicht in Form von Slices, sondern in Form von zugrunde liegenden Arrays:

"Nehmen Sie das (zugrunde liegende) Array von 'a' und hängen Sie Elemente aus dem Array 'b' an. Wenn das Array 'a' über genügend Kapazität verfügt, um alle Elemente aus 'b' aufzunehmen, ist das zugrunde liegende Array von 'c' kein neues Array , es wird tatsächlich Array 'a' sein. Grundsätzlich zeigt Slice 'a' len (a) Elemente des zugrunde liegenden Arrays 'a' und Slice 'c' zeigt len ​​(c) des Arrays 'a'. "

append () erstellt nicht unbedingt ein neues Array! Dies kann zu unerwarteten Ergebnissen führen. Siehe Go Playground-Beispiel .

Verwenden Sie immer die Funktion make (), wenn Sie sicherstellen möchten, dass dem Slice ein neues Array zugewiesen wird. Zum Beispiel gibt es hier nur wenige hässliche, aber effizient genug Optionen für die Aufgabe.

la := len(a)
c := make([]int, la, la + len(b))
_ = copy(c, a)
c = append(c, b...)

la := len(a)
c := make([]int, la + len(b))
_ = copy(c, a)
_ = copy(c[la:], b)

Funktion append () und Spread-Operator

Zwei Slices können mithilfe der appendMethode in der Standard-Golang-Bibliothek verkettet werden . Welches ist ähnlich wie die variadicFunktionsoperation. Also müssen wir verwenden...

package main

import (
    "fmt"
)

func main() {
    x := []int{1, 2, 3}
    y := []int{4, 5, 6}
    z := append([]int{}, append(x, y...)...)
    fmt.Println(z)
}

Die Ausgabe des obigen Codes lautet: [1 2 3 4 5 6]

append([]int{1,2}, []int{3,4}...)wird funktionieren. Argumente an übergeben... Parameter übergeben.

Wenn fist variadische mit einem letzten Parameter pvom Typ ...T, dann innerhalb von fder Art der päquivalent zu geben []T.

Wenn fohne tatsächliche Argumente für aufgerufen wird p, plautet der übergebene Wert is nil.

Andernfalls handelt es sich bei dem übergebenen Wert um ein neues Slice vom Typ []Tmit einem neuen zugrunde liegenden Array, dessen aufeinanderfolgende Elemente die tatsächlichen Argumente sind, denen alle zugewiesen werden müssen T. Die Länge und Kapazität des Slice ist daher die Anzahl der Argumente, die an pjede Aufrufstelle gebunden sind und sich für diese unterscheiden können.

Angesichts der Funktion und Aufrufe

func Greeting(prefix string, who ...string)
Greeting("nobody")
Greeting("hello:", "Joe", "Anna", "Eileen")