Arrays en Go

Introducción

En este artículo, nos adentraremos en el mundo de los arrays en Go, un poderoso lenguaje de programación creado por Google.

Aprenderemos cómo declarar, inicializar, acceder y manipular arrays en Go, además de examinar operaciones comunes y técnicas avanzadas para trabajar con ellos.

Al finalizar la lectura, contarás con un profundo conocimiento sobre el uso de arrays en tus proyectos de Go.

¿Qué son los arrays en Go?

Un array en Go es una estructura de datos que contiene una cantidad fija de elementos del mismo tipo. El tipo de elementos que puede contener un array es prácticamente ilimitado, incluyendo números enteros, flotantes, cadenas de caracteres, estructuras, etc.

Los arrays son útiles cuando necesitas almacenar múltiples valores relacionados de manera ordenada y accesible.

Por ejemplo, podrías tener un array de calificaciones de estudiantes, donde cada elemento del array representa la calificación de un estudiante en particular.

Al ser de tamaño fijo, los arrays aseguran que se utilice únicamente la cantidad de memoria necesaria, optimizando así el uso de recursos.

La sintaxis para declarar un array es la siguiente:


var nombre_array [longitud]tipo

Lenguaje del código: Go (go)

Donde nombre_array es el nombre del array, longitud es la cantidad de elementos que puede almacenar el array y tipo es el tipo de dato que contendrá el

Ejemplo de un array en Go:


package main

import "fmt"

func main() {
    var calificaciones [5]int

    calificaciones[0] = 85
    calificaciones[1] = 90
    calificaciones[2] = 78
    calificaciones[3] = 92
    calificaciones[4] = 88

    fmt.Println(calificaciones)
}

Lenguaje del código: Go (go)

En este ejemplo, hemos creado un array llamado calificaciones que contiene cinco elementos de tipo int. Luego, asignamos valores a cada elemento y, finalmente, imprimimos el contenido del array.

Diferencia entre arrays y slices en Go

Aunque los arrays y los slices en Go pueden parecer similares a simple vista, hay diferencias clave entre ellos:

  • Arrays:
    • Tamaño fijo en el momento de la declaración
    • Menos flexibles que los slices
    • Útiles cuando se conoce el tamaño requerido previamente
  • Slices:
    • Tamaño dinámico y puede cambiar durante la ejecución del programa
    • Más flexibles que los arrays
    • Útiles cuando se desconoce el tamaño requerido previamente o cuando se espera que cambie

A continuación, se muestra un ejemplo de array y slice en Go para ilustrar las diferencias:


var arrayEjemplo [3]int // Declaración de un array de tamaño fijo con 3 elementos
arrayEjemplo[0] = 1
arrayEjemplo[1] = 2
arrayEjemplo[2] = 3

sliceEjemplo := []int{1, 2, 3} // Declaración de un slice con 3 elementos
sliceEjemplo = append(sliceEjemplo, 4) // Añade un cuarto elemento al slice

Lenguaje del código: Go (go)

Declaración e inicialización de arrays en Go

En esta sección, veremos cómo declarar e inicializar arrays en Go utilizando diferentes métodos.

Declaración de arrays con tamaño fijo

Para declarar un array en Go, se utiliza la siguiente sintaxis:


var nombreArray [tamaño]Tipo

Lenguaje del código: Go (go)

Donde “nombreArray” es el identificador del array, “tamaño” es un número entero que define la cantidad de elementos que puede contener el array, y “Tipo” es el tipo de dato que almacena el array.

Ejemplo:


var colores [3]string // Declaración de un array llamado 'colores' que puede almacenar 3 cadenas de texto

Lenguaje del código: Go (go)

Inicialización de arrays con valores predeterminados

Una vez que hayas declarado un array, puedes inicializarlo asignando valores a sus elementos. Para asignar un valor a un elemento del array, utiliza el operador de indexación ([]).

Ejemplo:


