Arrays na linguagem de programação Golang ou Go é muito semelhante a outras linguagens de programação. No programa, às vezes precisamos armazenar uma coleção de dados do mesmo tipo, como uma lista de notas do aluno. Esse tipo de coleção é armazenado em um programa usando um Array. Uma array é uma sequência de comprimento fixo usada para armazenar elementos homogêneos na memória. Devido à sua array de comprimento fixo, não são muito populares como a linguagem Slice in Go.
Em uma array, você tem permissão para armazenar zero ou mais de zero elementos nela. Os elementos da array são indexados usando o operador de índice [] com sua posição baseada em zero, significa que o índice do primeiro elemento é array [0] e o índice do último elemento é array [len (array) -1] .

arrays-in-golang

Criação e acesso a um Array

Na linguagem Go, os arrays são criados de duas maneiras diferentes:

  1. Usando a palavra-chave var : na linguagem Go, um array é criado usando a palavra-chave var de um tipo específico com nome, tamanho e elementos.

    Sintaxe:

    Var array_name [comprimento] Tipo
ou
var array_name [comprimento] Digite {item1, item2, item3, ... itemN}

    Pontos importantes:



    • Na linguagem Go, os arrays são mutáveis, de modo que você pode usar a sintaxe array [índice] no lado esquerdo da atribuição para definir os elementos do array no índice fornecido.
      Var array_name [índice] = elemento

    • Você pode acessar os elementos da array usando o valor do índice ou usando o loop for.
    • Na linguagem Go, o tipo de array é unidimensional.
    • O comprimento da array é fixo e imutável.
    • Você tem permissão para armazenar elementos duplicados em uma array.

      Exemplo:




      // Go program to illustrate how to 
      // create an array using the var keyword 
      // and accessing the elements of the
      // array using their index value
      package main
        
      import "fmt"
        
      func main() {
        
      // Creating an array of string type 
      // Using var keyword
      var myarr[3]string
        
      // Elements are assigned using index
      myarr[0] = "GFG"
      myarr[1] = "GeeksforGeeks"
      myarr[2] = "Geek"
        
      // Accessing the elements of the array 
      // Using index value
      fmt.Println("Elements of Array:")
      fmt.Println("Element 1: ", myarr[0])
      fmt.Println("Element 2: ", myarr[1])
      fmt.Println("Element 3: ", myarr[2])
      }
      Saída:
      Elementos da array:
Elemento 1: GFG
Elemento 2: GeeksforGeeks
Elemento 3: Geek

  2. Usando a declaração abreviada: Na linguagem Go, os arrays também podem declarar usando a declaração abreviada. É mais flexível do que a declaração acima.
    Sintaxe:
    array_name: = [comprimento] Digite {item1, item2, item3, ... itemN}
    Exemplo:



    // Go program to illustrate how to create
    // an array using shorthand declaration 
    // and accessing the elements of the 
    // array using for loop
    package main
      
    import "fmt"
      
    func main() {
      
    // Shorthand declaration of array
    arr:= [4]string{"geek", "gfg", "Geeks1231", "GeeksforGeeks"}
      
    // Accessing the elements of 
    // the array Using for loop
    fmt.Println("Elements of the array:")
      
    for i:= 0; i < 3; i++{
    fmt.Println(arr[i])
    }
      
    }
    Saída:
    Elementos da array:
nerd
gfg
Geeks1231



Array Multi-Dimensional


Como já sabemos, os arrays são 1-D, mas você pode criar um array multidimensional. Arrayes multidimensionais são as arrayes de arrayes do mesmo tipo . Na linguagem Go, você pode criar uma array multidimensional usando a seguinte sintaxe: 




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


Você pode criar uma array multidimensional usando a palavra - chave Var ou usando a declaração abreviada conforme mostrado no exemplo abaixo.


Nota: Em uma array multidimensional, se uma célula não for inicializada com algum valor pelo usuário, ela será inicializada com zero pelo compilador automaticamente. Não existe um conceito não inicializado no Golang.


Exemplo:


// Go program to illustrate the
// concept of multi-dimension array
package main
  
import "fmt"
  
func main() {
  
// Creating and initializing 
// 2-dimensional array 
// Using shorthand declaration
// Here the (,) Comma is necessary
arr:= [3][3]string{{"C#", "C", "Python"}, 
                   {"Java", "Scala", "Perl"},
                    {"C++", "Go", "HTML"},}
  
// Accessing the values of the 
// array Using for loop
fmt.Println("Elements of Array 1")
for x:= 0; x < 3; x++{
for y:= 0; y < 3; y++{
fmt.Println(arr[x][y])
}
}
  
// Creating a 2-dimensional
// array using var keyword
// and initializing a multi
// -dimensional array using index
var arr1 [2][2] int
arr1[0][0] = 100
arr1[0][1] = 200
arr1[1][0] = 300
arr1[1][1] = 400
  
// Accessing the values of the array
fmt.Println("Elements of array 2")
for p:= 0; p<2; p++{
for q:= 0; q<2; q++{
fmt.Println(arr1[p][q])
  
}
}
}


