Introdução
No desenvolvimento moderno de software, frequentemente precisamos armazenar uma grande quantidade de dados.
Com base no que aprendemos, podemos facilmente definir inúmeras variáveis.
No entanto, se precisarmos usar variáveis para registrar os nomes dos funcionários de uma empresa, com dados em uma escala de centenas ou milhares, teremos que defini-las uma a uma?
Claro que não. Para dados com atributos semelhantes, podemos usar arrays (vetores) para defini-los e armazená-los.
Podemos pensar nos arrays como uma coleção de variáveis que se juntam como um trem. E quando queremos encontrar uma variável específica, só precisamos saber o número do trem (nome do array) e o número do assento (índice). Então, podemos encontrar e manipular a variável sem saber seu nome.
Nesta seção, aprenderemos sobre várias operações básicas de arrays.
Pontos de Conhecimento:
- Definição de array
- Inicialização de array
- Travessia de array (Array traversal)
- Características dos elementos do array
Definição de Array
Como definimos um array?
Vamos relembrar a situação quando aprendemos sobre variáveis. Como definimos uma variável int?
var a int
Ou seja:
var nome_da_variável tipo_da_variável
Da mesma forma, podemos definir um array int assim:
var a [10]int
Ou seja:
var nome_da_variável [número_de_elementos]tipo_da_variável
Dessa forma, definimos um array int básico chamado a com uma capacidade de 10.
Lista de Inicialização
Depois de entender como definir um array, vamos aprender como inicializar um array.
Ao inicializar um array, podemos usar uma lista de inicialização para definir os valores iniciais dos elementos do array.
Crie um arquivo array.go no diretório ~/project:
cd ~/project
touch array.go
Escreva o seguinte código em array.go:
package main
import "fmt"
func main() {
// Inicializado automaticamente com o valor zero do tipo de elemento
var simpleArray [3]int
// Inicializa com valores iniciais especificados e usa o valor zero para preencher os elementos ausentes
var numArray = [3]int{1, 2}
// Inicializa com valores iniciais especificados
var cityArray = [2]string{"London", "Chengdu"}
fmt.Println(simpleArray) // [0 0 0]
fmt.Println(numArray) // [1 2 0]
fmt.Println(cityArray) // [London Chengdu]
}
Execute o código:
go run ~/project/array.go
Saída esperada:
[0 0 0]
[1 2 0]
[London Chengdu]
O código acima demonstra três maneiras de especificar valores iniciais usando uma lista de inicialização:
- Sem passar uma lista: Inicializa com o valor zero do tipo de elemento
- Passando uma lista parcial: Inicializa os elementos especificados com os valores especificados e inicializa os elementos restantes com o valor zero
- Passando uma lista completa: Inicializa com os valores especificados
Observe que se o comprimento da lista passada for maior que o número de elementos no array, o código não compilará.
Inicialização com Comprimento Inferido
Ao inicializar um array usando uma lista de inicialização, você deve garantir que o número de valores iniciais fornecidos seja menor ou igual ao número de elementos.
Em geral, você pode confiar no compilador para inferir o comprimento do array com base nos valores iniciais.
Modifique o arquivo array.go da seguinte forma:
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
}
Execute o código:
go run ~/project/array.go
Saída esperada:
[0 0 0]
[1 2]
The type of numArray is: [2]int
[London Chengdu]
The type of cityArray is: [2]string
Inicialização com Índices Específicos
Às vezes, podemos querer atribuir valores iniciais específicos a certas posições em um array, independentemente de usarmos uma lista de inicialização ou inferirmos o comprimento.
Modifique o arquivo array.go da seguinte forma:
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
}
Execute o código:
go run ~/project/array.go
Saída esperada:
[0 1 0 5]
The type of array a is: [4]int
O código acima especifica os valores iniciais dos elementos com os índices 1 e 3 como 1 e 5, respectivamente. Ele também usa o método de inicialização com inferência de comprimento, que você deve aprender.
Nota: Em computação, o índice começa em 0.
Travessia de Array
Às vezes, precisamos acessar cada elemento de um array e realizar operações neles um por um.
Aqui, apresentamos duas maneiras de percorrer arrays:
Escreva o seguinte código em 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])
}
}
Execute o código:
go run ~/project/array.go
Saída esperada:
Traversing the array using range
0 123
1 321
2 456
3 777
Traversing the array using indices
123
321
456
777
Ambos os métodos acima podem ser usados para percorrer todo o array.
Acessando Elementos de Array
Para acessar um elemento específico em um array, que é essencialmente uma variável, usamos o índice.
Semelhante à maioria das linguagens de programação, o índice de um array começa em 0, e o índice do último elemento é len-1.
Se um índice maior que este limite for usado no código, resultará em um erro de "out-of-bounds" (fora dos limites).
Para acessar o elemento i-ésimo do array a, você pode usar a seguinte notação:
a[i]
Ou seja:
nome_do_array[índice_do_elemento]
Tipo de Valor de Arrays
Arrays são tipos de valor; atribuir um array ou passar um array como parâmetro irá copiar todo o array. Em outras palavras, você modificará os valores da cópia, não do array original.
Escreva o seguinte código em 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]
}
Execute o código:
go run ~/project/array.go
A saída será:
[10 20 30]
A partir do código acima, pode-se ver que quando o array a é passado para a função modifyArray, apenas uma cópia do seu array original é realmente passada.
Mudar o valor do array x na função não afeta o array original a.
Resumo
Neste laboratório, aprendemos:
- Como definir um array
- Três métodos de inicialização de array
- Características de arrays e como acessar seus elementos
Arrays não são comumente usados no desenvolvimento real, mas são a base para aprender estruturas de dados comumente usadas em Go.
Espero que todos os Gophers pratiquem diligentemente e aprendam a aplicar o que aprenderam.
