Append в Go: как работает append, почему slice внезапно копируется и где чаще всего ловят баги

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

Что именно происходит в памяти после append?

Что такое функция append в Golang

package main
import "fmt"
func main() {
nums := []int{1, 2, 3}
nums = append(nums, 4)
fmt.Println(nums)
}

[1 2 3 4]

Почему append в Go встроенная, а не метод

append(slice, elems...)

Можно добавить сразу несколько элементов

nums := []int{1, 2, 3}
nums = append(nums, 4, 5, 6)
fmt.Println(nums)

[1 2 3 4 5 6]

Почему тема append намного важнее, чем кажется

Практический вывод

Почему append работает только со slice

Почему не с array

arr := [3]int{1, 2, 3}

arr = append(arr, 4)

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

Почему не с map

m := map[string]int{}
m["go"] = 1

m := map[string][]int{"a": {1, 2, 3}}
m["a"] = append(m["a"], 4, 5)
fmt.Println(m)

Почему не со string напрямую

b := []byte{"G", "o"}
_ = b

b := []byte{'G', 'o'}
b = append(b, "lang"...)
fmt.Println(string(b))

Golang

Короткая запоминалка

• append работает со slice
•array надо сначала превратить в slice
•map не аппендят, но можно аппендить slice внутри map
•string напрямую не аппендят, но можно аппендить её байты в []byte

len, cap и underlying array: без этого append не понять

Что такое len

s := []int{10, 20, 30}
fmt.Println(len(s)) // 3

Что такое cap

s := make([]int, 0, 5)
fmt.Println(len(s)) // 0
fmt.Println(cap(s)) // 5

Почему это важно для append

Пример с make

s := make([]int, 0, 3)
fmt.Println(len(s), cap(s))
s = append(s, 1, 2, 3)
fmt.Println(s, len(s), cap(s))

s = append(s, 4)
fmt.Println(s, len(s), cap(s))

Почему скорее всего

Если cap не хватает, append может выделить новую память

Когда append использует старую память, а когда создаёт новую

Сценарий 1. Места хватает

package main
import "fmt"
func main() {
s := make([]int, 2, 4)
s[0] = 10
s[1] = 20
t := append(s, 30)
fmt.Println("s:", s, len(s), cap(s))
fmt.Println("t:", t, len(t), cap(t))
}

Что это значит practically

s := make([]int, 2, 4)
s[0], s[1] = 10, 20
t := append(s, 30)
t[0] = 999
fmt.Println(s) // [999 20]
fmt.Println(t) // [999 20 30]

Сценарий 2. Места не хватает

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

Почему это так важно

Когда это всплывает в реальной работе

Почему результат append нужно сохранять

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

Почему так нельзя

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

Почему язык устроен именно так

Особенно неприятный случай — внутри функции

func addValue(s []int) {
s = append(s, 100)
}
func main() {
nums := []int{1, 2, 3}
addValue(nums)
fmt.Println(nums)
}

Как правильно

func addValue(s []int) []int {
s = append(s, 100)
return s
}
func main() {
nums := []int{1, 2, 3}
nums = addValue(nums)
fmt.Println(nums)
}

Append slice к slice, append nil slice, append в начало и удаление через append

Как append один slice к другому

s1 := []int{1, 2, 3}
s2 := []int{4, 5, 6}
s1 = append(s1, s2...)
fmt.Println(s1)

[1 2 3 4 5 6]

Append к nil slice

var nums []int
fmt.Println(nums == nil) // true
nums = append(nums, 1, 2, 3)
fmt.Println(nums)

[1 2 3]

Почему это удобно

m := map[string][]string{}
m["go"] = append(m["go"], "slice", "append")

Как добавить элемент в начало slice

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

[0 1 2 3]

Как удалить элемент через append

s := []int{10, 20, 30, 40, 50}
i := 2
s = append(s[:i], s[i+1:]...)
fmt.Println(s)

[10 20 40 50]

Что здесь происходит

Важный нюанс

Append строковых значений

tags := []string{"go", "backend"}
tags = append(tags, "append")
fmt.Println(tags)

Append байтов и строки

buf := []byte("Go")
buf = append(buf, "lang"...)
fmt.Println(string(buf))

Golang

Append и map, array, string: что можно, а что нельзя

Append golang map

m := map[string]int{"a": 1}
// append(m, ...)

m := map[string][]int{"a": {1, 2, 3}}
m["a"] = append(m["a"], 4, 5)

Append golang array

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

Append golang string

s := []string{"a", "b"}
s = append(s, "c")

b := []byte("Hello")
b = append(b, " Go"...)
fmt.Println(string(b))

Append golang массив

В Go append работает со slice, а не с массивом.

Частые ошибки новичков и вопросы на собеседовании

append(s, 4)

Что любят спрашивать на собеседовании

Короткий итог-шпаргалка

Шпаргалка по функции append в Golang

Практика: 7 коротких упражнений, чтобы append реально закрепился

Упражнение 1. Один элемент

Упражнение 2. Несколько элементов

Упражнение 3. Append slice к slice

Упражнение 4. Nil slice

Упражнение 5. len и cap

Упражнение 6. Общая память

Упражнение 7. Удаление через append

Мини-шаблоны, которые стоит унести в работу

s = append(s, x)

s = append(s, a, b, c)

s1 = append(s1, s2...)

var s []int
s = append(s, 1, 2, 3)

s = append([]int{0}, s...)

s = append(s[:i], s[i+1:]...)

Как самому проверить, что тема реально улеглась

Зачем понимать append, если это кажется маленькой функцией