Мало выучиться танцевать: нужно ещё не забывать это делать (Авессалом Подводный).

12 практических примеров массивов на языке программирования GoLang Go

Главное меню » Язык программирования Go (Golang) » 12 практических примеров массивов на языке программирования GoLang Go

15.05.2019

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

Если вы разработчик или системный администратор, который является новичком в Go, важно понимать следующие ключевые различия в том, как обрабатывается массив в Go по сравнению с другим языком:

Вы не можете изменить размер массива, как только он объявлен.
Размер массива должен быть указан при объявлении массива. Чтобы преодолеть это ограничение, вы будете использовать срезы по большей части в GoLang. Но все же важно понимать, как работает массив, так как срезы работают поверх массива.
Когда вы присваиваете массив другому массиву, по сути вы копируете все элементы из одного в другой.
Вышесказанное важно понимать, так как при передаче массива в качестве параметра функции функция действительно получит копию массива и будет работать с ней. Это не указатель, который мы передаем. Это копия всего массива.

Эта статья объясняет следующие основы обработки массивов в Go, с полным рабочим примером вместе с выводом, который представлен в конце этой статьи.

Объявить переменную массива с определенным размером
Присвоить значение определенному элементу в массиве
Доступ к определенному элементу в массиве
Показать все или определенные элементы из массива
Инициализировать и присвоить значения массиву одновременно
Инициализируйте массив, используя многострочный синтаксис
Определить длину массива — сколько элементов существует?
Значение элемента массива по умолчанию
Проход по элементам массива с использованием For и Range
Переборка массива и получение только значения (Ignore Array Index)
Инициализируйте элементы Int Array с последовательностью чисел
Определить и инициализировать многомерные массивы
Полный рабочий код GoLang со всеми примерами массивов

В следующей статье мы рассмотрим срезы в GoLang с примерами.

1. Объявите переменную массива с определенным размером

var distros [5]string

var ids [5]int

В приведенном выше:

var — ключевое слово
distros, ids — имя переменной
5 — это длина массива. Вы должны указать длину массива при объявлении массива. Как только вы укажете размер массива, вы не сможете изменить его размер.
string, int — Тип массива. В этом примере distros — это строковый массив размером 5, а id — массив int с размером 5.

2. Присвойте значение определенному элементу в массиве

distros[0] = "Ubuntu"
distros[1] = "CentOS"
distros[2] = "RedHat"
distros[3] = "Debian"
distros[4] = "OpenBSD"

ids[0] = 1
ids[1] = 2
ids[2] = 3
ids[3] = 4
ids[4] = 5

Заметки:

Как вы видите выше, индексная ссылка, которую вы будете использовать для 1-го элемента массива, равна 0 (не 1).
distros[0] ссылается на 1-й элемент в массиве distros
ids[4] ссылается на 5-й элемент массива ids (который также является последним элементом массива ids в этом примере)

Если вы попытаетесь присвоить значение в массиве, размер которого превышает размер массива, вы получите сообщение об ошибке.

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

distros[5] = "Solaris"

Сообщение об ошибке:

./array.go:11:10: invalid array index 5 (out of bounds for 5-element array)

3. Доступ к определенному элементу в массиве

mydistro := distros[1]

myid := ids[3]

Заметки:

Мы присваиваем значение 1-го элемента массива distros переменной mydistro
Присвоение 3-го элемента массива ids переменной myid
: = объявляет и инициализирует переменную одновременно
Также для: = вам не нужно указывать тип переменной mydistro или myid
: = know будет определять тип переменной в зависимости от значения, которое будет присвоено.
Таким образом, mydistro станет строковой переменной, а myid автоматически станет переменной int

4. Показать все или определенные элементы из массива

fmt.Println(distros)
fmt.Println(ids)

fmt.Println("distros[2] = ", distros[2])
fmt.Println("ids[2] = ", ids[2])

Чтобы отобразить определенный элемент массива или все элементы в массиве, используйте fmt.Println, как показано выше.

Убедитесь, что пакет «fmt» импортирован сверху, используя команду import

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

[1 2 3 4 5]
[Ubuntu CentOS RedHat Debian OpenBSD]

5. Инициализировать и присвоить значения массиву одновременно

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

Следующее будет одновременно объявлять и инициализировать массив с заданными значениями.

os := [3]string{"Linux", "Mac", "Windows"}

fibonacci := [6]int{1, 1, 2, 3, 5, 8}

6. Инициализируйте массив, используя многострочный синтаксис

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

temperature := [3]float64{
     98.5,
     65.5,
     83.2,
}

