Navega por la tabla de contenido
Una de las estructuras de datos más útiles en informática es la tabla hash. Existen muchas implementaciones de tablas hash con propiedades variables, pero en general ofrecen búsquedas, adiciones y eliminaciones rápidas. Go proporciona un tipo de mapa integrado que implementa una tabla hash.
Tabla hash
Es una estructura de datos no lineal cuyo propósito final se centra en llevar a cabo las acciones básicas (inserción, eliminación y búsqueda de elementos) en el menor tiempo posible, mejorando las cotas de rendimiento respecto a un gran número de estructuras.
- Los mapas se utilizan para almacenar valores de datos en pares
key
:value
. - Cada elemento de un mapa es un par de
key
:value
. - Un mapa es una colección desordenada y modificable que no permite duplicados.
- La longitud de un mapa es el número de sus elementos. Este dato lo puedes obtener también utilizando la función
len()
. - El valor predeterminado de un mapa es
nil
. - Los mapas contienen referencias a una tabla hash subyacente.
- Go tiene varias formas de crear mapas.
La clave de asignación puede ser de cualquier tipo de datos para el que se haya definido el operador de igualdad.
- Booleanos (Booleans)
- Números (Numbers)
- Cadenas (Strings)
- Matrices (Arrays)
- Punteros (Pointers)
- Estructuras (Structs)
- Interfaces (siempre que el tipo dinámico admita la igualdad)
Los tipos de clave no válidos son:
- Rebanadas (Slices)
- Mapas (Maps)
- Funciones (Functions)
Estos tipos no son válidos porque el operador de igualdad () no está definido para ellos.
Los valores del mapa pueden ser de cualquier tipo.
Un tipo de mapa Go tiene el siguiente aspecto:
map[KeyType]ValueType
package main
import (
"fmt"
)
func main() {
var mapa map[string]string
fmt.Println(mapa)
}
go run declaration.go
#Output
map[]
Se inicializan dos mapas, el primero que está constituido como string tanto la clave como el valor. El segundo está definido para que la clave sea de string y los valores, numéricos enteros (int).
package main
import (
"fmt"
)
func main() {
var a = map[string]string{
"Username": "jersonmartinez",
"Name": "Jerson Antonio",
"Lastname": "Martínez Moreno",
}
b := map[string]int{
"Day": 6,
"Month": 4,
"Year": 1996,
"Magic number": 9,
}
fmt.Printf("a = \t%v\n", a)
fmt.Printf("b = \t%v\n", b)
}
go run initialization.go
# Output
a = map[Lastname:Martínez Moreno Name:Jerson Antonio Username:jersonmartinez]
b = map[Day:6 Magic number:9 Month:4 Year:1996]
package main
import (
"fmt"
)
func main() {
var a = make(map[string]string)
a["Username"] = "jersonmartinez"
a["Name"] = "Jerson Antonio"
a["Lastname"] = "Martínez Moreno"
b := make(map[string]int)
b["Day"] = 6
b["Month"] = 4
b["Year"] = 1996
b["Magic number"] = 9
fmt.Printf("a = \t%v\n", a)
fmt.Printf("b = \t%v\n", b)
}
go run initialization_with_make.go
# Output
a = map[Lastname:Martínez Moreno Name:Jerson Antonio Username:jersonmartinez]
b = map[Day:6 Magic number:9 Month:4 Year:1996]
Una vez creado al mapa, la forma de acceder es la misma que la de un arreglo; por medio del índice en la variable que contiene el mapa, ya sea que este índice sea compuesto de caracteres o numérica (depende de cómo se define el mapa). Observa el siguiente ejemplo donde se almacenan 3 datos y se imprimen dichos datos.
package main
import (
"fmt"
)
func main() {
var a = make(map[string]string)
a["Username"] = "jersonmartinez"
a["Name"] = "Jerson Antonio"
a["Lastname"] = "Martínez Moreno"
fmt.Printf("Your Username is: " + a["Username"] + "\n")
fmt.Printf("Your Name is: " + a["Name"] + "\n")
fmt.Printf("Your Lastname is: " + a["Lastname"])
}
go run get_data.go
# Output
Your Username is: jersonmartinez
Your Name is: Jerson Antonio
Your Lastname is: Martínez Moreno
package main
import (
"fmt"
)
func main() {
// Create a map
var a = map[string]string{
"Username": "jersonmartinez",
"Name": "Jerson Antonio",
"Lastname": "Martínez Moreno",
}
fmt.Printf("=> Mapa inicial\n")
fmt.Printf("Your Username is: " + a["Username"] + "\n")
fmt.Printf("Your Name is: " + a["Name"] + "\n")
fmt.Printf("Your Lastname is: " + a["Lastname"] + "\n\n")
// Change values of the map
a["Username"] = "CoreStack"
a["Name"] = "Antonio"
a["Lastname"] = "Moreno"
fmt.Printf("=> Mapa modificado\n")
fmt.Printf("Your Username is: " + a["Username"] + "\n")
fmt.Printf("Your Name is: " + a["Name"] + "\n")
fmt.Printf("Your Lastname is: " + a["Lastname"])
}
go run change_values.go
# Output
=> Mapa inicial
Your Username is: jersonmartinez
Your Name is: Jerson Antonio
Your Lastname is: Martínez Moreno
=> Mapa modificado
Your Username is: CoreStack
Your Name is: Antonio
Your Lastname is: Moreno
package main
import (
"fmt"
)
func main() {
// Create a map
var User = map[string]string{
"Username": "jersonmartinez",
"Name": "Jerson Antonio",
"Lastname": "Martínez Moreno",
}
// Add element
User["Age"] = "26"
// Add other element
User["Career"] = "DevOps Engineer"
fmt.Printf("Your Username is: " + User["Username"] + "\n")
fmt.Printf("Your Name is: " + User["Name"] + "\n")
fmt.Printf("Your Lastname is: " + User["Lastname"] + "\n")
// New elements
fmt.Printf("Your Age is: " + User["Age"] + "\n")
fmt.Printf("Your Career is: " + User["Career"] + "\n\n")
}
go run add_element.go
# Output
Your Username is: jersonmartinez
Your Name is: Jerson Antonio
Your Lastname is: Martínez Moreno
Your Age is: 26
Your Career is: DevOps Engineer
Go tiene una función integrada (delete()
), que elimina un elemento respecto a la clave especificada en un mapa. Si la clave no está disponible en el mapa, la eliminación no es operativa; en caso de que exista la clave, este la elimina del mapa.
package main
import (
"fmt"
)
func main() {
// Create a map
var User = map[string]string{
"Username": "jersonmartinez",
"Name": "Jerson Antonio",
"Lastname": "Martínez Moreno",
}
// Add element
User["Age"] = "26"
// Add other element
User["Career"] = "DevOps Engineer"
fmt.Printf("Your Username is: " + User["Username"] + "\n")
fmt.Printf("Your Name is: " + User["Name"] + "\n")
fmt.Printf("Your Lastname is: " + User["Lastname"] + "\n")
// Delete element "Age" key of the map "User".
delete(User, "Age")
// New elements
fmt.Printf("Your Age is: " + User["Age"] + "\n")
fmt.Printf("Your Career is: " + User["Career"] + "\n\n")
}
go run remove_element.go
# Output
Your Username is: jersonmartinez
Your Name is: Jerson Antonio
Your Lastname is: Martínez Moreno
Your Age is:
Your Career is: DevOps Engineer
Se recorre un mapa por medio de iteraciones en sus elementos. Usando la estructura repetitiva for
.
package main
import (
"fmt"
)
func main() {
// Create a map
var User = map[string]string{
"Username": "jersonmartinez",
"Name": "Jerson Antonio",
"Lastname": "Martínez Moreno",
}
// Looping through the map
for key, value := range User {
fmt.Printf("The %s is: %s \n", key, value)
}
}
go run looping_through.go
# Output
The Username is: jersonmartinez
The Name is: Jerson Antonio
The Lastname is: Martínez Moreno
Es posible realizar un conjunto de validaciones en los elementos que integran el mapa. Si solo desea comprobar la existencia de una determinada clave, puede usar el identificador en blanco (_
) en lugar de la variable que almacena el valor.
package main
import "fmt"
func main() {
// Create a map
var User = map[string]string{
"Username": "jersonmartinez",
"Name": "Jerson Antonio",
"Lastname": "Martínez Moreno",
"Age": "",
}
// Check if exists key and its value
k1, v1 := User["Username"]
// Check if non-exists key and its value
k2, v2 := User["Phone"]
// Check if exists key and its value
k3, v3 := User["Age"]
// Only check if exists key and not its value
_, v4 := User["Name"]
fmt.Println(k1, v1)
fmt.Println(k2, v2)
fmt.Println(k3, v3)
fmt.Println(v4)
}
go run check_specific_elemetns.go
# Output
jersonmartinez true
false
true
true
Se ha podido introducir Mapas en Go, pasando por su concepto, características, tipos de clave permitidos y de valores permitidos. Además, por medio de ejercicios, aprendes a declarar un mapa, inicializar, acceso a elementos, cambiar valores, agregar elementos, eliminar y recorrer los elementos, asimismo, también verificar dichos elementos.