Эти сложные map & slice в GO

В этой статье я хочу погрузиться в то, как работают некоторые структуры (далее ниже) в ГО. Хотя я и работаю с ГО уже 3й год, все равно есть вещи, в которые интересно погружаться. Хочу отметить, что я не буду погружаться прям сильно в реализацию того как устроены map и slice, скорее на столько, что бы понимать как они ведут себя и почему. Такое часто могут спрашивать на собеседованиях или это поможет писать более качественный и безопасный код.

Итак на сколько мы знаем (я надеюсь, что и вы читаете статью уже со знанием ГО) в ГО можно разделить типы переменных глобально на 2 группы

• Value types — это простые типы такие как int, float, array, struct, string,…

• Reference type — это сcылочные типы, такие как chan, map, slice

Для value type мы можем использовать ключевое слово new или литералы для создания

foo := "Some string" bar := new(int) // zero value is 0 + heap memory allocation

Для reference type мы должны использовать ключевое слово make для создания или литерал, иначе вы получите panic при попытки что-то сделать с nil

myMap := make(map[string]string) // myMap := map[string]string{} - literal for create a map myMap["foo"] = "foo" // all good here  var myBMap map[string]string myBMap["bar"] = "bar" // panic, don't do this!

Одна из интересных механик в ГО это как ведут себя переменные, которые мы прокидываем в функции. Для обычных типов (value type). Если мы передадим по значению и сделаем какие то действия с ней, то оригинальная переменная не поменяет свое значение, потому, что создается копия объекта в стеке функции (область памяти, которая очищается при завершения функции). Однако, когда мы передаем по ссылке, тогда любые манипуляции будут отражаться и на оригинальной переменной.

type User struct {   Name string }  func makeChangesWithVal(user User) {   user.Name = "Peter" }  func main() {   user := User{ Name: "Ivan" }   makeChangesWithVal(user)    fmt.Println(user.Name) // "Ivan" }

type User struct {   Name string }  func makeChangesWithVal(user *User) {   user.Name = "Peter" }  func main() {   user := User{ Name: "Ivan" }   makeChangesWithVal(user)    fmt.Println(user.Name) // "Peter" }

Однако ссылочные переменные (reference type) ведут себя по другому. Потому, что для их при создании выделяется память и создается дескриптор (специальная структура, которая содержит метаданные и ссылку на выделенную область памяти для мастер данных).

func DoSomeWithMap(myMap map[string]string) {   myMap["foo"] = "foo value" }  func main() {   fooMap := make(map[string]string)    DoSomeWithMap(fooMap)   fooKey, exists := fooMap["foo"]    fmt.Println(exists, fooKey) // true, "foo value" }

Ого! даже когда мы передаем «по значению» и добавляем новый ключ к map, мы видим изменения оригинальной переменной. Давайте посмотрим на еще один интересный пример с передачей «по значению»

func DoSomeWithMap(myMap map[string]string) {   myMap = make(map[string]string)   myMap["foo"] = "foo value" }  func main() {   fooMap := make(map[string]string)    DoSomeWithMap(fooMap)   fooKey, exists := fooMap["foo"] // fooKey is empty string here    fmt.Println(exists, fooKey) // false }

Интересно мы сделали ремейк (make) той же самой переменной в функции, однако она не поменялась. Но почему так ?

Как я писал выше когда мы создаем экземпляр класса ссылочных структур таких как map, slice, chan, данные кладутся в область памяти и создается дескриптор с ссылкой на эту область, и когда мы передаем эти переменные в функцию (по значению), то мы передаем дескриптор, при этом в функции создается новый дескриптор, но ссылка на область памяти остается той же(ссылается на туже область памяти) и когда мы меняем что-то то меняется именно данные по ссылке, при этом после завершении, дескриптор очищается(удаляется из памяти) но ссылка остается.

Но что происходит когда мы делаем ремейк и почему оригинальная переменная не меняется в этом случае ? Итак, у нас есть новый дескриптор, когда переменная попадает в функцию с ссылкой на оригинальную область в памяти, но когда мы делаем новый make мы создаем новую переменную, данные которой кладутся в новую область памяти и новый дескриптор с ссылкой на нее. После завершения функции дескриптор очищается вместе с этой новой ссылкой, тогда как оригинальная ссылка и данные остаются не тронутые.

Для slice работает тоже со своей логикой

func DoSomeWithSlice(mySlice []string) {   mySlice[0] = "foo value" }  func main() {   fooSlice := make([]string, 3)   DoSomeWithSlice(fooSlice)    fmt.Println(fooSlice, cap(fooSlice), len(fooSlice)) // [foo value  ] 3 3 }

func DoSomeWithSlice(mySlice []string) {   mySlice = append(mySlice, "foo value") }  func main() {   fooSlice := make([]string, 3)   DoSomeWithSlice(fooSlice)    fmt.Println(fooSlice, cap(fooSlice), len(fooSlice)) // [  ] 3 3 }

Во втором случае нужно точно знать как работает append, что оставлю вам в качестве самостоятельного исследования.

Жду ваших комментариев и критики