Но имейте в виду, что в многострочном синтаксисе вы должны указывать запятую после последнего элемента. Как вы видите выше, после 83,2 запятая

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

names := [3]string{
     "AndreyEx",
     "Jason",
     "Alica",
     // "Rita",
}

7. Определите длину массива — сколько элементов существует?

Функция len возвращает общее количество элементов в данном массиве. Вы можете присвоить значение функции len и другой переменной.

arraySize := len(distros)

fmt.Println("Количество дистрибутивов = ", len(distros))
fmt.Println("Количество идентификаторов = ", len(ids))

Вывод:

Количество дистрибутивов = 5
Количество идентификаторов = 5

8. Значение по умолчанию элемента массива

В целочисленном массиве, если вы не присвоите значение массиву и попытаетесь его распечатать, вы увидите 0 в качестве значений для элементов, которым вы не присвоили значение. По умолчанию целочисленные массивы инициализируются со значениями 0.

В следующем примере мы определили массив empIds с 5 элементами, но присваивали значения только первым трем элементам.

empIds := [5]int{101, 102, 103}

fmt.Println("empIds = ",empIds)

Как видно из следующего вывода, последним двум элементам автоматически присваивается значение 0.

empIds =  [101 102 103 0 0]

Для строковых массивов, если вы не назначите значение, оно просто будет иметь пустое значение. Мы просто присвоили два элемента и оставили три последних элемента пустыми.

empNames := [5]string{"AndreyEx","Jason"}

fmt.Println("empNames = ",empNames)

Выход:

empNames =  [AndreyEx Jason   ]

9. Цикл элементов массива с использованием For и Range

Используя команды for и range, вы можете перебрать все элементы в данном массиве

for index, value := range distros {
  fmt.Println(index, " = ", value)
}

В приведенном выше:

range distros — range — команда go, которая возвращает номер индекса и значение элемента массива.
Вы можете назначить вывод команды range циклу for и пройти через все элементы
для i, значение — Здесь укажите две переменные для команды for. Имя переменной может быть любым. Это просто произошло для ясности, мы используем индекс и значение в качестве имени переменной здесь.

10. Переберите массив и получите только значения (Ignore Array Index)

Если вы просто хотите использовать элемент массива, а не индекс, то указание переменной индекса, как показано ниже, выдаст сообщение об ошибке.

В этом примере мы просто хотим просмотреть все значения в массиве ids и суммировать их. Таким образом, мы действительно не заботимся о переменной индекса здесь.

total := 0
for index, value := range ids {
  total = total + value
}
fmt.Println("всего всех идентификаторов = ", total)

Выше будет выбрасывать следующую ошибку:

./array.go:54:7: index declared and not used

В этом случае просто замените переменную индекса в цикле for символом подчеркивания _, как показано ниже.

for _, value := range ids {
  total = total + value
}

Символ подчеркивания _ указывает на языке Go, что вы берете значение определенной переменной (в данном случае индекс) и просто игнорируете его.

11. Инициализируйте элементы массива Int с помощью числовой последовательности.

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

var sequence [10]int
counter := 10
for index, _ := range sequence {
  sequence[index] = counter
  counter = counter + 5
}
fmt.Println()
fmt.Println("sequence = ",sequence)

Выше мы используем for и range для обхода элементов массива и присваивания значения. Так как мы заботимся только об индексе, а не о текущем значении элемента массива, мы используем символ подчеркивания _ для значения в цикле for, как показано выше.

В этом примере последовательность начинается с 10 с шагом 5. Таким образом, первое значение массива будет 10 и с последующим увеличением до 5.

12. Определите и инициализируйте многомерные массивы

Go не имеет понятия многомерного массива. Но вы можете создавать массивы, которые можно рассматривать и использовать как многомерный массив, как показано ниже.

count := 1
var multi [4][2]int
 for i := 0; i < 4; i++ {
     for j := 0; j < 2; j++ {
         multi[i][j] = count
         count++
     }
 }
 fmt.Println("Массив 4 x 2 : ", multi)

В приведенном выше примере мы создаем массив init размером 4 x 2 (4 строки и 2 столбца) и присваиваем значения отдельным элементам с шагом 1, начиная со значения 1.

Код Go со всеми примерами массивов

Для справки, следующий рабочий код go содержит все приведенные выше примеры в одной программе.

package main

import "fmt"

