Соединить два кусочка в

Я пытаюсь объединить ломтик [1, 2] и фрагмент [3, 4]. Как я могу сделать это пойти?

пробовал:

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

но есть:

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

однако, документация кажется, это указывает на то, что это возможно, что я упускаю?

slice = append(slice, anotherSlice...)

6 ответов


добавить точки после второй фрагмент:

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

это так же, как и любая другая вариационная функция.

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

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

добавление и копирование ломтиков

функция variadic append добавляет ноль или более значений x to s типа S, который должен быть типом среза, и возвращает результат ломтик, также типа S. Значения x передаются в параметр тип ...T здесь T тип элементов S и соответствующих применяются правила передачи параметров. Как особый случай, append также принимает начало аргумент, присваиваемый типу []byte со вторым аргументом типа .... Эта форма добавляет байты строка.

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}

передача аргументов ... параметры

если f является вариативным с конечным типом параметра ...T, затем в функция аргумент эквивалентен параметру типа []T. На каждый зов f, аргумент, переданный конечному параметру, является новым ломтик типа []T чьи последовательные элементы являются фактическими аргументами, которые все должны быть назначены типу T. Длина среза поэтому количество аргументов, привязанных к конечному параметру и может различаются для каждого сайта вызова.

ответ на ваш вопрос-это пример s3 := append(s2, s0...) на Go Спецификация Языка Программирования. Например,

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

ничего против других ответов, но я нашел краткое объяснение в документы легче понять, чем примеры в них:

добавить кнопку func

func append(slice []Type, elems ...Type) []Type встроенное добавление функция добавляет элементы в конец фрагмента. Если он имеет достаточное емкость, назначение resliced для того чтобы приспособить новые элементы. Если это не так, будет выделен новый базовый массив. Добавлять возвращает обновленный фрагмент. Это поэтому необходимо хранить результат добавления, часто в переменной, удерживающей сам срез:

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

в частном случае законно добавлять строку в байтовый срез, вот так:

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

я думаю, что важно указать и знать, что если целевой срез (срез, к которому вы добавляете) имеет достаточную емкость, добавление произойдет "на месте", путем повторной ссылки на пункт назначения (повторной ссылки на увеличить своя длина для того чтобы мочь приспособить appendable элементы).

это означает, что если назначение было создано путем нарезки большего массива или среза, который имеет дополнительные элементы за пределами длины результирующего среза, они могут перезаписываются.

чтобы продемонстрировать, см. Этот пример:

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)

вывод (попробуйте на Go Playground):

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]

мы создали массив" backing"a длиной 10. Затем мы создаем x назначение ломтик, нарезая это a массив, y slice создается с помощью составного литерала []int{3, 4}. Теперь, когда мы добавляем y to x, результат ожидаемый [1 2 3 4], но что может быть удивительного в что бэк массив a также изменен, потому что емкость x is 10 которого достаточно, чтобы добавить y, так что x resliced который также будет использовать то же самое a поддержка массива, и append() скопировать элементов y в там.

если вы хотите избежать этого, вы можете использовать полное выражение фрагмент, который имеет вид

a[low : high : max]

который создает срез, а также управляет емкостью результирующего среза с помощью установка его в max - low.

см. измененный пример (единственная разница заключается в том, что мы создаем x такой: 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)

вывод (попробуйте на 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]

как вы можете видеть, мы получаем то же самое x результат, но резервный массив a не изменилось, потому что емкость x "только" 2 (благодаря полному выражению фрагмент a[:2:2]). Таким образом, чтобы сделать добавление, новый массив поддержки выделено, что может хранить элементы обоих x и y, который отличается от a.


append([]int{1,2}, []int{3,4}...) будет работать. Передача аргументов в ... параметры.

если f является вариативным с конечным параметром p типа ...T, затем в f тип p эквивалентно типа []T.

если f вызывается без фактических аргументов для p, стоимость переданного p is nil.

в противном случае переданное значение является новым кусочком типа []T С новым базовым массивом, последовательные элементы которого являются фактическими аргументами, которые все должны быть назначены T. Таким образом, длина и емкость среза-это количество аргументов, связанных с p и может отличаться для каждого сайта вызова.

учитывая функцию и вызовы

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

функции append( ) и ...

два ломтика могут быть объединены с помощью append метод в стандартной библиотеке golang. Который похож на variadic управление функции. Поэтому нам нужно использовать ...

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)
}

выход выше код: [1 2 3 4 5 6]