Введение
В современной разработке программного обеспечения мы часто должны хранить огромное количество данных.
Основываясь на том, что мы уже знаем, мы можем легко определить множество переменных.
Однако, если нам нужно использовать переменные для записи имен сотрудников компании, а количество данных составляет сотни или тысячи, должны ли мы определять их по одному?
Конечно, нет. Для данных с похожими атрибутами мы можем использовать массивы для их определения и хранения.
Массивы можно представить как набор переменных, объединенных, как вагоны поезда. И когда нам нужно найти конкретную переменную, нам нужно только знать номер поезда (имя массива) и номер места (индекс). Затем мы можем найти и манипулировать переменной, не зная ее имени.
В этом разделе мы узнаем о различных базовых операциях с массивами.
Точки знания:
- Определение массива
- Инициализация массива
- Обход массива
- Особенности элементов массива
Определение массива
Как определить массив?
Давайте вспомним, как мы определяли переменные. Как мы определяли переменную типа int?
var a int
То есть:
var variable_name variable_type
Аналогично, мы можем определить массив типа int следующим образом:
var a [10]int
То есть:
var variable_name [number_of_elements]variable_type
Таким образом, мы определили базовый массив типа int с именем a и емкостью 10 элементов.
Список инициализации
После того, как мы разобрались, как определить массив, давайте научимся инициализировать его.
При инициализации массива мы можем использовать список инициализации для установки начальных значений элементов массива.
Создайте файл array.go в директории ~/project:
cd ~/project
touch array.go
Напишите следующий код в файле array.go:
package main
import "fmt"
func main() {
// Automatically initialized to the zero value of the element type
var simpleArray [3]int
// Initialize with specified initial values, and use the zero value to fill in the missing elements
var numArray = [3]int{1, 2}
// Initialize with specified initial values
var cityArray = [2]string{"London", "Chengdu"}
fmt.Println(simpleArray) // [0 0 0]
fmt.Println(numArray) // [1 2 0]
fmt.Println(cityArray) // [London Chengdu]
}
Запустите код:
go run ~/project/array.go
Ожидаемый вывод:
[0 0 0]
[1 2 0]
[London Chengdu]
В приведенном выше коде показаны три способа указания начальных значений с использованием списка инициализации:
- Без передачи списка: инициализация нулевым значением типа элемента
- Передача частичного списка: инициализация указанных элементов заданными значениями, а оставшиеся элементы инициализируются нулевым значением
- Передача полного списка: инициализация заданными значениями
Обратите внимание, что если длина переданного списка больше количества элементов в массиве, код не будет скомпилирован.
Инициализация с неявной длиной
При инициализации массива с использованием списка инициализации необходимо убедиться, что количество предоставленных начальных значений меньше или равно количеству элементов массива.
В общем случае можно полагаться на компилятор для вывода длины массива на основе начальных значений.
Измените файл array.go следующим образом:
package main
import "fmt"
func main() {
var simpleArray [3]int
var numArray = [...]int{1, 2}
var cityArray = [...]string{"London", "Chengdu"}
fmt.Println(simpleArray) // [0 0 0]
fmt.Println(numArray) // [1 2]
fmt.Printf("The type of numArray is: %T\n", numArray) // The type of numArray is: [2]int
fmt.Println(cityArray) // [London Chengdu]
fmt.Printf("The type of cityArray is: %T\n", cityArray) // The type of cityArray is: [2]string
}
Запустите код:
go run ~/project/array.go
Ожидаемый вывод:
[0 0 0]
[1 2]
The type of numArray is: [2]int
[London Chengdu]
The type of cityArray is: [2]string
Инициализация с указанными индексами
Иногда мы можем захотеть присвоить определенные начальные значения определенным позициям в массиве, независимо от того, используем ли мы список инициализации или выводим длину массива.
Измените файл array.go следующим образом:
package main
import "fmt"
func main() {
a := [...]int{1: 1, 3: 5}
fmt.Println(a) // [0 1 0 5]
fmt.Printf("The type of array a is: %T\n", a) // The type of array a is: [4]int
}
Запустите код:
go run ~/project/array.go
Ожидаемый вывод:
[0 1 0 5]
The type of array a is: [4]int
В приведенном выше коде указаны начальные значения элементов с индексами 1 и 3, равные 1 и 5 соответственно. Также используется метод инициализации с выводом длины, который вы должны изучить.
Примечание: В компьютерных науках индексация начинается с 0.
Обход массива
Иногда нам нужно получить доступ к каждому элементу массива и выполнить с ними операции по очереди.
Вот два способа обхода массивов:
Напишите следующий код в файле array.go:
package main
import "fmt"
func main() {
a := [...]int{123, 321, 456, 777}
// Method 1: range
fmt.Println("Traversing the array using range")
for index, value := range a {
fmt.Println(index, " ", value)
}
// Method 2: using indices
fmt.Println("\nTraversing the array using indices")
for i := 0; i < len(a); i++ {
fmt.Println(a[i])
}
}
Запустите код:
go run ~/project/array.go
Ожидаемый вывод:
Traversing the array using range
0 123
1 321
2 456
3 777
Traversing the array using indices
123
321
456
777
Оба вышеперечисленных метода можно использовать для обхода всего массива.
Доступ к элементам массива
Для доступа к определенному элементу массива, который по сути является переменной, мы используем индекс.
Как и в большинстве языков программирования, индексация массива начинается с 0, а индекс последнего элемента равен len - 1.
Если в коде использовать индекс, превышающий этот предел, это приведет к ошибке выхода за границы массива.
Для доступа к i-му элементу массива a можно использовать следующую запись:
a[i]
То есть:
array_name[index_of_element]
Тип значений массивов
Массивы являются типами значений; при присвоении массива или передаче массива в качестве параметра копируется весь массив. Другими словами, вы будете изменять значения копии, а не исходного массива.
Напишите следующий код в файле array.go:
package main
import "fmt"
func modifyArray(x [3]int) {
x[0] = 100
}
func main() {
a := [3]int{10, 20, 30}
modifyArray(a) // The variable `x` in `modifyArray` is a copy of `a`
fmt.Println(a) // [10 20 30]
}
Запустите код:
go run ~/project/array.go
Вывод будет следующим:
[10 20 30]
Из приведенного выше кода видно, что когда массив a передается в функцию modifyArray, на самом деле передается только копия его исходного массива.
Изменение значения массива x в функции не влияет на исходный массив a.
Резюме
В этом практическом занятии (лабораторной работе) мы узнали:
- Как определить массив
- Три способа инициализации массива
- Характеристики массивов и способ доступа к их элементам
Массивы не часто используются в реальной разработке, но они являются основой для изучения часто используемых структур данных в Go.
Надеемся, что все разработчики на Go (Gophers) будут усердно практиковаться и научатся применять полученные знания.
