Arrays Multidimensionales en Golang

Introducción

En la sección anterior, aprendimos sobre el uso básico de los arrays.

¿Qué tipos de elementos pueden estar en un array?

En Go, los elementos en un array pueden ser de cualquier tipo primitivo, como enteros, cadenas de texto o tipos personalizados.

¿Qué sucede si los elementos en un array son arrays?

Entonces tenemos un array multidimensional:

Como se muestra en la figura anterior, el cuadro morado es nuestro array original.

Cada elemento en el array del cuadro morado es un nuevo array (el cuadro rojo).

Conceptos clave:

• Definición de un array bidimensional
• Inicialización de un array bidimensional
• Recorrido de un array bidimensional
• Uso de arrays multidimensionales

Skills Graph

Definición de un Array Bidimensional

Definición General

¿Recuerdas cómo definimos un array normal?

var variableName [elementCount]variableType

Entonces, ¿cómo definimos un array bidimensional utilizando este método más sencillo?

var variableName [elementCount][elementCount]variableType

La única diferencia es que agregamos otro [elementCount] antes del [elementCount] original para formar el formato [elementCount][elementCount].

Por ejemplo, si queremos definir un array bidimensional llamado a con una capacidad de 10*10 de tipo int, podemos usar la siguiente sintaxis:

var a [10][10]int

Definición Corta

Al igual que con la declaración corta de variables, podemos usar un método de definición corta para declarar arrays, incluso arrays multidimensionales.

Podemos usar := para declarar un array, incluyendo arrays multidimensionales.

Por ejemplo:

a := [10][10]int{}

De esta manera definimos un array bidimensional de enteros de tamaño 10*10.

Inicialización de un Array Bidimensional

Similar a los arrays unidimensionales, podemos inicializar un array bidimensional de las siguientes maneras:

• Lista de inicialización
• Inicialización con longitud inferida
• Inicialización con valor de índice especificado

¿Recuerdas cómo usar estos métodos?

Hemos aprendido cómo usar estos métodos en arrays unidimensionales en la sección anterior. Si los has olvidado, no pasa nada.

La siguiente sección revisará estos tres métodos de inicialización y los extenderá a los arrays bidimensionales.

Inicialización de un Array Bidimensional Utilizando una Lista de Inicialización

Continuemos utilizando el archivo array.go creado en la sección anterior. Si no has guardado tu trabajo, puedes crear el archivo de la siguiente manera:

touch ~/project/array.go

Escribe el siguiente código en array.go:

package main

import "fmt"

func main() {
    // Automatically initialized to 0
    var simpleArray [3][3]int
    // Initialize using specified initial values, use default values for the missing elements
    var numArray = [3][3]int{{1, 2, 3}, {2, 3, 4}}
    // Initialize using specified initial values
    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]]
}

El código anterior demuestra tres formas de inicializar un array bidimensional utilizando una lista de inicialización.

Ejecuta el código utilizando el siguiente comando:

go run ~/project/array.go

La salida es la siguiente:

[[0 0 0] [0 0 0] [0 0 0]]
[[1 2 3] [2 3 4] [0 0 0]]
[[London Chengdu] [Paris Boston]]

Puedes modificar los valores y repasar los métodos de inicialización de arrays unidimensionales.

Inicialización de un Array Bidimensional con Longitud Inferida

En un array bidimensional, podemos utilizar el método de longitud inferida para inicializarlo, al igual que hicimos con los arrays unidimensionales.

Escribe el siguiente código en array.go:

package main

import "fmt"

func main() {
    // Automatically initialized to 0
    var simpleArray [3][3]int
    // Initialize using specified initial values, use default values for the missing elements
    var numArray = [...][]int{{1, 2, 3, 3}, {2, 3, 4, 3}, {0}}
    // Initialize using specified initial values
    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]]
}

El código anterior demuestra el uso de la longitud inferida para inicializar un array bidimensional.

go run ~/project/array.go

La salida es la misma que con el método de lista de inicialización.

[[0 0 0] [0 0 0] [0 0 0]]
[[1 2 3 3] [2 3 4 3] [0]]
[[London Chengdu] [Paris Boston]]

