🤔 Как устроен слайс в Go ?

Слайсы представляют собой мощный и гибкий инструмент для работы с последовательностями элементов. Основаны на массивах, но они предоставляют более удобный и динамичный способ работы с данными.

🚩Структура

🟠Указатель на базовый массив
Указатель на первый элемент массива, на который ссылается слайс.
🟠Длина (length)
Количество элементов, доступных в слайсе.
🟠Емкость (capacity)
Максимальное количество элементов, которое может содержать слайс без перераспределения памяти.

🚩Внутреннее устройство

Можно представить в виде структуры

type slice struct {
    ptr *ElementType // Указатель на базовый массив
    len int          // Длина
    cap int          // Емкость
}

🟠Слайс из массива
Можно создать из массива, указав диапазон элементов:

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    slice := arr[1:4] // Слайс содержит элементы с индексами 1, 2, 3
    fmt.Println(slice) // [2 3 4]
}

🟠Слайс с использованием функции make
Позволяет создать слайс определенной длины и емкости:

package main

import "fmt"

func main() {
    slice := make([]int, 3, 5) // Слайс длиной 3 и емкостью 5
    fmt.Println(slice)         // [0 0 0]
}

🟠Доступ к элементам слайса
Осуществляется так же, как и к элементам массива:

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3, 4, 5}
    fmt.Println(slice[0]) // 1
    slice[1] = 10
    fmt.Println(slice)    // [1 10 3 4 5]
}

🚩Основные операции с ними

🟠Добавление элементов
Для этого используется функция append

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3}
    slice = append(slice, 4, 5) // Добавляем элементы 4 и 5 в конец слайса
    fmt.Println(slice)          // [1 2 3 4 5]
}

🟠Извлечение подмножества слайса (slicing)
Можно создавать новые слайсы на основе существующих

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3, 4, 5}
    subSlice := slice[1:4] // Слайс содержит элементы с индексами 1, 2, 3
    fmt.Println(subSlice)  // [2 3 4]
}

🟠Копирование слайсов
Для этого используется функция copy

package main

import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    copy(dst, src)
    fmt.Println(dst) // [1 2 3]
}

🚩Динамическое изменение длины и емкости

Могут автоматически изменять свою емкость при добавлении новых элементов с помощью append. Когда емкость текущего массива недостаточна для добавления новых элементов, создается новый массив с большей емкостью, в который копируются существующие элементы.

package main

import "fmt"

func main() {
    slice := make([]int, 3, 5)
    fmt.Println("Before append:", slice, "Len:", len(slice), "Cap:", cap(slice))

    slice = append(slice, 1, 2, 3)
    fmt.Println("After append:", slice, "Len:", len(slice), "Cap:", cap(slice))

    slice = append(slice, 4)
    fmt.Println("After another append:", slice, "Len:", len(slice), "Cap:", cap(slice))
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие бывают типы изоляции транзакций?

1. Read Uncommitted – транзакция читает несохраненные изменения других транзакций (грязное чтение).
2. Read Committed – транзакция видит только сохраненные изменения других транзакций.
3. Repeatable Read – транзакция видит одинаковые данные при повторных запросах, но возможны фантомные чтения.
4. Serializable – полный контроль над данными, транзакции выполняются последовательно, но снижается производительность.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как устроен массив в Go?

Массивы представляют собой фиксированную последовательность элементов одного типа. Являются основополагающей структурой данных, на базе которой строятся более сложные структуры, такие как слайсы. Рассмотрим, как устроены массивы, их особенности, а также сравнение с другими структурами данных.

🚩Основные характеристики

🟠Фиксированный размер
Размер массива задается при его объявлении и не может изменяться во время выполнения программы.
🟠Тип элементов
Все элементы массива имеют один и тот же тип.
🟠Непосредственное хранение данных
В отличие от слайсов, массивы хранят свои элементы в непрерывном блоке памяти.

🟠Объявление массива
С указанием типа элементов и фиксированного размера. Это объявление создает массив из пяти целых чисел, инициализированных нулями.

var arr [5]int

🟠Инициализация массива
Массивы могут быть инициализированы при объявлении

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

Можно также инициализировать массив частично, оставив остальные элементы равными нулям:

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

🟠Доступ к элементам
Осуществляется с использованием индексов, начиная с 0

fmt.Println(arr[0]) // 1
arr[1] = 10
fmt.Println(arr[1]) // 10

🟠Длина массива
Фиксирована и задается при его объявлении. Ее можно получить с помощью функции len

fmt.Println(len(arr)) // 5

🟠Копирование массива
При присваивании одного массива другому копируются все элементы:

arr1 := [5]int{1, 2, 3, 4, 5}
arr2 := arr1
arr2[0] = 10
fmt.Println(arr1) // [1 2 3 4 5]
fmt.Println(arr2) // [10 2 3 4 5]

🟠Передача массива в функции
При этом копируется весь массив:

func modifyArray(a [5]int) {
    a[0] = 10
}

arr := [5]int{1, 2, 3, 4, 5}
modifyArray(arr)
fmt.Println(arr) // [1 2 3 4 5]

🚩Сравнение

🟠Размер
Массивы имеют фиксированный размер, тогда как слайсы динамичны.

🟠Производительность
Массивы могут быть более производительными для небольших коллекций данных из-за отсутствия накладных расходов на управление динамическими данными.

🟠Гибкость: Слайсы более гибки благодаря динамическому изменению размера и доступным методам.

Использование массивов

package main

import (
    "fmt"
)

func main() {
    // Объявление и инициализация массива
    arr := [5]int{1, 2, 3, 4, 5}

    // Доступ к элементам
    fmt.Println("First element:", arr[0]) // First element: 1

    // Изменение элементов
    arr[1] = 10
    fmt.Println("Modified array:", arr) // Modified array: [1 10 3 4 5]

    // Длина массива
    fmt.Println("Length of array:", len(arr)) // Length of array: 5

    // Копирование массива
    arr2 := arr
    arr2[0] = 20
    fmt.Println("Original array:", arr) // Original array: [1 10 3 4 5]
    fmt.Println("Copied array:", arr2)  // Copied array: [20 10 3 4 5]

    // Передача массива в функцию
    modifyArray(arr)
    fmt.Println("Array after modifyArray call:", arr) // Array after modifyArray call: [1 10 3 4 5]
}

func modifyArray(a [5]int) {
    a[0] = 10
}

Ставь 👍 и забирай 📚 Базу знаний