我想强调@icza的答案，并简化一下，因为它是一个至关重要的概念。我假设读者对切片很熟悉。

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

这是对这个问题的有效回答。 但是，如果你需要在以后的代码中在不同的上下文中使用切片'a'和'c'，这不是连接切片的安全方法。

为了解释，让我们不从切片的角度来阅读表达式，而是从底层数组的角度来阅读:

取(底层的)数组'a'，并将数组'b'中的元素附加到 它。如果数组'a'有足够的容量包含'b'中的所有元素 c的底层数组不会是一个新数组，它实际上是数组a。基本上，切片'a'将显示len(a)个元素 底层数组a和切片c将显示数组a的len(c) "

Append()不一定创建一个新数组!这可能会导致意想不到的结果。参见Go Playground的例子。

如果你想确保新数组被分配给切片，总是使用make()函数。例如，这里有一些丑陋但足够有效的任务选项。

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)

在第二片之后加点:

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

我想强调@icza的答案，并简化一下，因为它是一个至关重要的概念。我假设读者对切片很熟悉。

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

这是对这个问题的有效回答。 但是，如果你需要在以后的代码中在不同的上下文中使用切片'a'和'c'，这不是连接切片的安全方法。

为了解释，让我们不从切片的角度来阅读表达式，而是从底层数组的角度来阅读:

取(底层的)数组'a'，并将数组'b'中的元素附加到 它。如果数组'a'有足够的容量包含'b'中的所有元素 c的底层数组不会是一个新数组，它实际上是数组a。基本上，切片'a'将显示len(a)个元素 底层数组a和切片c将显示数组a的len(c) "

Append()不一定创建一个新数组!这可能会导致意想不到的结果。参见Go Playground的例子。

如果你想确保新数组被分配给切片，总是使用make()函数。例如，这里有一些丑陋但足够有效的任务选项。

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)

Append()函数和展开运算符

可以使用标准golang库中的append方法连接两个片。这类似于变进函数的运算。所以我们需要用…

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]

Appending to and copying slices The variadic function append appends zero or more values x to s of type S, which must be a slice type, and returns the resulting slice, also of type S. The values x are passed to a parameter of type ...T where T is the element type of S and the respective parameter passing rules apply. As a special case, append also accepts a first argument assignable to type []byte with a second argument of string type followed by .... This form appends the bytes of the 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} Passing arguments to ... parameters If f is variadic with final parameter type ...T, then within the function the argument is equivalent to a parameter of type []T. At each call of f, the argument passed to the final parameter is a new slice of type []T whose successive elements are the actual arguments, which all must be assignable to the type T. The length of the slice is therefore the number of arguments bound to the final parameter and may differ for each call site.

你问题的答案是Go编程语言规范中的示例s3:= append(s2, s0…)例如,

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

似乎是泛型的完美用途(如果使用1.18或更高版本)。

func concat[T any](first []T, second []T) []T {
    n := len(first);
    return append(first[:n:n], second...);
}