var colores [3]string // Declaración de un array llamado 'colores' que puede almacenar 3 cadenas de texto

colores[0] = "rojo"    // Asignación de valores a los elementos del array
colores[1] = "verde"
colores[2] = "azul"

Lenguaje del código: Go (go)

Declaración e inicialización en una sola línea

También puedes declarar e inicializar un array en una sola línea utilizando la siguiente sintaxis:


nombreArray := [tamaño]Tipo{valor1, valor2, ..., valorN}

Lenguaje del código: Go (go)

Ejemplo:


colores := [3]string{"rojo", "verde", "azul"} // Declaración e inicialización del array 'colores' en una sola línea

Lenguaje del código: Go (go)

Si deseas que Go infiera el tamaño del array a partir de la cantidad de elementos proporcionados, puedes utilizar la sintaxis “…” en lugar de especificar el tamaño explícitamente:


colores := [...]string{"rojo", "verde", "azul"} // Go infiere el tamaño del array 'colores' como 3

Lenguaje del código: Go (go)

En este caso, Go determina automáticamente el tamaño del array en base a la cantidad de elementos proporcionados en la inicialización.

Acceder a elementos de un array en Go

En Go, se accede a los elementos de un array mediante su índice. El índice indica la posición del elemento dentro del array, empezando por 0 para el primer elemento.

Para acceder a un elemento específico del array, se utiliza la sintaxis array[indice], donde array es el nombre del array y indice es el número entero que indica la posición del elemento que se desea acceder.

Por ejemplo, si tenemos el siguiente array de tipo int:


var mi_array [5]int = [5]int{10, 20, 30, 40, 50}

Lenguaje del código: Go (go)

Para acceder al tercer elemento del array, que tiene un índice de 2, se puede hacer lo siguiente:


fmt.Println(mi_array[2]) // Imprime el valor del tercer elemento del array: 30

Lenguaje del código: Go (go)

En este ejemplo, se utiliza la sintaxis mi_array[2] para acceder al tercer elemento del array, que tiene un índice de 2. Luego, se utiliza la función fmt.Println() para imprimir el valor del elemento.

También se pueden utilizar variables como índices para acceder a los elementos de un array. Por ejemplo, si tenemos una variable indice de tipo int que contiene el valor 1, se puede acceder al segundo elemento del array de la siguiente manera:


var indice int = 1
fmt.Println(mi_array[indice]) // Imprime el valor del segundo elemento del array: 20

Lenguaje del código: Go (go)

En este ejemplo, se utiliza la variable indice como índice para acceder al segundo elemento del array, que tiene un valor de 20.

Es importante tener en cuenta que los índices en Go deben ser números enteros no negativos. Si se utiliza un índice fuera del rango válido del array, se producirá un error en tiempo de ejecución.

Cambiar elementos de un array en Go

En Go, se pueden cambiar los elementos de un array utilizando la sintaxis array[indice] = valor, donde array es el nombre del array, indice es el número entero que indica la posición del elemento que se desea cambiar y valor es el nuevo valor que se desea asignar al elemento.

Por ejemplo, si tenemos el siguiente array de tipo int:


var mi_array [5]int = [5]int{10, 20, 30, 40, 50}

Lenguaje del código: Go (go)

Para cambiar el valor del tercer elemento del array, que tiene un índice de 2, se puede hacer lo siguiente:


mi_array[2] = 35
fmt.Println(mi_array) // Imprime el array modificado: [10 20 35 40 50]

Lenguaje del código: Go (go)

En este ejemplo, se utiliza la sintaxis mi_array[2] = 35 para cambiar el valor del tercer elemento del array, que tiene un índice de 2, a 35. Luego, se utiliza la función fmt.Println() para imprimir el array modificado.

También se pueden utilizar variables como índices para cambiar los elementos de un array. Por ejemplo, si tenemos una variable indice de tipo int que contiene el valor 1 y queremos cambiar el valor del segundo elemento del array, se puede hacer lo siguiente:


