English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Основной учебник по Golang

Контрольные инструкции в Golang

Функции & методы в Golang

Структуры в Golang

Режим резания & массивы в Golang

Строки(String) в Golang

Указатели в Golang

Интерфейсы в Golang

Конкурентоспособность в Golang

异常(Error) в Golang

Другие статьи по Golang

Массивы (Array) языка Go

Язык программирования Go имеет массивы, очень похожие на массивы других языков программирования. В программе, иногда нам нужно хранить набор данных одного и того же типа, например, список оценок студентов. Этот тип набора данных хранится в программе с помощью массивов. Массивы - это фиксированной длины последовательность, используемая для хранения элементов одного и того же типа в памяти. Из-за их фиксированной длины массивы не так популярны, как Slice (режим резания) в языке программирования Go.
В массиве разрешается хранить ноль или более элементов. Это означает, что индексирование элементов массива начинается с нуля, что означает, что индекс первого элемента равенarray [0]Индекс последнего элементаarray [len(array)-1].

Создание и доступ к массиву

В языке Go массивы создаются двумя способами:

  • Использование ключевого слова var:В языке Go массивы создаются с использованием ключевого слова var с именем, размером и типом элементов.

    Грамматика:

    Var array_name[длина]Type
или
var array_name[длина]Typle{item1, item2, item3, ...itemN}

    Важно:

    • В языке Go массивы изменяемы, поэтому вы можете использовать синтаксис array[index] для установки элемента массива на заданном индексе.

      Var array_name[index] = element[объект Объект]

    • Вы можете получить доступ к элементам массива с помощью индексного значения или с помощью цикла for.

    • В языке Go тип массива одномерный.

    • Длина массива фиксирована и не может быть изменена.

    • Вы можете хранить повторяющиеся элементы в массиве.

      • //Использование ключевого слова var для создания массива
