Array do Linguagem Go

O linguagem de programação Go é muito semelhante a outras linguagens de programação. Em um programa, às vezes precisamos armazenar um conjunto de dados do mesmo tipo, como uma lista de notas de alunos. Este tipo de conjunto é armazenado em um array no programa. O array é uma sequência de comprimento fixo, usada para armazenar elementos do mesmo tipo em memória. Devido ao seu comprimento fixo, os arrays não são tão populares quanto o Slice (fatia) no Go.
No array, é permitido armazenar zero ou mais elementos. Ao usar o operador de indexação [] e a posição zero, isso significa que o índice do primeiro elemento éarray [0]，o índice do último elemento éarray [len(array)]-1].

]]

Criar e acessar arrays

• Em Go, arrays são criados de duas maneiras diferentes:Usar palavra-chave var:

  Sintaxe:

  Em Go, arrays são criados usando a palavra-chave var com nome, tamanho e tipo específico de elementos.
  或
  Var　array_name[length]Type1,　item2,　item3var　array_name[length]Typle{item

  ,　...itemN}
  

• Importante:

  Em Go, arrays são mutáveis, portanto você pode usar a sintaxe array[index] no lado esquerdo da atribuição para definir o elemento do array no índice especificado.

• Var　array_name[index]　=　element[object　Object]

• Você pode acessar os elementos do array usando valor de índice ou usando loop for.

• O tipo de array em Go é unidimensional.

• O comprimento do array é fixo e não pode ser alterado.

示例