var indice int = 1
mi_array[indice] = 25
fmt.Println(mi_array) // Imprime el array modificado: [10 25 30 40 50]

Lenguaje del código: Go (go)

En este ejemplo, se utiliza la variable indice como índice para acceder al segundo elemento del array y cambiar su valor a 25. Luego, se utiliza la función fmt.Println() para imprimir el array modificado.

Iteración sobre un array usando bucles for

Para recorrer todos los elementos de un array, puedes utilizar un bucle for. Go proporciona dos formas de iterar sobre un array: utilizando un bucle for con índices y utilizando un bucle for con la declaración range.

Bucle for con índices


colores := [3]string{"rojo", "verde", "azul"} // Declaración e inicialización del array 'colores'

// Iteración sobre el array utilizando un bucle for con índices
for i := 0; i < len(colores); i++ {
    fmt.Println(colores[i]) // Imprime cada elemento del array 'colores'
}

Lenguaje del código: Go (go)

Bucle for con la declaración range


colores := [3]string{"rojo", "verde", "azul"} // Declaración e inicialización del array 'colores'

// Iteración sobre el array utilizando un bucle for con la declaración range
for i, color := range colores {
    fmt.Printf("Índice: %d, Color: %s\n", i, color) // Imprime el índice y el elemento del array 'colores'
}

Lenguaje del código: Go (go)

Ten en cuenta que si solo necesitas el elemento y no el índice, puedes utilizar el operador guion bajo (_) para ignorar el valor del índice:


for _, color := range colores {
    fmt.Println(color) // Imprime cada elemento del array 'colores' sin utilizar el índice
}

Lenguaje del código: Go (go)

Operaciones comunes en arrays

En esta sección, discutiremos algunas operaciones comunes que puedes realizar en arrays en Go.

Longitud de un array con la función len()

La función len() te permite obtener la longitud (número de elementos) de un array.

Ejemplo:


numeros := [...]int{1, 2, 3, 4, 5} // Declaración e inicialización del array 'numeros'
longitud := len(numeros)           // Obtiene la longitud del array 'numeros'
fmt.Println(longitud)              // Imprime 5

Lenguaje del código: Go (go)

Copiar arrays con la función copy()

La función copy() te permite copiar elementos de un array a otro. La función devuelve la cantidad de elementos copiados.

Ejemplo:


numeros1 := [5]int{1, 2, 3, 4, 5} // Declaración e inicialización del array 'numeros1'
var numeros2 [5]int               // Declaración del array 'numeros2' de tamaño 5

copiados := copy(numeros2[:], numeros1[:]) // Copia elementos de 'numeros1' a 'numeros2'
fmt.Println(copiados)                      // Imprime 5
fmt.Println(numeros2)                      // Imprime [1 2 3 4 5]

Lenguaje del código: Go (go)

Encontrar el elemento máximo y mínimo en un array

Para encontrar el elemento máximo y mínimo en un array, puedes iterar sobre el array y comparar los elementos.

Ejemplo:


numeros := [...]int{5, 2, 8, 1, 4} // Declaración e inicialización del array 'numeros'

min := numeros[0] // Inicializa 'min' y 'max' con el primer elemento del array
max := numeros[0]

for _, num := range numeros {
    if num < min {
        min = num // Actualiza 'min' si se encuentra un valor menor
    }
    if num > max {
        max = num // Actualiza 'max' si se encuentra un valor mayor
    }
}

fmt.Printf("Mínimo: %d, Máximo: %d\n", min, max) // Imprime "Mínimo: 1, Máximo: 8"

Lenguaje del código: Go (go)

Ordenar un array en Go

Go no proporciona una función de ordenación específica para arrays, pero puedes convertir un array a un slice y utilizar el paquete “sort” para ordenar el slice.

Ejemplo:


