Массивы в Go

Массивы в Go

#GO


Массивы на языке программирования Golang или Go очень похожи на другие языки программирования. В программе иногда нам нужно хранить набор данных одного типа, например, список оценок учеников. Такой тип коллекции хранится в программе с использованием массива. Массив — это последовательность фиксированной длины, которая используется для хранения однородных элементов в памяти. Из-за их фиксированной длины массив не так популярен, как Slice in Go.

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

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

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

  1. Использование ключевого слова var : в языке Go массив создается с использованием ключевого слова var определенного типа с именем, размером и элементами.Синтаксис:
Var array_name[length]Type
or
var array_name[length]Typle{item1, item2, item3, ...itemN}
  1. Важные моменты:
В языке Go массивы изменчивы, так что вы можете использовать синтаксис array [index] слева от присваивания, чтобы установить элементы массива с заданным индексом.Var array_name[index] = element
  1. Вы можете получить доступ к элементам массива, используя значение индекса или цикл for.
  2. В языке Go тип массива одномерный.
  3. Длина массива фиксирована и неизменна.
  4. Вам разрешено хранить повторяющиеся элементы в массиве.

Пример:


// Перейти к программе, чтобы проиллюстрировать, как

// создаем массив с помощью ключевого слова var

// и доступ к элементам

// массив с использованием значения индекса

package main

  

import "fmt"

func main() {

  

// Создание массива строкового типа

// Используем ключевое слово var

var myarr[3]string

  

// Элементы назначаются с использованием индекса

myarr[0] = "GFG"

myarr[1] = "GeeksforGeeks"

myarr[2] = "Geek"

  

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

// Использование значения индекса

fmt.Println("Elements of Array:")

fmt.Println("Element 1: ", myarr[0])

fmt.Println("Element 2: ", myarr[1])

fmt.Println("Element 3: ", myarr[2])

}

Выход:

Elements of Array:
Element 1:  GFG
Element 2:  GeeksforGeeks
Element 3:  Geek

2. Использование стенографического объявления. В языке Go массивы также могут быть объявлены с помощью стенографического объявления. Это более гибко, чем приведенная выше декларация.Синтаксис:

array_name:= [length]Type{item1, item2, item3,...itemN}

Пример:


// Перейти к программе, чтобы проиллюстрировать, как создать

// массив с кратким объявлением

// и доступ к элементам

// использование массива для цикла

package main

  

import "fmt"

  

func main() {

  

// Сокращенное объявление массива

arr:= [4]string{"geek", "gfg", "Geeks1231", "GeeksforGeeks"}

  

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

// Использование массива для цикла

fmt.Println("Elements of the array:")

  

for i:= 0; i < 3; i++{

fmt.Println(arr[i])

}

  

}

Выход:

Elements of the array:
geek
gfg
Geeks1231

Многомерный массив

Как мы уже знаем, массивы являются одномерными, но вам разрешено создавать многомерный массив. Многомерные массивы — это массивы массивов одного типа . В языке Go вы можете создать многомерный массив, используя следующий синтаксис:

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

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

Примечание. В многомерном массиве, если ячейка не инициализируется пользователем каким-либо значением, компилятор автоматически инициализирует ее нулевым значением. На Голанге нет неинициализированной концепции.

Пример:


// Перейти к программе, чтобы проиллюстрировать

// концепция многомерного массива

package main

  

import "fmt"

  

func main() {

  

// Создание и инициализация

// 2-мерный массив

// Использование стенографического объявления

// Здесь нужна (,) запятая

arr:= [3][3]string{{"C#", "C", "Python"}, 

                   {"Java", "Scala", "Perl"},

                    {"C++", "Go", "HTML"},}

  

// Доступ к значениям

// массив Использование для цикла

fmt.Println("Elements of Array 1")

for x:= 0; x < 3; x++{

for y:= 0; y < 3; y++{

fmt.Println(arr[x][y])

}

}

  

// Создание 2-мерного

// массив с использованием ключевого слова var

// и инициализация мульти

// -мерный массив с использованием индекса

var arr1 [2][2] int

arr1[0][0] = 100

arr1[0][1] = 200

arr1[1][0] = 300

arr1[1][1] = 400

  

// Доступ к значениям массива

fmt.Println("Elements of array 2")

for p:= 0; p<2; p++{

for q:= 0; q<2; q++{

fmt.Println(arr1[p][q])

  

}

}

}

