Introdução
Na seção anterior, aprendemos sobre o uso básico de arrays.
Que tipos de elementos podem estar em um array?
Em Go, os elementos em um array podem ser de qualquer tipo primitivo, como inteiros, strings ou tipos personalizados.
O que acontece se os elementos em um array forem arrays?
Então, temos um array multidimensional:
Como mostrado na figura acima, a caixa roxa é nosso array original.
Cada elemento no array da caixa roxa é um novo array (a caixa vermelha).
Conceitos Chave:
- Definição de um array bidimensional
- Inicialização de um array bidimensional
- Percorrendo um array bidimensional
- Uso de arrays multidimensionais
Definição de um Array Bidimensional
Definição Geral
Você se lembra de como definimos um array regular?
var variableName [elementCount]variableType
Então, como definimos um array bidimensional usando este método mais ingênuo?
var variableName [elementCount][elementCount]variableType
A única diferença é que adicionamos outro [elementCount] antes do [elementCount] original para formar o formato [elementCount][elementCount].
Por exemplo, se quisermos definir um array bidimensional chamado a com uma capacidade de 10*10 do tipo int, podemos usar a seguinte sintaxe:
var a [10][10]int
Definição Curta
Assim como a declaração de variável curta, podemos usar um método de definição curta para declarar arrays, inclusive arrays multidimensionais.
Podemos usar := para declarar um array, incluindo arrays multidimensionais.
Por exemplo:
a := [10][10]int{}
Dessa forma, definimos um array bidimensional de inteiros de tamanho 10*10.
Inicialização de um Array Bidimensional
Semelhante aos arrays unidimensionais, podemos inicializar um array bidimensional das seguintes maneiras:
- Lista de inicialização
- Inicialização com comprimento inferido
- Inicialização com valor de índice especificado
Você se lembra de como usar esses métodos?
Aprendemos como usar esses métodos em arrays unidimensionais na seção anterior. Se você esqueceu, não tem problema.
A seção a seguir revisará esses três métodos de inicialização e os estenderá para arrays bidimensionais.
Inicialização de um Array Bidimensional Usando uma Lista de Inicialização
Vamos continuar usando o arquivo array.go criado na seção anterior. Se você não salvou seu trabalho, pode criar o arquivo da seguinte forma:
touch ~/project/array.go
Escreva o seguinte código em array.go:
package main
import "fmt"
func main() {
// Inicializado automaticamente para 0
var simpleArray [3][3]int
// Inicializa usando valores iniciais especificados, usa valores padrão para os elementos ausentes
var numArray = [3][3]int{{1, 2, 3}, {2, 3, 4}}
// Inicializa usando valores iniciais especificados
var cityArray = [2][2]string{{"London", "Chengdu"}, {"Paris", "Boston"}}
fmt.Println(simpleArray) // [[0 0 0] [0 0 0] [0 0 0]]
fmt.Println(numArray) // [[1 2 3] [2 3 4] [0 0 0]]
fmt.Println(cityArray) // [[London Chengdu] [Paris Boston]]
}
O código acima demonstra três maneiras de inicializar um array bidimensional usando uma lista de inicialização.
Execute o código usando o seguinte comando:
go run ~/project/array.go
A saída é a seguinte:
[[0 0 0] [0 0 0] [0 0 0]]
[[1 2 3] [2 3 4] [0 0 0]]
[[London Chengdu] [Paris Boston]]
Você pode modificar os valores e revisar os métodos de inicialização para arrays unidimensionais.
Inicialização de um Array Bidimensional com Comprimento Inferido
Em um array bidimensional, podemos usar o método de comprimento inferido para inicializá-lo, assim como fizemos com arrays unidimensionais.
Escreva o seguinte código em array.go:
package main
import "fmt"
func main() {
// Inicializado automaticamente para 0
var simpleArray [3][3]int
// Inicializa usando valores iniciais especificados, usa valores padrão para os elementos ausentes
var numArray = [...][]int{{1, 2, 3, 3}, {2, 3, 4, 3}, {0}}
// Inicializa usando valores iniciais especificados
var cityArray = [...][2]string{{"London", "Chengdu"}, {"Paris", "Boston"}}
fmt.Println(simpleArray) // [[0 0 0] [0 0 0] [0 0 0]]
fmt.Println(numArray) // [[1 2 3 3] [2 3 4 3] [0]]
fmt.Println(cityArray) // [[London Chengdu] [Paris Boston]]
}
O código acima demonstra o uso do comprimento inferido para inicializar um array bidimensional.
go run ~/project/array.go
A saída é a mesma do método da lista de inicialização.
[[0 0 0] [0 0 0] [0 0 0]]
[[1 2 3 3] [2 3 4 3] [0]]
[[London Chengdu] [Paris Boston]]
No entanto, ao contrário dos arrays unidimensionais, na inicialização com comprimento inferido de um array bidimensional, o símbolo ... só pode existir nos primeiros colchetes.
Por exemplo:
var numArray = [...][]int{{1, 2, 3, 3}, {2, 3, 4, 3}}
Este código é válido, mas as duas variações a seguir estão incorretas:
var numArray = [][...]int{{1, 2, 3, 3}, {2, 3, 4, 3}}
var numArray = [...][...]int{{1, 2, 3, 3}, {2, 3, 4, 3}}
Além disso, vamos comparar numArray e cityArray.
Podemos ver que em cityArray, especificamos o segundo parâmetro do tamanho do array bidimensional, como mostrado abaixo:
var cityArray = [...][2]string{{"London", "Chengdu"}, {"Paris", "Boston"}}
Isso significa que especificamos o tamanho de cada sub-array como 2 durante a inicialização.
Se os valores fornecidos não forem suficientes durante a inicialização, os valores padrão do tipo de dados serão usados para preencher os elementos ausentes.
Se o número de valores fornecidos exceder o tamanho especificado, ocorrerá um erro.
Inicializando um Array Bidimensional com Valores de Índice Específicos
Semelhante aos arrays unidimensionais, você também pode usar valores de índice especificados para inicialização em um array bidimensional. O processo é similar.
Escreva o seguinte código em array.go:
package main
import "fmt"
func main() {
a := [...][]int{1: {1, 2, 3}, 3: {4, 7, 9}}
fmt.Println(a) // [[] [1 2 3] [] [4 7 9]]
fmt.Printf("Type of array a: %T\n", a) // Type of array a: [4][]int
}
go run ~/project/array.go
A saída é:
[[] [1 2 3] [] [4 7 9]]
Type of array a: [4][]int
O código acima define o array a como um array bidimensional com um comprimento indeterminado. Ele atribui o valor [1 2 3] ao array no índice 1 e o valor [4 7 9] ao array no índice 3.
No caso do comprimento inferido automaticamente, o tipo do array a é [4][]int.
Percorrendo um Array Bidimensional
Como percorremos um array bidimensional?
Quando aprendemos sobre arrays unidimensionais, usamos dois métodos para percorrer arrays: usando a palavra-chave range e usando números de índice.
Agora, vamos aplicar esses dois métodos para percorrer um array bidimensional.
Escreva o seguinte código em array.go:
package main
import "fmt"
func main() {
a := [...][]int{{123, 321, 222}, {404, 501, 503}, {857, 419, 857}}
// Method 1: using the range keyword
fmt.Println("Traversing the Two-Dimensional Array Using the range Keyword")
for index, value := range a {
for i, j := range value {
fmt.Println(index, i, j)
}
}
// Method 2: using index numbers
fmt.Println("\nTraversing the Two-Dimensional Array Using Index Numbers")
for i := 0; i < len(a); i++ {
for j := 0; j < len(a[i]); j++ {
fmt.Println(i, j, a[i][j])
}
}
}
O código acima demonstra duas maneiras de percorrer um array bidimensional.
go run ~/project/array.go
A saída é:
Traversing the Two-Dimensional Array Using the range Keyword
0 0 123
0 1 321
0 2 222
1 0 404
1 1 501
1 2 503
2 0 857
2 1 419
2 2 857
Traversing the Two-Dimensional Array Using Index Numbers
0 0 123
0 1 321
0 2 222
1 0 404
1 1 501
1 2 503
2 0 857
2 1 419
2 2 857
Embora ambos os métodos gerem os mesmos resultados, eles são fundamentalmente diferentes. Essas diferenças serão particularmente evidentes em nosso uso real de arrays.
Usos Práticos de Arrays
Na seção anterior, mencionamos que os dois métodos de percorrimento de array são fundamentalmente diferentes.
Vamos usar um pequeno exemplo para explicar isso.
Escreva o seguinte código em array.go:
package main
import "fmt"
func main() {
a := [...][]int{{123, 321, 222}, {404, 501, 503}, {857, 419, 857}}
// Method 1: using the range keyword
fmt.Println("Traversing the Two-Dimensional Array Using the range Keyword")
for _, value := range a {
for _, j := range value {
fmt.Println(j)
}
}
fmt.Println(a)
// Method 2: using index numbers
fmt.Println("\nTraversing the Two-Dimensional Array Using Index Numbers")
for i := 0; i < len(a); i++ {
for j := 0; j < len(a[i]); j++ {
fmt.Println(a[i][j])
a[i][j] = 0
}
}
fmt.Println(a)
}
O código acima demonstra o uso dos dois métodos diferentes para definir todos os valores no array bidimensional como 0.
go run ~/project/array.go
A saída do programa é:
Traversing the Two-Dimensional Array Using the range Keyword
123
321
222
404
501
503
857
419
857
[[123 321 222] [404 501 503] [857 419 857]]
Traversing the Two-Dimensional Array Using Index Numbers
123
321
222
404
501
503
857
419
857
[[0 0 0] [0 0 0] [0 0 0]]
Descobrimos que, ao usar a palavra-chave range para percorrer o array, modificar seu valor não tem efeito. No entanto, após usar números de índice para percorrer o array, modificar seu valor é eficaz. Isso ocorre porque, quando usamos a palavra-chave range para percorrer o array, a variável de loop j é, na verdade, uma cópia do valor do array. Modificar o valor da cópia não afeta o array original a. No entanto, modificar o valor do array original é válido ao usar números de índice para percorrer o array.
Escalonando um Array Tridimensional
Às vezes, precisamos usar um array tridimensional ou até mesmo um array quadridimensional.
Expandir para arrays de dimensões superiores não é muito diferente de expandir um array unidimensional para um array bidimensional.
Vamos pegar um exemplo simples:
package main
import "fmt"
func main() {
a := [2][2][2]int{}
for i := 0; i < 2; i++ {
for j := 0; j < 2; j++ {
for k := 0; k < 2; k++ {
a[i][j][k] = 1
}
}
}
fmt.Println(a)
}
O código acima demonstra como definir e usar um array tridimensional. O processo é o mesmo para arrays quadridimensionais ou de dimensões superiores.
go run ~/project/array.go
A saída é:
[[[1 1] [1 1]] [[1 1] [1 1]]]
No entanto, arrays de dimensões superiores não são comumente usados. Portanto, entender o conceito é suficiente.
Resumo
Neste laboratório, aprendemos o seguinte:
- Dois métodos para definir um array bidimensional
- Três métodos para inicializar um array bidimensional
- Dois métodos para percorrer um array bidimensional
- A diferença entre os dois métodos de percorrimento no uso real
- Uma visão geral do uso de arrays multidimensionais
