Arrays en Go: multidimensionalidad

Los arrays no son una mera colección secuencial de valores. También permiten con trabajar varias dimensiones de datos, con lo que su capacidad de trabajar con datos relacionados aumenta exponencialmente.

Arrays bidimensionales

Imaginemos una clase que tiene 20 alumnos, que todos tienen 11 asignaturas, y que deseamos guardar las notas de cada uno de estos alumnos.

Go nos permite definir y trabajar con un array en dos dimensiones (una para los alumnos, y otra para las asignaturas). Para ello, a la hora de declarar el array, definimos el tamaño de cada una de las dimensiones entre corchetes.

var notas [20][11]int   // 20 alumnos y 11 asignaturas

A la hora de acceder a cada elemento, especificamos el índice correspondiente en cada una de las dos dimensiones. Por ejemplo:

notas[0][0] = 5 // Nota 5 para alumno 0, asignatura 0
notas[5][6] = 7 // Nota 7 para alumno 5, asignatura 6
notas[11][2] = 6 // Nota 6 para alumno 11, asignatura 2

El siguiente programa ilustra el uso de un array bidimensional de 3 alumnos con 3 asignaturas (para no hacerlo muy extenso).

package main

import "fmt"

func main() {
   // Definicion de un array bidimensional
   // Primera dimension es el alumno
   // Segunda dimension es la asignatura
   var notas [3][3]int

   // Asignacion nota a nota
   notas[0][0] = 5 // alumno 0, asignatura 0
   notas[0][1] = 3 // alumno 0, asignatura 1
   notas[0][2] = 6 // alumno 0, asignatura 2

   // Asignacion directa de todas las notas
   notas[1] = [3]int{7, 9, 6}  // Alumno 1
   notas[2] = [3]int{6, 7, 8}  // Alumno 2

   fmt.Println("---")
   fmt.Println("Contenido array notas", notas)
   fmt.Println("Contenido primer alumno", notas[0])
   fmt.Println("---")
   fmt.Println("Notas del primer alumno")
   fmt.Println("Asignatura 0: ", notas[0][0])
   fmt.Println("Asignatura 1: ", notas[0][1])
   fmt.Println("Asignatura 2: ", notas[0][2])
}

El resultado sería el siguiente:

---
Contenido array notas [[5 3 6] [7 9 6] [6 7 8]]
Contenido primer alumno [5 3 6]
---
Notas del primer alumno
Asignatura 0:  5
Asignatura 1:  3
Asignatura 2:  6

Arrays multidimensionales

Podemos utilizar más de dos dimensiones en un array. Por ejemplo, si vamos a asignar las notas de varias clases, podríamos utilizar un array tridimensional:

// 6 clases, 20 alumnos y 11 asignaturas
var notas [6][20][11]int

El número de dimensiones puede ser mayor. Por ejemplo, si tenemos varios centros, podemos añadir una dimensión más:

// 3 centros, 6 clases, 20 alumnos y 11 asignaturas
var notas [3][6][20][11]int

La forma de referenciar y acceder a cada dimensión sigue la misma dinámica que con un array de dos dimensiones:

// Nota 5 para la asignatura 5, del alumno 14,
// de la clase 3, del centro 1
notas [1][3][14][5] = 5

El uso de arrays se vuelve más complejo y difícil de mantener a medida que añadimos dimensiones.

Además, el uso de dimensiones obliga a que todas las dimensiones sean iguales de forma obligatoria, cosa que no suele ser real. Por ejemplo, no todos los centros tienen el mismo número de clases, ni todas las clases tienen el mismo número de alumnos ni de asignaturas. Un año escolar puede tener más o menos clases que otro año, y lo mismo ocurre con los alumnos. Una legislación nueva puede incluir o quitar algunas asignaturas.

En estos casos es mejor utilizar colecciones de entidades por separado. Por ejemplo, una colección de centros, otra de clases, otra de alumnos y otra de asignaturas. Cada una de estas colecciones estará relacionada con otra a través de un campo clave, de tipo código o id. Esta sería la forma en que las bases de datos relacionales usan y conectan datos sin importar sus dimensiones.

Este tipo de colecciones ya utilizarían tipos definidos de estructura, los cuales simulan registros de campos variados similares a los registros de una tabla de base de datos.

Enlaces de interés

• Go by example - Arrays: https://gobyexample.com/arrays
• Golang book - Arrays: https://www.golang-book.com/books/intro/6#section1