Saída:


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



Observações importantes sobre a array


  1. Em uma array, se uma array não foi inicializada explicitamente, o valor padrão desta array é 0 .
    Exemplo:



    // Go program to illustrate an array
    package main
      
    import "fmt"
      
    func main() {
      
    // Creating an array of int type
    // which stores, two elements
    // Here, we do not initialize the 
    // array so the value of the array
    // is zero
    var myarr[2]int 
    fmt.Println("Elements of the Array :", myarr)
      
    }
    Saída:
    Elementos do Array: [0 0]
  2. Em uma array, você pode encontrar o comprimento da array usando o método len() conforme mostrado abaixo:
    Exemplo:



    // Go program to illustrate how to find
    // the length of the array
    package main
      
    import "fmt"
      
    func main() {
      
    // Creating array
    // Using shorthand declaration    
    arr1:= [3]int{9,7,6}
    arr2:= [...]int{9,7,6,4,5,3,2,4}
    arr3:= [3]int{9,3,5}
      
    // Finding the length of the 
    // array using len method
    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))
    }
    Saída:
    O comprimento da array 1 é: 3
O comprimento da array 2 é: 8
O comprimento da array 3 é: 3

  3. Em uma array, se as reticências ''… '' se tornarem visíveis no lugar do comprimento, então o comprimento da array é determinado pelos elementos inicializados. Conforme mostrado no exemplo abaixo:
    Exemplo:



    // Go program to illustrate the
    // concept of ellipsis in an array
    package main
      
    import "fmt"
      
    func main() {
          
    // Creating an array whose size is determined 
    // by the number of elements present in it
    // Using ellipsis
    myarray:= [...]string{"GFG", "gfg", "geeks",
                        "GeeksforGeeks", "GEEK"}
      
    fmt.Println("Elements of the array: ", myarray)
      
    // Length of the array
    // is determine by 
    // Using len() method
    fmt.Println("Length of the array is:", len(myarray))
    }
    Saída:
    Elementos da array: [GFG gfg geeks GeeksforGeeks GEEK]
O comprimento da array é: 5

  4. Em uma array, você pode iterar ao longo do intervalo dos elementos da array . Conforme mostrado no exemplo abaixo:
    Exemplo:



    // Go program to illustrate 
    // how to iterate the array
    package main
      
    import "fmt"
      
    func main() {
          
    // Creating an array whose size
    // is represented by the ellipsis
    myarray:= [...]int{29, 79, 49, 39,
                       20, 49, 48, 49}
      
    // Iterate array using for loop
    for x:=0; x < len(myarray); x++{
    fmt.Printf("%d\n", myarray[x])
    }
    }
    Saída:
    29
79
49
39
20
49
48
49

  5. Na linguagem Go, um array é do tipo valor e não do tipo referência . Portanto, quando a array é atribuída a uma nova variável, as alterações feitas na nova variável não afetam a array original. Conforme mostrado no exemplo abaixo:
    Exemplo:



    // Go program to illustrate value type array
    package main
      
    import "fmt"
      
    func main() {
          
    // Creating an array whose size 
    // is represented by the ellipsis
    my_array:= [...]int{100, 200, 300, 400, 500}
    fmt.Println("Original array(Before):", my_array)
      
    // Creating a new variable 
    // and initialize with my_array
    new_array := my_array
      
    fmt.Println("New array(before):", new_array)
      
    // Change the value at index 0 to 500
    new_array[0] = 500
      
    fmt.Println("New array(After):", new_array)
      
    fmt.Println("Original array(After):", my_array)
    }
    Saída:
    Array original (antes): [100 200 300 400 500]
Nova array (antes): [100 200 300 400 500]
Nova array (Depois): [500 200 300 400 500]
Array original (depois): [100 200 300 400 500]

  6. Em uma array, se o tipo de elemento da array for comparável, o tipo de array também será comparável. Portanto , podemos comparar diretamente duas arrayes usando o operador == . Conforme mostrado no exemplo abaixo:
    Exemplo:



    // Go program to illustrate 
    // how to compare two arrays
    package main
      
    import "fmt"
      
    func main() {
      
    // Arrays    
    arr1:= [3]int{9,7,6}
    arr2:= [...]int{9,7,6}
    arr3:= [3]int{9,5,3}
      
    // Comparing arrays using == operator
    fmt.Println(arr1==arr2)
    fmt.Println(arr2==arr3)
    fmt.Println(arr1==arr3)
      
    // This will give and error because the 
    // type of arr1 and arr4 is a mismatch 
    /*
    arr4:= [4]int{9,7,6}
    fmt.Println(arr1==arr4)
    */
    }
    Saída:
    verdade
falso
falso