//Использование индексного значения для доступа к элементам массива
package　main
import　"fmt"
func　main()　{
　　　　//Использование ключевого слова var для создания массива строкового типа
　　　　var myarr [3]string
　　　　//Использование индексного значения для назначения элемента
　　　　myarr[0] = "GFG"
　　　　myarr[1] = "ru.oldtoolbag.com"
　　　　myarr[2] = "w3codebox"
　　　　//Доступ к элементам массива
　　　　//Использование индексного значения
　　　　fmt.Println("элементы массива:")
　　　　fmt.Println("Элемент 1: ", myarr[0])
　　　　fmt.Println("Элемент 2: ", myarr[1])
　　　　fmt.Println("Элемент 3: ", myarr[2])
{}

      Вывод:

      элементы массива:
Элемент 1: GFG
Элемент 2: ru.oldtoolbag.com
Элемент 3: w3codebox

  • Использование сокращенного синтаксиса:В языке Go массивы также могут быть объявлены с использованием сокращенного синтаксиса. Это более гибко, чем上面的声明。

    Грамматика:

    array_name:= [длина]Тип {элемент1, элемент2, элемент3,...элементN}[объект Объект]
    //массив с краткой декларацией
//доступ к массиву с использованием цикла for
package　main
import　"fmt"
func　main()　{
　　　　//краткая декларация массива
　　　　arr　:=　[4]string{"w3codebox",　"gfg",　"w3codeboxs1231",　"ru.oldtoolbag.com"}
　　　　//доступ к элементам, использование массива с циклом for
　　　　fmt.Println("элементы массива:")
　　　　for　i　:=　0;　i　<　3;　i++　{
　　　　　　　　fmt.Println(arr[i])
　　　　{}
{}

    Вывод:

    элементы массива:
w3codebox
gfg
w3codeboxs1231

    • многомерные массивы

    Мы уже знаем, что массивы одномерные, но можно создавать многомерные массивы. Многомерные массивы — это массивы массивов одного и того же типа. В Golang вы можете создать многомерный массив следующим образом:

    Array_name[Length1][Length2]..[LengthN]Type

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

    Внимание:В многомерных массивах, если пользователь не инициализирует ячейку с помощью某个 значения, компилятор автоматически initializes её к нулю. В Golang нет концепции неинициализированного.

    package　main
import　"fmt"
func　main()　{
　　　　//создание и инициализация
　　　　//двумерный массив
　　　　//Использование краткой записи
　　　　//здесь нужно использовать запятую (,)
　　　　arr　:=　[3][3]string{{"C#",　"C",　"Python"},
　　　　　　　　{"Java",　"Scala",　"Perl"},
　　　　　　　　{"C++",　"Go",　"HTML"}}
　　　　//доступ к значению
　　　　//использование цикла for для массива
　　　　fmt.Println("элементы массива　1")
　　　　for　x　:=　0;　x　<　3;　x++　{
　　　　　　　　for　y　:=　0;　y　<　3;　y++　{
　　　　　　　　　　　　fmt.Println(arr[x][y])
　　　　　　　　{}
　　　　{}
　　　　//создание двумерного массива
　　　　//использование ключевого слова var для массива
　　　　//и инициализация
　　　　//использование массива с индексированием
　　　　var　arr1　[2][2]int
　　　　arr1[0][0]　=　100
　　　　arr1[0][1]　=　200
　　　　arr1[1][0]　=　300
　　　　arr1[1][1]　=　400
　　　　//доступ к значению массива
　　　　fmt.Println("элементы массива　2")
　　　　for　p　:=　0;　p　<　2;　p++　{
　　　　　　　　for　q　:=　0;　q　<　2;　q++　{
　　　　　　　　　　　　fmt.Println(arr1[p][q])
　　　　　　　　{}
　　　　{}
{}

    Вывод:

    элемент 1 массива
C#
C
Python
Java
Scala
Perl
C++
Go
HTML
элемент 2 массива
100
200
300
400

    Внимание к массивам

  • в массиве, если массив не был явно инициализирован, тоэти массивывпо умолчанию 0.

    package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
//Создание массива типа int, содержащего два элемента
//Здесь мы не инициализируем массив, поэтому значения массива равны нулю
var myarr[2]int　
fmt.Println("Элементы массива:", myarr)　
　　
{}

    Вывод:

    элементы массива: [0 0]

  • в массиве, вы можетеиспользоватьметод len()получитьмассивдлинакак показано ниже:

    package　main
import　"fmt"
func　main()　{
　　　　//Создание массива
　　　　//Использование краткой записи
　　　　arr1　:=　[3]int{9,　7,　6}
　　　　arr2 := [...]int{9, 7, 6, 4, 5, 3, 2, 4}
　　　　arr3 := [...]int{9, 3, 5}
　　　　//Использование метода len() для вычисления размера массива
　　　　fmt.Println("Длина массива 1:", len(arr1))
　　　　fmt.Println("Длина массива 2:", len(arr2))
　　　　fmt.Println("Длина массива 3:", len(arr3))
{}

    Вывод:

    длина массива 1: 3
длина массива 2: 8
длина массива 3: 3

  • в массивеесли многоточие "..."длина видна в положении lengths, тогда длина массива определяется инициализированными элементами. Вот пример:

    //Использование многоточия в массиве
package　main
import　"fmt"
func　main()　{
　　　　//Создание массива с фиксированным размером
　　　　//На основе количества элементов
　　　　//Использование многоточия
　　　　myarray := [...]string{"GFG", "gfg", "w3codeboxs", "ru.oldtoolbag.com", "w3codebox"}
　　　　fmt.Println("Элементы массива: ", myarray)
　　　　//Длина массива
　　　　//Определено...
　　　　//Использование метода len()
　　　　fmt.Println("Длина массива:", len(myarray))
{}

    Вывод:

    элементы массива: [GFG gfg w3codeboxs ru.oldtoolbag.com w3codebox]
длина массива: 5

  • в массивепозволяет вамв array в диапазоне элементов。如下例所示：

    //Как итерировать массив
package　main
import　"fmt"
func　main()　{
　　　　//Создать массив, размер
　　　　//Использовать точку с запятой для
　　　　myarray := [...]int{29, 79, 49, 39, 20, 49, 48, 49}
　　　　//Использование цикла for для итерации массива
　　　　for　x　:=　0;　x　<　len(myarray);　x++　{
　　　　　　　　fmt.Printf("%d\n",　myarray[x])
　　　　{}
{}

    Вывод:

    29
79
49
39
20
49
48
49

  • В языке Go:Тип значения массива не является типом ссылки。Таким образом, когда массив назначается новому переменной, изменения, сделанные в новой переменной, не влияют на исходный массив. Например:

    package　main
import　"fmt"
func　main()　{
　　　　//Создать массив, размер
　　　　//Использовать точку с запятой для
　　　　my_array　:=　[...]int{100,　200,　300,　400,　500}
　　　　fmt.Println("Оригинальный массив (до изменения):",　my_array)
　　　　//Создать новую переменную
　　　　//И использовать my_array для инициализации
　　　　new_array　:=　my_array
　　　　fmt.Println("Новый массив (до изменения):",　new_array)
　　　　//Изменить значение по индексу 0 на 500
　　　　new_array[0]　=　500
　　　　fmt.Println("Новый массив (изменен):",　new_array)
　　　　fmt.Println("Оригинальный массив (изменен):",　my_array)
{}

    Вывод:

    Оригинальный массив (до изменения):　[100　200　300　400　500]
Новый массив (до изменения):　[100　200　300　400　500]
Новый массив (изменен):　[500　200　300　400　500]
Оригинальный массив (изменен):　[100　200　300　400　500]

  • В массиве, если тип элементов массива сравним, то и тип массива сравним. Таким образом:Мы можем использовать оператор == для прямого сравнения двух массивов。如下例所示：

    //Как сравнивать два массива
package　main
import　"fmt"
func　main()　{
　　　　arr1　:=　[3]int{9,　7,　6}
　　　　arr2　:=　[...]int{9,　7,　6}
　　　　arr3　:=　[3]int{9,　5,　3}
　　　　//Использование оператора == для сравнения массивов
　　　　fmt.Println(arr1　==　arr2)
　　　　fmt.Println(arr2　==　arr3)
　　　　fmt.Println(arr1　==　arr3)
　　　　//　Это даст ошибку, потому что
　　　　//　arr1 и arr4 несовместимы по типу
　　　　/*
　　　　　　　arr4:=　[4]int{9,7,6}
　　　　　　　fmt.Println(arr1==arr4)
　　　　*/
{}

    Вывод:

    true
false
false
Копирование массива в GoФункция в качестве поля структуры в Go