Массивы в Go являлись для меня одной из сложных тем, так как я не понимал как они работают. В данной статье рассмотрим как же именно работают слайсы и массивы в Go, а также как именно работает append и copy.
Массивы
Массивы - коллекция элементов одного типа. Длина массива не может изменяться. Вот как мы можем создать массив в Go:
arr := [4]int{3,2,5,4}
Если мы создадим два массива в Go с разными длинами, то два массива будут иметь разные типы, так как длина массива в Go, входит в его тип:
a := [3]int{} b := [2]int{} // (a) [2]int и (b) [3]int - разные типы
Более того, если нам лень писать длину массива, то мы можем сказать компилятору, чтобы он сам подсчитал длину:
a := [...]int{1, 2, 3} // [3]int
Передача по значению
Переменная, которую мы инициализировали со значением массива, содержит именно значения массива, а не ссылку на первый элемент массива (как это сделано в C).
Именно поэтому массив в Go является примитивным типом данных, он может копироваться при передаче в другую переменную. По умолчанию в Go все значения копируются, а не передаются с помощью ссылки. Это значит, что если мы передадим наш массив в функцию, то Go скопирует данный массив и в функции будет находиться уже совершенно другой массив (вернее точная копия исходного массива).
Внизу мы рассмотрим пример, где мы скопируем массив, а затем посмотрим на адрес, по которому хранится значение:
package main import "fmt" func main() { var initArray = [...]int{1, 2, 3} var copyArray = initArray fmt.Printf("Address of initArray: %p\n", &initArray) fmt.Printf("Address of copyArray: %p\n", ©Array) } /* Output: Address of initArray: 0xc00001a018 Address of copyArray: 0xc00001a030 */
Слайсы
Слайсы в Go более гибкие, они позволяют изменять свою длину. По сути слайсы являются надмножеством массивов. Слайсы создают нам массив, которым мы можем пользоваться как обычным массивом и при надобности расширяют его.
Слайсы можно создать двумя способами:
// С помощью make var foo []byte s = make([]byte, 5, 5) // С помощью shorthand syntax bar := []byte{}
Способ с make
Способ с make является более интересным, так как дает нам возможность задать тип, длину и вместимость.
С типом я думаю никаких проблем быть не должно. Тип слайса формируется в виде []тип.
С длиной тоже ничего интересного. В зависимости от введенного количества - массив заполнится нулевыми значениями, например:
package main import "fmt" func main() { var foo = make([]byte, 5) var bar = make([]int, 10) var fee = make([]string, 2) fmt.Println(foo, bar, fee) } /* Output: [0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0] [ ] */
Последний параметр - вместимость играет важную роль в производительности программы, а также является интересным. По сути он говорит о том сколько памяти нужно выделить заранее под наш массив, чтобы при расширении нам не пришлось искать новый участок памяти.
Например, если мы создадим массив с вместимостью в 10 элементов, наполним его 5-ю элементами, а потом добавим один - адрес массива не изменится:
package main import "fmt" func main() { var foo = make([]int, 5, 10) fmt.Printf("Address of foo array [before append]: %p\n", &foo) foo = append(foo, 222) fmt.Printf("Address of foo array [after append]: %p\n", &foo) } /* Output: Address of foo array [before append]: 0xc0000aa018 Address of foo array [after append]: 0xc0000aa018 */
К слову, если мы явно не задали вместимость слайса (то есть использовали конструкцию
make([]int, 5)), то вместимость будет равна длине массива (в данном случае - 5).
Если же мы укажем вместимость массива меньше, чем его длину, то код и вовсе нескомпилируется:
package main import "fmt" func main() { var foo = make([]int, 5, 4) fmt.Printf("Capacity of the array: ", cap(foo)) } /* ./prog.go:6:24: invalid argument: length and capacity swapped */
Что будет если мы переполним вместимость?
Если же мы переполним вместимость слайса, то вместимость умножится на 2:
package main import "fmt" func main() { var foo = make([]int, 10, 10) // Изначальная вместимость - 10 foo = append(foo, 2) // Добавляем элемент fmt.Println("Length of the array:", len(foo)) fmt.Println("Capacity of the array:", cap(foo)) } /* Output: Length of the array: 11 Capacity of the array: 20 */
При этом в памяти произойдет следующее:
Go понимает что нам не хватает памяти и посмотрит есть ли после текущего сегмента памяти еще столько же ячеек;
Если ячейки есть, он не будет передвигать массив и просто зарезервирует больше памяти;
Если ячеек нет, то он скопирует всю информацию из уже использующегося сегмента и найдет вдвое больше свободных ячеек, после нажождения он перенесет туда все данные и отдаст нам адрес сегмента;
Shorthand-syntax
С короткой версией объявления слайса все проще:
package main import "fmt" func main() { foo := []int{1, 2, 3} fmt.Println("Length of the array:", len(foo)) fmt.Println("Capacity of the array:", cap(foo)) } /* Output: Length of the array: 3 Capacity of the array: 3 */
В примере вверху Go создаст массив (под капотом) с длиной в три ячейки и такой же вместимостью.
Срезы на слайсах
Срезом на слайсе является дочерний слайс, который ссылется только на часть слайса:
package main import "fmt" func main() { name := []string{"D", "a", "n", "i", "i", "l"} firstThreeLetters := name[:3] fmt.Println(firstThreeLetters) } /* Output: [D a n] */
Не смотря на то, что слайс и срез - понятия взаимозаменяемые (а если быть точнее, то срез - перевод от англ. slice), мы будем называть слайсами все новосозданные слайсы с помощью make() или shorthand-синтаксиса, а срезами будем называть слайсы проделанные над уже существующим массивом.
Мы также можем делать срезы на массивах, таким образом мы можем делать массивы динамически расширяемыми:
package main import "fmt" func main() { nameArray := [6]string{"D", "a", "n", "i", "i", "l"} nameSlice := nameArray[:] nameSlice = append(nameSlice, "!") fmt.Println(nameSlice) } /* Output: [D a n i i l !] */
Слайс под капотом
Слайс под капотом является структурой, которая содержит ссылку на исходный массив, длину и вместимость:
struct { array *[]T length int capacity int }
Когда мы создаем новый слайс или срезаем массив, то ссылка массива присвивается полю array, с помощью данного указателя слайс сможет обращаться к массиву под капотом. length и capacity хранят длину и вместимость, соответственно.
Поскольку слайс ссылается на часть массива, мы можем срезать часть массива. Срез не копирует элементы массива, он просто ссылается на них. Таким образом при изменении среза, изменится и массив, с которого мы брали срез:
package main import "fmt" func main() { nameArray := [6]string{"D", "a", "n", "i", "i", "l"} nameSlice := nameArray[:3] nameSlice[len(nameSlice) - 1] = "m" fmt.Println(nameSlice) // [D a m] fmt.Println(nameArray) // [D a m i i l] }
Мы также можем сделать так, чтобы срез занял всю длину исходного массива. Так как слайс хранит вместимость исходного массива - мы можем сделать срез снова и указать параметр cap(nameArray):
package main import "fmt" func main() { nameArray := [6]string{"D", "a", "n", "i", "i", "l"} nameSlice := nameArray[:3] nameSlice[len(nameSlice)-1] = "m" fmt.Println(nameSlice) // [D a m] // Делаем новый срез nameSlice = nameSlice[0:cap(nameSlice)] fmt.Println(nameSlice) // [D a m i i l] }
У вас может возникнуть вопрос: почему мы не срезали
cap(nameSlice) - 1, ибо мы указали в конце несуществующий индекс (на один больше, нежели существует в массиве). Все дело в том, что последний элемент при срезе не включается в срез.То есть, первый индекс идет включительно в срез, а последний - не включительно.
Копирование
Как уже можно понять, при срезе с массива или слайса мы не создаем новый слайс. Также, если мы присвоим одной переменной значение слайса другой переменной - они обе будут указывать на один массив:
package main import ( "fmt" ) func main() { nameSlice := []string{"D", "a", "n", "i", "i", "l"} secondNameSlice := nameSlice secondNameSlice[0] = "T" fmt.Println(nameSlice, secondNameSlice) // [T a n i i l] [T a n i i l] }
Мы можем избежать такого поведения с помощью копирования. Для того чтобы скопировать слайс (создать независимую копию) - нам достаточно использовать функцию copy:
package main import ( "fmt" ) func main() { nameSlice := []string{"D", "a", "n", "i", "i", "l"} secondNameSlice := make([]string, len(nameSlice), cap(nameSlice)) copy(secondNameSlice, nameSlice) secondNameSlice[0] = "T" fmt.Println(nameSlice, secondNameSlice) // [D a n i i l] [T a n i i l] }
сopy и append под капотом
Мы можем заметить два различия: при использовании функции append - мы переприсваивали значение переменной:
foo := []int {} foo = append(foo, 1)
В случае с copy мы просто передаем саму переменную (не ссылку, а именно переменную!):
foo := []int {1, 2} bar := []int {} copy(bar, foo)
Вот как работает копирование под капотом:
func copy(to []T, from []T) { for i := range from { to[i] = from[i] } }
Разработчики Go решили не добавлять часть с инициализацией нового слайса внутрь copy.
В случае с дополнением все немного иначе. Тут разработчики Go посчитали, что функция сама должна решать нужно ли инициализировать новый слайс, или можно дополнить данные в уже существующий слайс:
func append(slice []T, data ...T) []T { initialLength := len(slice) finalLength := m + len(data) if finalLength > cap(slice) { // if necessary, reallocate // allocate double what's needed, for future growth. newSlice := make([]byte, (n+1)*2) copy(newSlice, slice) slice = newSlice } slice = slice[0:finalLength] copy(slice[initialLength:finalLength], data) return slice }
Вместо заключения 🌚
Если вам понравилась данная статья - то вы всегда можете перейти в мой блог, там больше схожей информации о веб-разработке.
Если у вас остались вопросы - не стесняйтесь задавать их в комментариях. Хорошего времяпрепровождения! 💁🏻♂