import (
	"fmt"
	"sort"
)

func main() {
    numeros := [...]int{5, 2, 8, 1, 4} // Declaración e inicialización del array 'numeros'
    numerosSlice := numeros[:]         // Convierte el array 'numeros' en un slice

    sort.Ints(numerosSlice) // Ordena el slice 'numerosSlice' en orden ascendente
    fmt.Println(numerosSlice) // Imprime [1 2 4 5 8]
}

Lenguaje del código: Go (go)

En esta sección, hemos explorado algunas operaciones comunes en arrays, como obtener la longitud, copiar arrays, encontrar elementos máximo y mínimo, y ordenar arrays. En la siguiente sección, aprenderemos sobre arrays multidimensionales.

Arrays multidimensionales en Go

Los arrays multidimensionales son arrays que contienen otros arrays como elementos. En Go, los arrays multidimensionales se pueden utilizar para representar estructuras de datos como matrices, tablas o rejillas.

En esta sección, aprenderemos cómo declarar, inicializar, acceder y modificar elementos en arrays multidimensionales, así como cómo iterar sobre ellos.

Declaración e inicialización de arrays multidimensionales

Para declarar un array multidimensional en Go, especifica las dimensiones del array en la declaración utilizando corchetes ([]).

Ejemplo de declaración de un array bidimensional (matriz) de 3×3:


var matriz [3][3]int // Declaración de un array bidimensional 'matriz' con 3 filas y 3 columnas

Lenguaje del código: Go (go)

Para inicializar un array multidimensional, proporciona los valores de los elementos en un formato anidado.

Ejemplo de inicialización de un array bidimensional (matriz) de 3×3:


matriz := [3][3]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
} // Inicialización del array bidimensional 'matriz' con valores

Lenguaje del código: Go (go)

Acceso y modificación de elementos en arrays multidimensionales

Para acceder o modificar un elemento en un array multidimensional, utiliza el operador de indexación ([]) y proporciona los índices de cada dimensión.

Ejemplo de acceso y modificación de un elemento en un array bidimensional (matriz) de 3×3:


matriz := [3][3]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
} // Inicialización del array bidimensional 'matriz' con valores

elemento := matriz[1][2] // Acceso al elemento en la fila 1 (segunda fila) y columna 2 (tercera columna)
fmt.Println(elemento)    // Imprime 6

matriz[1][2] = 10        // Modificación del elemento en la fila 1 y columna 2
fmt.Println(matriz[1][2]) // Imprime 10

Lenguaje del código: Go (go)

Iteración sobre arrays multidimensionales

Para iterar sobre un array multidimensional, utiliza bucles for anidados. El bucle externo recorre las filas y el bucle interno recorre las columnas (o las dimensiones adicionales, si es un array de más de dos dimensiones).

Ejemplo de iteración sobre un array bidimensional (matriz) de 3×3 utilizando bucles for anidados:


matriz := [3][3]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
} // Inicialización del array bidimensional 'matriz' con valores

// Iteración sobre el array bidimensional 'matriz' utilizando bucles for anidados
for i := 0; i < len(matriz); i++ {
    for j := 0; j < len(matriz[i]); j++ {
        fmt.Printf("%d ", matriz[i][j]) // Imprime cada elemento de 'matriz'
    }
    fmt.Println()
}

Lenguaje del código: Go (go)

Alternativamente, puedes utilizar bucles for con la declaración range para iterar sobre un array multidimensional:


matriz := [3][3]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
} // Inicialización del array bidimensional 'matriz' con valores

// Iteración sobre el array bidimensional 'matriz' utilizando bucles for con la declaración range
for i, fila := range matriz {
    for j, elemento := range fila {
        fmt.Printf("Índice: [%d][%d], Valor: %d\n", i, j, elemento) // Imprime los índices y el elemento de 'matriz'
    }
}

Lenguaje del código: Go (go)

Arrays multidimensionales de más de dos dimensiones