Sin embargo, a diferencia de los arrays unidimensionales, en la inicialización con longitud inferida de un array bidimensional, el símbolo ... solo puede existir en los primeros corchetes cuadrados.

Por ejemplo:

var numArray = [...][]int{{1, 2, 3, 3}, {2, 3, 4, 3}}

Este código es válido, pero las siguientes dos variaciones son incorrectas:

var numArray = [][...]int{{1, 2, 3, 3}, {2, 3, 4, 3}}
var numArray = [...][...]int{{1, 2, 3, 3}, {2, 3, 4, 3}}

Además, comparemos numArray y cityArray.

Podemos ver que en cityArray, especificamos el segundo parámetro del tamaño del array bidimensional, como se muestra a continuación:

var cityArray = [...][2]string{{"London", "Chengdu"}, {"Paris", "Boston"}}

Esto significa que especificamos el tamaño de cada sub-array como 2 durante la inicialización.

Si los valores dados no son suficientes durante la inicialización, se utilizarán los valores predeterminados del tipo de datos para llenar los elementos faltantes.

Si el número de valores dados excede el tamaño especificado, se producirá un error.

Inicialización de un Array Bidimensional con Valores de Índice Especificados

Similar a los arrays unidimensionales, también puedes utilizar valores de índice especificados para la inicialización en un array bidimensional. El proceso es similar.

Escribe el siguiente código en 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

La salida es:

[[] [1 2 3] [] [4 7 9]]
Type of array a: [4][]int

El código anterior define el array a como un array bidimensional con longitud indeterminada. Asigna el valor [1 2 3] al array en el índice 1 y el valor [4 7 9] al array en el índice 3.

En el caso de la longitud inferida automáticamente, el tipo del array a es [4][]int.

Recorriendo un Array Bidimensional

¿Cómo recorremos un array bidimensional?

Cuando aprendimos sobre arrays unidimensionales, utilizamos dos métodos para recorrerlos: usando la palabra clave range y usando números de índice.

Ahora apliquemos estos dos métodos para recorrer un array bidimensional.

Escribe el siguiente código en 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])
        }
    }
}

El código anterior demuestra dos formas de recorrer un array bidimensional.

go run ~/project/array.go

La salida es:

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

Aunque ambos métodos generan los mismos resultados, son fundamentalmente diferentes. Estas diferencias serán particularmente evidentes en nuestro uso real de los arrays.

Usos Prácticos de los Arrays

En la sección anterior, mencionamos que los dos métodos de recorrido de arrays son fundamentalmente diferentes.

Usemos un pequeño ejemplo para explicar esto.

Escribe el siguiente código en 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)
}

El código anterior demuestra el uso de los dos métodos diferentes para establecer todos los valores en el array bidimensional a 0.

go run ~/project/array.go

La salida del programa es:

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]]

Descubrimos que cuando se utiliza la palabra clave range para recorrer el array, modificar su valor no tiene efecto. Sin embargo, después de usar números de índice para recorrer el array, modificar su valor es efectivo. Esto se debe a que cuando usamos la palabra clave range para recorrer el array, la variable de bucle j es en realidad una copia del valor del array. Modificar el valor de la copia no afecta al array original a. Sin embargo, modificar el valor del array original es válido cuando se utilizan números de índice para recorrer el array.

Aumento de Dimensión de un Array Bidimensional

A veces, necesitamos utilizar un array tridimensional o incluso un array tetradimensional.

Expandir a arrays de dimensiones superiores no es muy diferente de expandir un array unidimensional a un array bidimensional.

Tomemos un ejemplo sencillo:

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

El código anterior demuestra cómo definir y utilizar un array tridimensional. El proceso es el mismo para arrays tetradimensionales o de dimensiones superiores.

go run ~/project/array.go

La salida es:

[[[1 1] [1 1]] [[1 1] [1 1]]]

Sin embargo, los arrays de dimensiones superiores no se utilizan comúnmente. Así que entender el concepto es suficiente.

Resumen

En este laboratorio (lab), hemos aprendido lo siguiente:

• Dos métodos para definir un array bidimensional
• Tres métodos para inicializar un array bidimensional
• Dos métodos para recorrer un array bidimensional
• La diferencia entre los dos métodos de recorrido en el uso real
• Una visión general del uso de arrays multidimensionales