//Você pode armazenar elementos repetidos em um array.
//Usar palavra-chave var para criar um array
package main
import "fmt"
func main() {
　　　　//Usar valor de índice para acessar o array
　　　　Usar palavra-chave var para criar um array de tipo string3var　myarr　[
　　　　//]string
　　　　Atribuir elementos usando índice
　　　　codebox.com"1myarr[0]　=　"GFG"3]　=　"www.w
　　　　codebox.com"2myarr[3]　=　"w
　　　　//codebox"
　　　　//Acessar elementos do array
　　　　fmt.Println("Elementos do array:")
　　　　:　",　myarr[0])　1Usar valor de índice
　　　　:　",　myarr[0])　2fmt.Println("Elemento1:　",　myarr[
　　　　:　",　myarr[0])　3fmt.Println("Elemento2:　",　myarr[
{}

Saída:

Elementos do array:
:　　www.w　1:　　)
:　　www.w　2:　　GFG3codebox.com
:　　www.w　3Elemento3codebox

• :　　wEm Go, arrays também podem ser declarados usando declaração abreviada. Ela é mais flexível que a declaração acima.

  Sintaxe:

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

  示例

  //Usar array com declaração abreviada
  //Acessar array usando loop for
  package main
  import "fmt"
  func main() {
  　　　　//Declaração abreviada de array
  　　　　4]string{"w3codebox",　"gfg",　"w3codeboxs1231",　"pt.oldtoolbag.com"}
  　　　　//Elemento acessado, usando array no loop for
  　　　　fmt.Println("Elementos do array:")
  　　　　for　i　:=　0;　i　<　3;　i++　{
  　　　　　　　　fmt.Println(arr[i])
  　　　　{}
  {}

  Saída:

  Elementos do array:
  w3codebox
  gfg
  w3codeboxs1231

Arrays multidimensionais

Já sabemos que um array é unidimensional, mas é permitido criar arrays multidimensionais. Arrays multidimensionais são arrays de arrays do mesmo tipo. Em Go, você pode usar a seguinte sintaxe para criar arrays multidimensionais:

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

您可以使用Var关键字或Uso de declaração abreviada来创建多维数组，如下例所示。

注意：在多维数组中，如果用户未使用某个值初始化单元格，则编译器将自动将其初始化为零。Golang中没有未初始化的概念。

示例

package main
import "fmt"
func main() {
　　　　//创建和初始化
　　　　//二维数组
　　　　//Uso de declaração abreviada
　　　　//
　　　　3][3
　　　　　　　　]string{{"C#
　　　　　　　　{"Java", "Scala", "Perl"},++{"C
　　　　//", "Go", "HTML"}}
　　　　//Uso de loop for para acessar o valor
　　　　fmt.Println("Elementos do array:",　1")
　　　　for x := 0; x <　3; x++　{
　　　　　　　　for y := 0; y <　3; y++　{
　　　　　　　　　　　　fmt.Println(arr[x][y])
　　　　　　　　{}
　　　　{}
　　　　//Criação de array bidimensional
　　　　//Uso do keyword var para array
　　　　//e inicializa um
　　　　//Uso de array vetorial por meio de índices
　　　　var arr1　[2][2]int
　　　　arr1[0][0] =　100
　　　　arr1[0][1] =　200
　　　　arr1[1][0] =　300
　　　　arr1[1][1] =　400
　　　　//Acessar o valor do array
　　　　fmt.Println("Elementos do array:",　2")
　　　　for p := 0; p <　2; p++　{
　　　　　　　　for q := 0; q <　2; q++　{
　　　　　　　　　　　　fmt.Println(arr1[p][q])
　　　　　　　　{}
　　　　{}
{}

Saída:

Elementos do array　1
C#
C
Python
Java
Scala
Perl
C++
Go
HTML
Elementos do array　2
100
200
300
400

Notas sobre arrays

• No array, se o array não for inicializado explicitamente,Este arraydoO valor padrão é 0.

  示例

  package main　
  　　
  import "fmt"
  　　
  func main() {　
  　　
  //Cria um array do tipo int, armazenando dois elementos
  //Aqui, não inicializamos o array, então o valor do array é zero
  var myarr[2]int　
  fmt.Println("Elementos do array:", myarr)　
  　　
  {}

  Saída:

  Elementos do array: [0 0]

• No array, você podeUsoMétodo len()ObterArraySeu comprimentoComo mostrado a seguir:

  示例

  package main
  import "fmt"
  func main() {
  　　　　//Criação de array
  　　　　//Uso de declaração abreviada
  　　　　arr1　:=[3int{9,　7,　6{}
  　　　　arr2　:=[...]int{9,　7,　6,　4,　5,　3,　2,　4{}
  　　　　arr3　:=[3int{9,　3,　5{}
  　　　　//　Calcula o tamanho do array usando o método len
  　　　　fmt.Println("Array1Seu comprimento é: "1))
  　　　　fmt.Println("Array2Seu comprimento é: "2))
  　　　　fmt.Println("Array3Seu comprimento é: "3))
  {}

  Saída:

  Array1Seu comprimento é:　3
  Array2Seu comprimento é:　8
  Array3Seu comprimento é:　3

• 在数组中，Se o ponto de interrogação " ..."Visível na posição de comprimento, o comprimento do array é determinado pelos elementos inicializados. Vamos ver um exemplo:

  示例

  //Uso do ponto de interrogação no array
  package main
  import "fmt"
  func main() {
  　　　　//Cria um array de tamanho determinado
  　　　　//De acordo com o número de elementos
  　　　　//Uso de pontos de interrogação
  　　　　myarray := [...]string{"GFG", "gfg", "w3"codeboxs", "pt.oldtoolbag.com", "w"3codebox"}
  　　　　fmt.Println("数组元素:　", myarray)
  　　　　//数组的长度
  　　　　//由...决定
  　　　　//使用len()方法
  　　　　fmt.Println("数组的长度为:", len(myarray))
  {}

  Saída:

  数组元素:　　[GFG　gfg　w3codeboxs　pt.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])
  　　　　{}
  {}

  Saída:

  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)
  {}

  Saída:

  原始数组(改变前):　[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　:=[3int{9,　7,　6{}
  　　　　arr2　:=[...]int{9,　7,　6{}
  　　　　arr3　:=[3int{9,　5,　3{}
  　　　　//使用==运算符比较数组
  　　　　fmt.Println(arr1　==arr2)
  　　　　fmt.Println(arr2　==arr3)
  　　　　fmt.Println(arr1　==arr3)
  　　　　//这将给出和错误，因为
  　　　　//　arr1和arr4的类型不匹配
  　　　　/*
  　　　　　　　arr4:=[4int{9,7,6{}
  　　　　　　　fmt.Println(arr1==arr4)
  　　　　*/
  {}

  Saída:

  true
  false
  false