Aunque los ejemplos anteriores se centran en arrays bidimensionales (matrices), también puedes trabajar con arrays multidimensionales de más de dos dimensiones utilizando una sintaxis similar.

Ejemplo de un array tridimensional de 2x3x4:


var cubo [2][3][4]int // Declaración de un array tridimensional 'cubo' con 2 capas, 3 filas y 4 columnas

// Inicialización del array tridimensional 'cubo' con valores
cubo = [2][3][4]int{
    {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    },
    {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
        {21, 22, 23, 24},
    },
}

// Iteración sobre el array tridimensional 'cubo' utilizando bucles for anidados
for i := 0; i < len(cubo); i++ {
    for j := 0; j < len(cubo[i]); j++ {
        for k := 0; k < len(cubo[i][j]); k++ {
            fmt.Printf("%d ", cubo[i][j][k]) // Imprime cada elemento de 'cubo'
        }
        fmt.Println()
    }
    fmt.Println()
}

Lenguaje del código: Go (go)

Conversiones entre arrays y slices en Go

Los arrays y los slices son dos estructuras de datos fundamentales en Go. Aunque ambos son similares en muchos aspectos, también tienen diferencias importantes.

Los arrays tienen un tamaño fijo, mientras que los slices son dinámicos y pueden cambiar de tamaño. En esta sección, aprenderemos cómo convertir arrays a slices y viceversa.

Convertir un array en un slice

Para convertir un array en un slice, utiliza los dos puntos (:) para seleccionar un rango de elementos en el array y crear un nuevo slice. Si no especificas los límites del rango, se seleccionarán todos los elementos del array.

Ejemplo:


numeros := [5]int{1, 2, 3, 4, 5} // Declaración e inicialización del array 'numeros'
numerosSlice := numeros[:]       // Convierte el array 'numeros' en un slice que incluye todos los elementos

fmt.Printf("Array: %v, Slice: %v\n", numeros, numerosSlice) // Imprime "Array: [1 2 3 4 5], Slice: [1 2 3 4 5]"

Lenguaje del código: Go (go)

También puedes especificar un rango específico de elementos para incluir en el nuevo slice:


numeros := [5]int{1, 2, 3, 4, 5} // Declaración e inicialización del array 'numeros'
subSlice := numeros[1:4]         // Crea un nuevo slice que incluye los elementos en los índices 1, 2 y 3

fmt.Println(subSlice) // Imprime "[2 3 4]"

Lenguaje del código: Go (go)

Convertir un slice en un array

Dado que los slices tienen un tamaño dinámico, no es posible convertir directamente un slice en un array. Sin embargo, puedes crear un nuevo array y copiar los elementos del slice en el array utilizando la función copy().

Ejemplo:


numerosSlice := []int{1, 2, 3, 4, 5} // Declaración e inicialización del slice 'numerosSlice'
var numeros [5]int                   // Declaración del array 'numeros' de tamaño 5

copiados := copy(numeros[:], numerosSlice) // Copia los elementos del slice 'numerosSlice' en el array 'numeros'
fmt.Println(copiados)                      // Imprime 5
fmt.Println(numeros)                       // Imprime "[1 2 3 4 5]"

Lenguaje del código: Go (go)

Ten en cuenta que si el tamaño del slice y el array no coinciden, se copiarán tantos elementos como sea posible sin exceder el tamaño del array de destino.

Ejemplos prácticos

A continuación, veremos algunos ejemplos prácticos que demuestran cómo utilizar arrays en Go para resolver problemas comunes.

Ejemplo 1: Suma de elementos en un array


package main

import "fmt"

func main() {
    numeros := [5]int{1, 2, 3, 4, 5} // Declaración e inicialización del array 'numeros'
    suma := 0                        // Inicializa la variable 'suma' en 0

    for _, num := range numeros {
        suma += num // Suma el valor de 'num' a 'suma'
    }

    fmt.Println("La suma de los elementos del array es:", suma) // Imprime "La suma de los elementos del array es: 15"
}

