Introducción
En el desarrollo de software moderno, a menudo necesitamos almacenar una gran cantidad de datos.
Basándonos en lo que hemos aprendido, podemos definir fácilmente numerosos variables.
Sin embargo, si necesitamos usar variables para registrar los nombres de los empleados de una empresa, con datos en una escala de cientos o miles, ¿tenemos que definirlos uno por uno?
Por supuesto que no. Para datos con atributos similares, podemos usar arrays (arreglos) para definirlos y almacenarlos.
Podemos pensar en los arrays como una colección de variables que se agrupan como un tren. Y cuando queremos encontrar una variable específica, solo necesitamos conocer el número de tren (nombre del array) y el número de asiento (índice). Entonces podemos encontrar y manipular la variable sin conocer su nombre.
En esta sección, aprenderemos sobre varias operaciones básicas de los arrays.
Puntos de conocimiento:
- Definición de array
- Inicialización de array
- Recorrido de array
- Características de los elementos de array
Definición de Array
¿Cómo definimos un array?
Recordemos la situación cuando aprendimos sobre variables. ¿Cómo definimos una variable int?
var a int
Es decir:
var variable_name variable_type
De manera similar, podemos definir un array de int de la siguiente manera:
var a [10]int
Es decir:
var variable_name [number_of_elements]variable_type
De esta manera, hemos definido un array básico de int llamado a con una capacidad de 10.
Lista de Inicialización
Después de entender cómo definir un array, aprendamos cómo inicializar un array.
Al inicializar un array, podemos usar una lista de inicialización para establecer los valores iniciales de los elementos del array.
Crea un archivo array.go en el directorio ~/project:
cd ~/project
touch array.go
Escribe el siguiente código en array.go:
package main
import "fmt"
func main() {
// Automatically initialized to the zero value of the element type
var simpleArray [3]int
// Initialize with specified initial values, and use the zero value to fill in the missing elements
var numArray = [3]int{1, 2}
// Initialize with specified initial values
var cityArray = [2]string{"London", "Chengdu"}
fmt.Println(simpleArray) // [0 0 0]
fmt.Println(numArray) // [1 2 0]
fmt.Println(cityArray) // [London Chengdu]
}
Ejecuta el código:
go run ~/project/array.go
Salida esperada:
[0 0 0]
[1 2 0]
[London Chengdu]
El código anterior demuestra tres formas de especificar valores iniciales usando una lista de inicialización:
- Sin pasar una lista: Inicializar al valor cero del tipo de elemento
- Pasando una lista parcial: Inicializar los elementos especificados con los valores especificados y los elementos restantes al valor cero
- Pasando una lista completa: Inicializar con los valores especificados
Ten en cuenta que si la longitud de la lista pasada es mayor que el número de elementos del array, el código no se compilará.
Inicialización con longitud inferida
Al inicializar un array utilizando una lista de inicialización, debes asegurarte de que la cantidad de valores iniciales proporcionados sea menor o igual al número de elementos.
En general, puedes confiar en el compilador para inferir la longitud del array basado en los valores iniciales.
Modifica el archivo array.go de la siguiente manera:
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
}
Ejecuta el código:
go run ~/project/array.go
Salida esperada:
[0 0 0]
[1 2]
The type of numArray is: [2]int
[London Chengdu]
The type of cityArray is: [2]string
Inicialización con índices especificados
A veces, es posible que queramos asignar valores iniciales específicos a ciertas posiciones en un array, independientemente de si usamos una lista de inicialización o inferimos la longitud.
Modifica el archivo array.go de la siguiente manera:
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
}
Ejecuta el código:
go run ~/project/array.go
Salida esperada:
[0 1 0 5]
The type of array a is: [4]int
El código anterior especifica los valores iniciales de los elementos con índices 1 y 3 como 1 y 5, respectivamente. También utiliza el método de inicialización con inferencia de longitud, que debes aprender.
Nota: En informática, el índice comienza desde 0.
Recorrido de Array
A veces, necesitamos acceder a cada elemento de un array y realizar operaciones en ellos uno por uno.
Aquí, introducimos dos formas de recorrer arrays:
Escribe el siguiente código en 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])
}
}
Ejecuta el código:
go run ~/project/array.go
Salida esperada:
Traversing the array using range
0 123
1 321
2 456
3 777
Traversing the array using indices
123
321
456
777
Ambos métodos anteriores se pueden utilizar para recorrer todo el array.
Acceso a elementos de array
Para acceder a un elemento específico en un array, que es esencialmente una variable, utilizamos el índice.
Al igual que en la mayoría de los lenguajes de programación, el índice de un array comienza desde 0, y el índice del último elemento es len-1.
Si se utiliza un índice mayor que este límite en el código, se producirá un error de acceso fuera de los límites (out-of-bounds error).
Para acceder al i-ésimo elemento del array a, puedes utilizar la siguiente notación:
a[i]
Es decir:
array_name[index_of_element]
Tipo de valor de los arrays
Los arrays son tipos de valor; asignar un array o pasar un array como parámetro copiará todo el array. En otras palabras, se modificarán los valores de la copia, no del array original.
Escribe el siguiente código en 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]
}
Ejecuta el código:
go run ~/project/array.go
La salida será:
[10 20 30]
A partir del código anterior, se puede ver que cuando se pasa el array a a la función modifyArray, en realidad solo se pasa una copia de su array original.
Cambiar el valor del array x en la función no afecta al array original a.
Resumen
En este laboratorio, aprendimos:
- Cómo definir un array
- Tres métodos de inicialización de arrays
- Características de los arrays y cómo acceder a sus elementos
Los arrays no se utilizan comúnmente en el desarrollo real, pero son la base para aprender estructuras de datos comunes en Go.
Espero que todos los Gophers (desarrolladores de Go) practiquen diligentemente y aprendan a aplicar lo que han aprendido.