Выход:

Elements of Array 1
C#
C
Python
Java
Scala
Perl
C++
Go
HTML
Elements of array 2
100
200
300
400

Важные замечания о массиве

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


// Перейти к программе для иллюстрации массива

package main

  

import "fmt"

  

func main() {

  

// Создание массива типа int

// который хранит, два элемента

// Здесь мы не инициализируем

// массив, так что значение массива

// ноль

var myarr[2]int 

fmt.Println("Elements of the Array :", myarr)

  

}

Выход:

Elements of the Array : [0 0]

2. В массиве вы можете найти длину массива с помощью метода len (), как показано ниже:

Пример:


// Перейти к программе, чтобы проиллюстрировать, как найти

// длина массива

package main

  

import "fmt"

  

func main() {

  

// Создание массива

// Использование стенографического объявления

arr1:= [3]int{9,7,6}

arr2:= [...]int{9,7,6,4,5,3,2,4}

arr3:= [3]int{9,3,5}

  

// Находим длину

// массив с использованием метода len

fmt.Println("Length of the array 1 is:", len(arr1))

fmt.Println("Length of the array 2 is:", len(arr2))

fmt.Println("Length of the array 3 is:", len(arr3))

}

Выход:

Length of the array 1 is: 3
Length of the array 2 is: 8
Length of the array 3 is: 3

3. В массиве, если многоточие ''… '' становится видимым в месте длины, тогда длина массива определяется инициализированными элементами. Как показано в примере ниже:

Пример:


// Перейти к программе, чтобы проиллюстрировать

// понятие эллипса в массиве

package main

  

import "fmt"

  

func main() {

      

// Создание массива, размер которого определяется

// по количеству элементов в нем

// Используем многоточие

myarray:= [...]string{"GFG", "gfg", "geeks",

                    "GeeksforGeeks", "GEEK"}

  

fmt.Println("Elements of the array: ", myarray)

  

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

// определяется по

// Использование метода len ()

fmt.Println("Length of the array is:", len(myarray))

}

Выход:

Elements of the array:  [GFG gfg geeks GeeksforGeeks GEEK]
Length of the array is: 5

4. В массиве вам разрешено выполнять итерации по диапазону элементов массива . Как показано в примере ниже:

Пример:


// Перейти к программе для иллюстрации

// как перебрать массив

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

5. В языке Go массив имеет тип значения, а не ссылочный тип . Поэтому, когда массиву присваивается новая переменная, изменения, внесенные в новую переменную, не влияют на исходный массив. Как показано в примере ниже:

Пример:


// Перейти к программе для иллюстрации массива типов значений

package main

  

import "fmt"

  

func main() {

      

// Создание массива, размер которого

// представлен многоточием

my_array:= [...]int{100, 200, 300, 400, 500}

fmt.Println("Original array(Before):", my_array)

  

// Создание новой переменной

// и инициализируем с помощью my_array

new_array := my_array

  

fmt.Println("New array(before):", new_array)

  

// Изменить значение с индексом 0 на 500

new_array[0] = 500

  

fmt.Println("New array(After):", new_array)

  

fmt.Println("Original array(After):", my_array)

}

Выход:

Original array(Before): [100 200 300 400 500]
New array(before): [100 200 300 400 500]
New array(After): [500 200 300 400 500]
Original array(After): [100 200 300 400 500]

6. В массиве, если тип элемента массива сопоставим, тогда тип массива также сопоставим. Таким образом, мы можем напрямую сравнивать два массива, используя оператор == . Как показано в примере ниже:

Пример:


// Перейти к программе для иллюстрации

// как сравнить два массива

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


Report content on this page

Report Page

Please submit your DMCA takedown request to dmca@telegram.org