Lenguaje del código: Go (go)

En este ejemplo, hemos creado un array numeros que contiene cinco elementos. Luego, inicializamos una variable llamada suma con el valor de 0.

Usamos un bucle for con la declaración range para iterar sobre los elementos del array numeros, y vamos sumando cada elemento a la variable suma. Al final, imprimimos la suma de todos los elementos del array.

Ejemplo 2: Cálculo del promedio de un array de números


package main

import "fmt"

func main() {
    numeros := [5]float64{1, 2, 3, 4, 5} // Declaración e inicialización del array 'numeros'
    suma := 0.0                          // Inicializa la variable 'suma' en 0

    for _, num := range numeros {
        suma += num // Suma el valor de 'num' a 'suma'
    }

    promedio := suma / float64(len(numeros)) // Calcula el promedio dividiendo la suma por la cantidad de elementos en el array
    fmt.Printf("El promedio de los elementos del array es: %.2f\n", promedio) // Imprime "El promedio de los elementos del array es: 3.00"
}

Lenguaje del código: Go (go)

En este caso, también creamos un array numeros con cinco elementos, pero de tipo float64. Inicializamos la variable suma con el valor de 0.0. Utilizamos un bucle for con la declaración range para iterar sobre los elementos del array numeros y sumar cada elemento a la variable suma.

Después del bucle, calculamos el promedio dividiendo la suma por la cantidad de elementos en el array (len(numeros)). Finalmente, imprimimos el promedio de los elementos del array.

Ejemplo 3: Búsqueda secuencial en un array


package main

import "fmt"

func main() {
    numeros := [7]int{23, 42, 15, 7, 68, 32, 29} // Declaración e inicialización del array 'numeros'
    valorBuscado := 68                          // Valor que se busca en el array
    indice := -1                                // Inicializa la variable 'indice' en -1, lo que indica que el valor no se encontró

    for i, num := range numeros {
        if num == valorBuscado {
            indice = i       // Si se encuentra el valor buscado, guarda el índice en la variable 'indice'
            break            // Termina el bucle, ya que se encontró el valor
        }
    }

    if indice != -1 {
        fmt.Printf("El valor %d se encuentra en el índice %d del array.\n", valorBuscado, indice) // Imprime "El valor 68 se encuentra en el índice 4 del array."
    } else {
        fmt.Printf("El valor %d no se encuentra en el array.\n", valorBuscado) // Imprime esto si el valor no se encuentra en el array
    }
}

Lenguaje del código: Go (go)

En el tercer ejemplo, creamos un array numeros con siete elementos y especificamos un valorBuscado que queremos encontrar en el array. Inicializamos una variable llamada indice con el valor de -1, lo que indica que el valor buscado aún no se ha encontrado.

Usamos un bucle for con la declaración range para iterar sobre los elementos del array numeros. Si encontramos el valorBuscado, actualizamos la variable indice con el índice del elemento encontrado y terminamos el bucle con la instrucción break.

Después del bucle, verificamos si el valor de indice es diferente de -1, lo que indica que encontramos el valor buscado en el array. Si es así, imprimimos el índice en el que se encuentra el valor; de lo contrario, imprimimos un mensaje que indica que el valor no se encuentra en el array.

Referencias

Aquí tienes algunas referencias útiles sobre arrays en Go:

  1. Sitio oficial de Go – Documentación sobre arrays.
  2. Go by Example – Arrays.

Estas referencias cubren varios aspectos de los arrays en Go, desde la documentación oficial hasta ejemplos prácticos y tutoriales en profundidad. Al leer y estudiar estos recursos, podrás ampliar tus conocimientos sobre el tema y aprender más sobre cómo utilizar arrays en Go.

Curso de HTML Desde Cero

Inscríbete Ahora