Concatenate two slices in Go

Question

I m trying to combine the slice  1  2  and the slice  3  4   How can I do this in Go   I tried   append   int 1 2     int 3 4     but got   cannot use   int literal  type   int  as type int in append   However  the documentation seems to indicate this is possible  what am I missing   slice   append slice  anotherSlice

User · Answer

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.

The answer to your question is example s3 := append(s2, s0...) in the Go Programming Language Specification. For example,

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

User · Answer

I would like to emphasize  icza answer and simplify it a bit since it is a crucial concept  I assume that reader is familiar with slices   c    append a  b       This is a valid answer to the question   BUT if you need to use slices  a  and  c  later in code in different context  this is not the safe way to concatenate slices    To explain  lets read the expression not in terms of slices  but in terms of underlying arrays       Take  underlying  array of  a  and append elements from array  b  to   it  If array  a  has enough capacity to include all elements from  b    - underlying array of  c  will not be a new array  it will actually be array  a   Basically  slice  a  will show len a  elements of   underlying array  a   and slice  c  will show len c  of array  a      append   does not necessarily create a new array  This can lead to unexpected results  See Go Playground example   Always use make   function if you want to make sure that new array is allocated for the slice  For example here are few ugly but efficient enough options for the task   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

User · Answer

I think it s important to point out and to know that if the destination slice  the slice you append to  has sufficient capacity  the append will happen  in-place   by reslicing the destination  reslicing to increase its length in order to be able to accommodate the appendable elements    This means that if the destination was created by slicing a bigger array or slice which has additional elements beyond the length of the resulting slice  they may get overwritten   To demonstrate  see this example   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    Output  try it on the 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    We created a  backing  array a with length 10  Then we create the x destination slice by slicing this a array  y slice is created using the composite literal   int 3  4   Now when we append y to x  the result is the expected  1 2 3 4   but what may be surprising is that the backing array a also changed  because capacity of x is 10 which is sufficient to append y to it  so x is resliced which will also use the same a backing array  and append   will copy elements of y into there   If you want to avoid this  you may use a full slice expression which has the form  a low   high   max    which constructs a slice and also controls the resulting slice s capacity by setting it to max - low   See the modified example  the only difference is that we create x like this  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    Output  try it on the 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    As you can see  we get the same x result but the backing array a did not change  because capacity of x was  only  2  thanks to the full slice expression a  2 2    So to do the append  a new backing array is allocated that can store the elements of both x and y  which is distinct from a

User · Answer

append    function and spread operator  Two slices can be concatenated using append method in the standard golang library  Which is similar to the variadic function operation  So we need to use      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         output of the above code is    1 2 3 4 5 6

User · Answer

append   int 1 2     int 3 4      will work  Passing arguments to     parameters   If f is variadic with a final parameter p of type    T  then within f the type of p is equivalent to type   T    If f is invoked with no actual arguments for p  the value passed to p is nil    Otherwise  the value passed is a new slice of type   T with a new underlying array whose successive elements are the actual arguments  which all must be assignable to T  The length and capacity of the slice is therefore the number of arguments bound to p and may differ for each call site   Given the function and calls  func Greeting prefix string  who    string  Greeting  nobody   Greeting  hello     Joe    Anna    Eileen

User · Answer

Nothing against the other answers  but I found the brief explanation in the docs more easily understandable than the examples in them      func append      func append slice   Type  elems    Type    Type The append built-in   function appends elements to the end of a slice  If it has sufficient   capacity  the destination is resliced to accommodate the new elements    If it does not  a new underlying array will be allocated  Append   returns the updated slice  It is therefore necessary to store the   result of append  often in the variable holding the slice itself   slice   append slice  elem1  elem2  slice   append slice  anotherSlice           As a special case  it is legal to append a string to a byte slice    like this   slice   append   byte  hello      world

User · Answer

Add dots after the second slice     ---------------------------vvv append   int 1 2     int 3 4          This is just like any other variadic function   func foo is    int        for i    0  i  lt  len is   i             fmt Println is i            func main         foo   int 9 8 7 6 5

[go] Concatenate two slices in Go

Examples related to go

Examples related to append

Examples related to slice

Examples related to variadic-functions