Массив (array) — это структура данных, которая представляет собой фиксированную последовательность элементов одного типа. Все элементы массива размещены в памяти последовательно и имеют одинаковый тип. Используются для хранения коллекций данных, где количество элементов заранее известно и фиксировано.

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

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

Объявление и инициализация массивов

Массивы объявляются с указанием типа элементов и фиксированного размера:

```go
var arr [5]int
```

Это объявление создает массив из пяти целых чисел, инициализированных нулями.

Инициализация массива

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

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

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

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

Доступ к элементам массива

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

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

Длина массива

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

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

Копирование массива

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

```go
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]
```

Передача массива в функции

Копируется весь массив:

```go
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]
```

Сравнение массивов

С помощью оператора `==`, если они имеют одинаковую длину и тип элементов:

```go
arr1 := [3]int{1, 2, 3}
arr2 := [3]int{1, 2, 3}
arr3 := [3]int{4, 5, 6}

fmt.Println(arr1 == arr2) // true
fmt.Println(arr1 == arr3) // false
```

Пример:

```go
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
}
```

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

July 1, 2024, easyoffer