Массивы в языке Go
Язык Go предоставляет структуру данных типа массив.
Массив — это последовательность пронумерованных элементов данных фиксированной длины одного и того же уникального типа, который может быть любым примитивным типом, например целые числа, строки или пользовательские типы.
По сравнению с объявлениемnumber0, number1, ..., number99переменных, использование формы массиваnumbers[0], numbers[1] ..., numbers[99]удобнее и проще для расширения.
Элементы массива можно читать (или изменять) по индексу (позиции). Индекс начинается с 0: первый элемент имеет индекс 0, второй — индекс 1, и так далее.
Объявление массивов
Для объявления массива в языке Go необходимо указать тип элементов и количество элементов. Синтаксис имеет следующий вид:
var arrayName [size]dataTypeгде,arrayName— имя массива,size— размер массива,dataType— это тип данных элементов массива.
Ниже определяется массив balance длиной 10 и типа float32:
var balance [10]float32
Инициализация массивов
Ниже демонстрируется инициализация массива:
В следующем примере объявляется целочисленный массив с именем numbers размером 5. При объявлении каждый элемент массива инициализируется значением по умолчанию в соответствии со своим типом данных. Для целочисленных типов начальное значение равно 0.
var numbers [5]int
Вы также можете использовать список инициализации для инициализации элементов массива:
var numbers = [5]int{1, 2, 3, 4, 5}
Приведённый выше код объявляет целочисленный массив размером 5 и инициализирует его элементы значениями 1, 2, 3, 4 и 5 соответственно.
Кроме того, вы также можете использовать:=сокращённый синтаксис объявления для объявления и инициализации массива:
numbers := [5]int{1, 2, 3, 4, 5}
Приведённый выше код создаёт целочисленный массив с именем numbers, задаёт его размер равным 5 и инициализирует значения его элементов.
Примечание:В языке Go размер массива является частью его типа, поэтому массивы разных размеров несовместимы. То есть[5]intи[10]int— это разные типы.
Ниже определяется массив balance длиной 5 и типа float32, а также инициализируются элементы массива:
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Мы также можем быстро инициализировать массив при объявлении с помощью литералов:
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Если длина массива неизвестна, можно использовать...вместо длины массива; компилятор самостоятельно определит длину массива по количеству элементов:
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
или
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Если длина массива задана, мы также можем инициализировать элементы, указав индексы:
// 将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}
Инициализация массива{}Количество элементов в нем не может быть больше[]числа в.
Если не указывать[]Если размер массива не задан в числах, язык Go установит размер массива на основе количества элементов:
balance[4] = 50.0
В приведенном выше примере считывается пятый элемент. К элементам массива можно обращаться (или изменять их) по индексу (позиции). Индексы начинаются с 0: первый элемент имеет индекс 0, второй — индекс 1, и так далее.
Доступ к элементам массива
Элементы массива можно читать по индексу (позиции). Формат: имя массива, за которым следуют квадратные скобки, а значение индекса указывается внутри квадратных скобок. Например:
var salary float32 = balance[9]
В приведенном выше примере считывается значение 10-го элемента массива balance.
Ниже приведен пример полных операций с массивом (объявление, присваивание, доступ):
Пример 1
import "fmt"
func main() {
var n [10]int /* n — массив длиной 10 */
var i,j int
/* инициализировать элементы массива n */
for i = 0; i < 10; i++ {
n[i] = i + 100 /* установить элемент в i + 100 */
}
/* вывести значение каждого элемента массива */
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] = %d\n", j, n[j] )
}
}
Результат выполнения приведенного выше примера выглядит следующим образом:
Element[0] = 100 Element[1] = 101 Element[2] = 102 Element[3] = 103 Element[4] = 104 Element[5] = 105 Element[6] = 106 Element[7] = 107 Element[8] = 108 Element[9] = 109
Пример 2
import "fmt"
func main() {
var i,j,k int
// Объявить массив и сразу же инициализировать его
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* вывести элементы массива */ ...
for i = 0; i < 5; i++ {
fmt.Printf("balance[%d] = %f\n", i, balance[i] )
}
balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* вывести значение каждого элемента массива */
for j = 0; j < 5; j++ {
fmt.Printf("balance2[%d] = %f\n", j, balance2[j] )
}
// инициализировать элементы с индексами 1 и 3
balance3 := [5]float32{1:2.0,3:7.0}
for k = 0; k < 5; k++ {
fmt.Printf("balance3[%d] = %f\n", k, balance3[k] )
}
}
Результат выполнения приведенного выше примера выглядит следующим образом:
balance[0] = 1000.000000 balance[1] = 2.000000 balance[2] = 3.400000 balance[3] = 7.000000 balance[4] = 50.000000 balance2[0] = 1000.000000 balance2[1] = 2.000000 balance2[2] = 3.400000 balance2[3] = 7.000000 balance2[4] = 50.000000 balance3[0] = 0.000000 balance3[1] = 2.000000 balance3[2] = 0.000000 balance3[3] = 7.000000 balance3[4] = 0.000000
Больше контента
Массивы очень важны для языка Go. Ниже мы представим больше информации о массивах:
| content | Описание |
|---|---|
| Многомерные массивы | Язык Go поддерживает многомерные массивы. Простейший многомерный массив — это двумерный массив. |
| Передача массивов в функции | Вы можете передавать массивы как аргументы функциям |