хорошо, давайте погрузимся в одну из самых универсальных и основных функций Go - ломтики. Если вы приезжаете с другого языка, вы можете подумать о ломтиках, похожих на массивы. И, да, у них есть некоторое сходство, но ломтики приносят гораздо больше силы, гибкости и магии, специфичной для GO! ?

] Что такое ломтик в любом случае? ?

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

Итак, кусочек GO на самом деле является «окном» над основным массивом. Вы можете изменить размер этого окна, выращивая или сократив его - и оно так же гладко, как нарезать кусок торта. ?

создание среза?
Создание среза довольно просто:
]

// Using a literal
numbers := []int{1, 2, 3, 4, 5}

// Using the make function
sliceOfStrings := make([]string, 5) // a slice of 5 strings, each 

инициализирован в пустую строку
] С Make вы говорите, чтобы создать кусок определенной длины, но подкрепленный массивом, который он управляет вам. Таким образом, вам не нужно беспокоиться о деталях распределения памяти. ?

] Длина и емкость?

Два важных концепция в срезах - это длина и емкость. Длина - это количество элементов, которые в настоящее время находятся в среза, в то время как емкость - это общее количество элементов, которые он может удерживать до того, как ему необходимо изменить размер.
]

numbers := []int{1, 2, 3}
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // 3 (same as length here)

Когда вы начнете добавлять элементы, Go удваивает емкость, когда она заполняется, поэтому вам не нужно беспокоиться о том, чтобы попасть в потолок.
]

numbers = append(numbers, 4)
fmt.Println(len(numbers)) // 4
fmt.Println(cap(numbers)) // probably 6 now, depending on Go’s growth 

шаблон
Добавление к ломтикам: встроенная магия Go? ✨
] Добавить элементы в срез так же просто, как и Pie с функцией приложения GO. Вы можете добавить один или несколько элементов одновременно, и Go будет обрабатывать все изменения в изменении размера и памяти.

numbers := []int{1, 2, 3}
numbers = append(numbers, 4, 5, 6) // Adding multiple elements at once
fmt.Println(numbers) // [1 2 3 4 5 6]

Эта функция автоматического размера делает ломтики очень удобными, особенно если вы не знаете, насколько большой ваш список получит.

] Нарежьте кусочек ??

нарезка GO - это то, где все становится действительно веселым. Вы можете создать «подсадку» существующего среза, не копируя элементы.
]

numbers := []int{10, 20, 30, 40, 50}
subSlice := numbers[1:4] // Just takes a "slice" of the original slice
fmt.Println(subSlice) // [20 30 40]

в числах [1: 4], первый индекс (1) является инклюзивным, а последний индекс (4) является исключительным. В конечном итоге вы получаете элементы в позициях 1, 2 и 3, но не 4.

Этот подлис по-прежнему разделяет один и тот же базовый массив с исходным ломтиком, поэтому изменения в одном повлияют на другое:
]

subSlice[0] = 25
fmt.Println(numbers) // [10 25 30 40 50]
fmt.Println(subSlice) // [25 30 40]

, чтобы избежать каких -либо непреднамеренных изменений, вы можете использовать копию для создания независимой версии Slice:

newSlice := make([]int, len(subSlice))
copy(newSlice, subSlice)

] Изменение емкости с добавлением?

Если вам нужен ломтик, который больше, чем его текущая емкость, добавит автоматически создаст новый, больший массив в фоновом режиме и копирует все. Это невероятно эффективно и огромная часть того, что делает ломтики потрясающими. Когда Append создает новый массив, он выделяет удваивание предыдущей емкости - давая вам место для роста!

] Нарезка и эффективность памяти?

Вот немного секрет: хотя нарезка очень мощно, это иногда может привести к утечкам памяти, если вы не осторожны. Поскольку срезы относятся к тому же базовому массиву, массив может оставаться в памяти, даже если вы используете только небольшую его часть.

Например:

bigSlice := make([]int, 1_000_000) // A big slice with a lot of elements
smallSlice := bigSlice[:10]        // A tiny slice from it

// Now `smallSlice` only uses 10 elements, but the underlying array with
// 1,000,000 elements is still in memory! ?

В подобных случаях лучше использовать копию для создания действительно независимого среза, который содержит только необходимые данные, освобождая оставшуюся часть памяти.
]

miniSlice := make([]int, len(smallSlice))
copy(miniSlice, smallSlice) // Now `miniSlice` is completely separate!

] Многомерные срезы ??

нужно больше, чем одно измерение? Вы также можете создавать многомерные ломтики! Это может быть удобно для таких вещей, как сетки или таблицы. Просто объявите кусочек ломтиков:
]

matrix := [][]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
}
fmt.Println(matrix) // [[1 2 3] [4 5 6] [7 8 9]]

каждый «ряд» является ломтиком само по себе, так что вы можете вырастить их независимо, если это необходимо.

matrix[0] = append(matrix[0], 10)
fmt.Println(matrix) // [[1 2 3 10] [4 5 6] [7 8 9]]

] NIL SLICE?

Nil Slice - это просто ломтик, который еще не был инициализирован. Он имеет нулевую длину и емкость, но все еще может использоваться с такими функциями, как добавление без паники.
]

var nilSlice []int // Declared, but not initialized
fmt.Println(len(nilSlice)) // 0
fmt.Println(cap(nilSlice)) // 0

Когда вы добавляете к нулевым ломтике, перейдите просто инициализируйте его для вас автоматически. Это аккуратный трюк, чтобы поднять рукав.

подводные камни и лучшие практики?
] Следите за общей памятью: помните, кусочки делятся памятью с исходным массивом. Это отлично подходит для производительности, но будьте осторожны, когда нарезаете части большого массива, чтобы не держать ненужные данные в памяти.

Остерегайтесь изменения размера: когда вы добавляете, GO может потребоваться создать новый базовый массив, если текущая емкость будет заполнена. Это может быть более эффективным, чем выполнение многих небольших изменений, но имейте в виду накладные расходы, если вы имеете дело с большими наборами данных.

избегайте преждевременной оптимизации: GO обрабатывает много распределения памяти и автоматически изменение размера с помощью ломтиков. Часто попытка микроуправления эти детали могут в конечном итоге сделать ваш код беспорядочным и менее эффективным. Доверие Go Механика среза, чтобы делать правильные вещи в большинстве случаев.