Concatenate Two Slices in Go

  1. Declaration of Slice
  2. Concatenation of Slices
  3. Working of Go Append() Function

In Go, a slice is the dynamic data structure that stores multiple elements of the same data type. They can also be thought of as variable-sized arrays that have indexing as of array but their size is not fixed as they can be resized. As slices are dynamic in nature we can append a new element to slice or concatenate two or more slices using the append function.

Declaration of Slice

The declaration of a Slice is similar to the declaration of arrays, but the size is not specified.

package main

import "fmt"

func main() {
    var Slice1 = []int{1, 2, 3, 4}
    fmt.Printf("Length of Slice: %v\n",len(Slice1))
    fmt.Printf("First Element: %v\n",Slice1[0])
    fmt.Printf("Second Element: %v\n",Slice1[1])
    fmt.Printf("Third Element: %v\n",Slice1[2])
    fmt.Printf("Fourth Element: %v\n",Slice1[3])

}

Output:

Length of Slice: 4
First Element: 1
Second Element: 2
Third Element: 3
Fourth Element: 4

Concatenation of Slices

We use the built-in append() function to add elements to list or concatenate two or more slices together. If there is sufficient capacity, the destination is re-sliced to accommodate the new elements. If no sufficient capacity is available, a new underlying is allocated and contents are copied over. Finally, the append function returns the updated slice.

Append a Single Element to Slice

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)  
    fmt.Printf("slice_1: %v\n", slice_1)
    fmt.Printf("slice_2: %v\n", slice_2)

}

Output:

slice_1: [1 2]
slice_2: [1 2 3]

Append Multiple Elements to a Slice

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)
    slice_3 := append(slice_2, 4,5,6)   
    fmt.Printf("slice_3: %v\n", slice_3)

}

Output:

slice_3: [1 2 3 4 5 6]

Concatenate Two Slices

package main

import "fmt"

func main() {
    var slice_3 = []int{1, 2, 3, 4, 5, 6}
    var slice_4 = []int{7,8}
    
    slice_5 := append(slice_3,slice_4...) 
    fmt.Printf("slice_4: %v\n", slice_4)
    fmt.Printf("slice_5: %v\n", slice_5)

}

Output:

slice_4: [7 8]
slice_5: [1 2 3 4 5 6 7 8]

An important point to be noticed while concatenating two slices in a go is that ... is essential after slice_4 as append() is a variadic function, just like other variadic functions. ... lets you pass multiple arguments to a function from a slice. Here append function is called recursively for each element in slice_4.

Append a String to a Byte Slice

var slice []byte = append([]byte("abc "), "def"...)
fmt.Printf("slice: %v\n", slice)

Output:

slice: [97 98 99 32 100 101 102]

Here the characters are encoded in UTF-8 using 3 bytes which represent ASCII value of characters. The slice byte can be converted back to string as:

slice_str := string(slice)
fmt.Printf("String: %v\n", slice_str)

Output:

Slice: abc def

Working of Go Append() Function

The append() built-in function takes a slice, appends all the elements to the end of an input slice and finally returns the concatenated slice. If the destination slice has sufficient capacity, the slice is re-sliced to accommodate the new appended elements. But if the destination does not have sufficient capacity, a new array is created and the elements present in the existing slices are copied into the new array and finally, a new array is returned by the function.

package main

import "fmt"

func main() {

    slice_1 := []int{0, 1, 2}
    fmt.Println("slice_1 : ", slice_1)
    fmt.Println("Capacity of slice_1: ", cap(slice_1))

    res_1 := append(slice_1, 3)
    fmt.Println("res_1 : ", res_1)
    fmt.Println("Capacity of res_1: ", cap(res_1))

    slice_2 := make([]int, 3, 5)  //Create slice_1 with length 3 and capacity 5
    copy(slice_2, []int{0, 1, 2}) //Copy elements into slice_1
    fmt.Println("slice_2 : ", slice_2)
    fmt.Println("Capacity of slice_2: ", cap(slice_2))

    res_2 := append(slice_2, 3)
    fmt.Println("res_2 : ", res_2)
    fmt.Println("Capacity of res_2: ", cap(res_2))

}

Output:

slice_1 :  [0 1 2]
Capacity of slice_1:  3
res_1 :  [0 1 2 3]
Capacity of res_1:  6
slice_2 :  [0 1 2]
Capacity of slice_2:  5
res_2 :  [0 1 2 3]
Capacity of res_2:  5

Here slice_1 doesn’t have enough capacity to append new elements so a new slice of capacity 6 is created and all elements in existing slices are copied to newly created slice.

However, slice_2 has enough capacity to append new elements and hence elements are appended in the existing slice.

Related Article - Go Slices

  • How to Delete an Element From a Slice in Golang
  • comments powered by Disqus