func array() {

  // Строковый массив
  fmt.Println("1. Строковый массив : ")

  var distros [5]string
  distros[0] = "Ubuntu"
  distros[1] = "CentOS"
  distros[2] = "RedHat"
  distros[3] = "Debian"
  distros[4] = "OpenBSD"

  mydistro := distros[1]
  fmt.Println("mydistro = ", mydistro)
  fmt.Println("distros[2] = ", distros[2])
  fmt.Println("distros = ", distros)
  fmt.Println("Количество дистрибутивов = ", len(distros))

  // Целочисленный массив (Numbers)
  fmt.Println()
  fmt.Println("2. Целочисленный массив : ")

  var ids [5]int
  ids[0] = 1
  ids[1] = 2
  ids[2] = 3
  ids[3] = 4
  ids[4] = 5

  myid := ids[3]
  fmt.Println("myid = ", myid)
  fmt.Println("ids[2] = ", ids[2])
  fmt.Println("ids = ", ids)
  fmt.Println("Количество идентификаторов = ", len(ids))

  // Одновременно объявить и инициализировать массив
  fmt.Println()
  fmt.Println("3. Одновременно объявить и инициализировать массив : ")

  os := [3]string{"Linux", "Mac", "Windows"}
  fmt.Println("os = ",os)
  fmt.Println("Количество ОС = ", len(os))

  fibonacci := [6]int{1, 1, 2, 3, 5, 8}
  fmt.Println("fibonacci = ",fibonacci)

  // Синтаксис инициализации многострочного массива
  fmt.Println()
  fmt.Println("4. Синтаксис инициализации многострочного массива : ")

  temperature := [3]float64{
       98.5,
       65.5,
       83.2,
  }
  fmt.Println("temperature = ", temperature)

  names := [3]string{
       "AndreyEx",
       "Jason",
       "Alica",
       // "Rita",
  }
  fmt.Println("names = ", names)

  // Значения по умолчанию в массиве
  fmt.Println()
  fmt.Println("5. Значения по умолчанию в массиве : ")

  empIds := [5]int{101, 102, 103}
  fmt.Println("empIds = ",empIds)

  empNames := [5]string{"AndreyEx","Jason"}
  fmt.Println("empNames = ",empNames)

  // Цикл через массив, использующий For и Range
  fmt.Println()
  fmt.Println("6. Цикл через массив, использующий For и Range : ")

  for index, value := range distros {
    fmt.Println(index, " = ", value)
  }

  // Цикл через массив, использующий For и Range (Игнорировать Индекс)
  fmt.Println()
  fmt.Println("7. Цикл через массив, использующий For и Range (Игнорировать Индекс) : ")

  total := 0
  for _, value := range ids {
    total = total + value
  }
  fmt.Println("всего всех идентификаторов = ", total)

  // Инициализировать целочисленный массив последовательностью
  fmt.Println()
  fmt.Println("8. Инициализировать целочисленный массив последовательностью : ")
  var sequence [10]int
  counter := 10
  for index, _ := range sequence {
    sequence[index] = counter
    counter = counter + 5
  }
  fmt.Println("sequence = ",sequence)

  // Многомерный массив
  fmt.Println()
  fmt.Println("9. Многомерный массив : ")

  count := 1
  var multi [4][2]int
   for i := 0; i < 4; i++ {
       for j := 0; j < 2; j++ {
           multi[i][j] = count
           count++
       }
   }
   fmt.Println("Массив 4 x 2 : ", multi)

}

Полный вывод для приведенного выше примера кода:

1. Строковый массив :
mydistro =  CentOS
distros[2] =  RedHat
distros =  [Ubuntu CentOS RedHat Debian OpenBSD]
Количество дистрибутивов =  5

2. Целочисленный массив :
myid =  4
ids[2] =  3
ids =  [1 2 3 4 5]
Количество идентификаторов =  5

3. Одновременно объявить и инициализировать массив :
os =  [Linux Mac Windows]
Количество ОС =  3
fibonacci =  [1 1 2 3 5 8]

4. Синтаксис инициализации многострочного массива :
temperature =  [98.5 65.5 83.2]
names =  [AndreyEx Jason Alica]

5. Значения по умолчанию в массиве :
empIds =  [101 102 103 0 0]
empNames =  [AndreyEx Jason   ]

6. Цикл через массив, использующий For и Range :
0  =  Ubuntu
1  =  CentOS
2  =  RedHat
3  =  Debian
4  =  OpenBSD

7. Цикл через массив, использующий For и Range (Игнорировать Индекс) :
всего всех идентификаторов =  15

8. Инициализировать целочисленный массив последовательностьюИнициализировать целочисленный массив последовательностьюИнициализировать целочисленный массив последовательностью :
sequence =  [10 15 20 25 30 35 40 45 50 55]

9. Многомерный массив :
Массив 4 x 2 :  [[1 2] [3 4] [5 6] [7 8]]

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.