我试图切片结合[1, 2]和切片[3, 4] 我怎样才能在Go做到这一点？
我试过了：
append([]int{1,2}, []int{3,4})
但得到：
cannot use []int literal (type []int) as type int in append
然而， 该文件似乎表明这是可能的，我缺少什么？
slice = append(slice, anotherSlice...)
Answer 1:
第二切片后加入点：
//---------------------------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}...)
}
Answer 2:
追加并复制片
所述可变参数函数
append追加的零个或更多个值x到s类型的S，它必须是一个切片类型，并返回生成的切片，也类型的S。 值x被传递给类型的参数...T其中T是的元素类型S和相应的参数传递规则适用。 作为一种特殊的情况下，追加也接受分配的第一参数来键入[]byte与第二个参数string接着类型...。 这种形式的附加字符串的字节数。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...)在围棋编程语言规范 。 例如，
s := append([]int{1, 2}, []int{3, 4}...)
Answer 3:
并不反对其他的答案，但我发现在简要说明中的文档比它们的例子更容易理解：
FUNC追加
func append(slice []Type, elems ...Type) []Type的附加内置函数追加元素切片的末端。 如果它具有足够的容量，将目的地resliced以适应新的元素。 如果不是这样，一个新的基础数组将被分配。 追加返回更新的切片。 因此，有必要经常存储追加的结果，在可变保持片本身：slice = append(slice, elem1, elem2) slice = append(slice, anotherSlice...)作为一个特例，它是合法的字符串附加到字节片，就像这样：
slice = append([]byte("hello "), "world"...)
Answer 4:
我想指出，要知道，如果目标切片（你追加到片）有足够的能力，追加会发生“就地”是非常重要的，通过reslicing目的地（reslicing 增加其长度为了能够容纳可附加元素）。
这意味着，如果所述目的地是由切片具有超出所得到的片段的长度的附加元件更大阵列或切片创建的，它们可能会被覆盖。
为了演示，请参阅下面的例子：
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)
输出（尝试在转到操场 ）：
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]
我们创建了一个“背衬”数组a长度为10 。 然后，我们创建了x通过切割该目的地切片a阵列， y切片使用复合字面创建[]int{3, 4} 现在，当我们追加y到x ，结果是预期的[1 2 3 4]但什么可以是令人惊讶的是，该背衬阵列a也改变，因为容量x是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)
输出（尝试在围棋游乐场 ）
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 。
Answer 5:
追加（）函数和蔓延运营商
两片可以使用串联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]
Answer 6:
append([]int{1,2}, []int{3,4}...)将起作用。 传递参数给...参数。
如果f是可变参数与最终的参数p型的...T ，然后内f的类型p是相当于类型[]T 。
如果f与用于没有实际参数调用p ，传递给值p是nil 。
否则，传递的值是类型的新切片[]T用新的底层数组，其连续元素是实际的参数，其中所有必须分配给T 。 因此，片的长度和容量的绑定到参数的个数p ，并且可以为每个调用位置不同。
由于功能和来电
func Greeting(prefix string, who ...string)
Greeting("nobody")
Greeting("hello:", "Joe", "Anna", "Eileen")
文章来源: Concatenate two slices in Go
