Llave valor con Maps

JSON tu me escuchas?

También es posible declarar un nuevo map de esta forma:

temperature := map[string]int{
		"Earth": 15,
		"Mars":  -65,
	}

Hay que recordar que los json, diccionaros, maps no son más que un hash map así que sin importar el nombre tienen el mismo uso y funcionamiento

La estructura de datos MAP son más eficientes que los Array o Slices, ya que usan de forma nativa concurrencia para ejecutar las operaciones.

Mis apuntes 😄

Maps - Geeks for Geeks

Maps - Go Blog

package main

import "fmt"

func main() {
	//MAPS

	//Declaration
	var map_1 = map[string]int32{
		"Car":      50000,
		"House":    20000,
		"Computer": 1000,
	}

	fmt.Println(map_1)

	//Another type of declaration
	map_2 := make(map[int]int)
	map_2[10] = 1
	map_2[12] = 4
	map_2[8] = 5
	map_2[11] = 2

	//Displaying a map
	for i, v := range map_2 {
		fmt.Println(i, "=", v) //There is no order at the momento of displaying a map
	}

	//Knowing if a value exist
	//If we display map_1["Car"] it will show the value
	value := map_1["Car"]
	fmt.Println(value)

	//But what if it doesn't exist
	value = map_1["aasd"]
	fmt.Println(value) //It will show zero

	value, ok := map_1["aasd"] //If we want to know if it exists, it must be done with the second returing value
	//it will return a bool depending on if exists or not
	fmt.Println(value, ok)
}

😎

package main

import "fmt"

func main() {
	m := make(map[string]int)

	m["Jose"] = 14
	m["Pepito"] = 20

	value, ok := m["Jose"]
	fmt.Println(value, ok)
}

para eliminar un elemento nada más es con delete: delete(m, “Pepito”)

Ejemplo de uso [maps]:

Se diseñó una pequeña BD de nombre usuario. Esta base de datos contiene cuatro índices donde llaves son nombres y valores respectivamente la edad del usuario. Entonces:

var usuario = map[string]int{
    "Luis"    : 17,
    "Micaela" : 18,
    "Ian"     : 16,
    "Jorge"   : 22,
}

Realizamos un bucle sujeto a la condición de que si la edad del usuario es mayor o igual a 18, indique junto al nombre del usuario, un mensaje que afirme dicha cumplida condición. De lo contrario, que indique que este no es mayor de edad:

// [...]
func main(){
  for nombre, edad := range usuario{
    if edad >= 18{
      fmt.Printf("%s es mayor de edad \n", nombre)
    }else{
      fmt.Printf("%s es menor de edad \n", nombre)
    }
  }
}

Que comportamiento tan raro tener que usar una segunda variable para saber si el dato no existe en el map

La clase en código:

package main

import "fmt"

func main() {

	fmt.Println()
	fmt.Println("====================================================")
	fmt.Println("Llave valor con Maps (también llamados diccionarios)")
	fmt.Println("====================================================")
	fmt.Println()

	fmt.Println("Forma recomendada de inicializar el Map:\nmapConMake := make(map[string]int)")
	mapConMake := make(map[string]int)
	fmt.Println("Impresion:", mapConMake)

	fmt.Println()
	fmt.Println("Hay otro par de formas de inicializar que quedan en el código después de este comentario.")
	fmt.Println()

	var mapInicializado2Pasos map[string]int
	mapInicializado2Pasos = map[string]int{"init": -1}

	mapInicializado1Paso := map[string]int{"abc": 1}
	fmt.Println("Ejemplo: mapInicializado1Paso=", mapInicializado1Paso)
	fmt.Println()

	fmt.Println("La asignación de valores es tan sencillo como:\nmapInicializado2Pasos[\"valor_wan\"] = 1")
	fmt.Println()

	mapInicializado2Pasos["valor_wan"] = 1
	mapInicializado2Pasos["valor_two"] = 2

	fmt.Println()
	fmt.Println("La impresión directa del Map muestra los pares key-value separados por un espacio vacío de los demás:\n", mapInicializado2Pasos)
	fmt.Println()

	fmt.Println("Para recorrer el Mapa se puede usar el FOR-range, igual que con los slices:")
	fmt.Println()

	fmt.Println("for indice, valor := range mapInicializado2Pasos { fmt.Println(\"clave-valor >>>\", indice, valor) }")
	fmt.Println()

	fmt.Println("Lo que imprime:")
	fmt.Println()

	for indice, valor := range mapInicializado2Pasos {

		fmt.Println("clave-valor >>>", indice, valor)
	}

	fmt.Println()
	fmt.Println("Nota: La ejecución anterior es concurrente, por lo que la info no se imprime en órden.")
	fmt.Println()

	fmt.Println("Extraer un valor solo es cuestión de hacer:")
	fmt.Println("mapInicializado2Pasos[\"valor_wan\"]\nque da el valor:", mapInicializado2Pasos["valor_wan"])
	fmt.Println()

	fmt.Println("Si no existe nada en el mapa para el 'key' simplemente se devuelve un 'zero value'.")
	fmt.Println()

	fmt.Println("Hay una forma mas certera, booleana para saber si existe o no el valor:")
	fmt.Println("valor, existe := mapInicializado2Pasos[\"key_falsa\"]")
	fmt.Println()

	valor, existe := mapInicializado2Pasos["key_falsa"]

	fmt.Printf("Lo que entrega: valor=%d, existe=%t", valor, existe)
	fmt.Println()
	fmt.Println()
}

El orden de los maps al iterarlo no es el mismo con el que se declara por la concurrencia de acceso a esos valores. Solución: https://stackoverflow.com/questions/18342784/how-to-iterate-through-a-map-in-golang-in-order/18342865

Clase 20: Llave valor con Maps

Los maps/hash son más eficientes según el caso de uso, si conoces el KEY siempre será más eficiente usar un MAP, debido a que el tiempo de acceso es EN PROMEDIO constante (O(1)) para todos los keys independientemente del tamaño del MAP.

• Map son diccionarios en GO

• Se usa para manejar valores constantes

• Hay que tener cuidado con el recorrido ya que es concurrente se puede ejecutar de forma aleatoria

• Si solo necesitas iterar sobre un conjunto de elementos, siempre es mejor alternativa usar un Array.

• Usa concurrencia de manera nativa

• Arrays y Hashes, son bastante similares en memoria, los hashes son en resumen un hack para crear arreglos en los que podemos definir un KEY distinto a un índice entero.

• Este es un muy buen artículo para conocer más de los hashes, aunque usa Python para los ejemplos: Articulo

Fuente:
Víctor Hugo Villalobos Balzán

//Declaración  1 Forma 
temperature := map[string]int{
		"Earth": 15,
		"Mars":  -65,
	}


// Declaración forma 2 
m:= make(map[string]int)
m["Jose"] = 25
m["Maria"] = 20

fmt.Println(m)

for i, v := range m{
	fmt.Println(i,v)
}

//Encotrar vaor 

value, ok := m[Josep]
fmt.Println(value, ok)

Los maps son más eficientes que los arrays y slices** ya que nativamente implementan concurrencia** para interactuar con las operaciones que se hacen con el map, por lo tanto, no debemos preocuparnos por el orden en que se ingresaron los datos, más bien debemos preocuparnos porque la dupla KEY,VALUE exista o no y en base a eso hacer operaciones con los elementos del map.

package main

import (
“fmt”
“strings”
)

func isPalindromo(text string) {
var textReverse string

for i := len(text) - 1; i >= 0; i-- {
	textReverse += string(text[i])
}
if strings.ToLower(textReverse) == strings.ToLower(text) {
	fmt.Println(text, " Es un palíndromo")
} else {
	fmt.Println(text, " No es un palíndromo")
}

}

func main() {
isPalindromo(“Oro”)
isPalindromo(“amor”)
isPalindromo(“Ara”)
}

package main

import "fmt"

func main() {
	m := make(map[string]int)

	m["Jose"] = 14
	m["Pepito"] = 20

	fmt.Println(m)


	// Recorrer un map
	for i, v := range m {
		fmt.Printf("%s tiene %d años\n", i, v)
	}

	// Encontrar un valor
	value, ok := m["Jose"]
	fmt.Println(value, ok)
}

Si pueden quitar los bordes innecesarios del vídeo. Se les agradecería. El curso está excelente, pero esos bordes son molestos debido a que el código se ve mucho más pequeño. Salidos

Best Maps

Nota:
La variable ok es solo una variable, que por lo que entiendo por estandar de la comunidad la usan para dicho caso, pero al testear puedes validar que con cualquier otra varible obtiene el resultado:

people := map[string]int{}
	fmt.Println(people)

	people["Monteria"] = 60000
	people["Medellin"] = 50000
	people["Manizales"] = 80000
	people["Motonui"] = 10000
	fmt.Println(people)

_, ok := people["Cartagena"]
	fmt.Println("Is present Cartegena on the Map", ok)

	_, d := people["Medellin"]
	fmt.Println("Is present Medellin on the Map", d)

Nota:
El map hace un index desde el mismo instante de la creacion, ya que segun se aprecia, hace un ordenamiento alfabetico apartir de la Key

poblacion["Monteria"] = 60000
	poblacion["Medellin"] = 50000
	poblacion["Manizales"] = 80000
	poblacion["Motonui"] = 10000
	fmt.Println(poblacion)

map[Manizales:80000 Medellin:50000 Monteria:60000 Motonui:10000]

Tal como lo muestran el map la KEY es de un sólo tipo, pero el VALUE también es de un sólo tipo. Pero un JSON, puede tener en el VALUE distintos tipos, aunque es verdad que todo se podría manejar como string.

Reto clase anterior

package main

import (
	"fmt"
	"strings"
)

// Funcion para validar palabras palindromas
func esPalindromo(texto string) {
	var textoAlrevez string

	for i := len(texto) - 1; i >= 0; i-- {
		textoAlrevez += string(texto[i])
	}
	if strings.ToLower(texto) == strings.ToLower(textoAlrevez) {
		fmt.Println("Es palindromo")
	} else {
		fmt.Println("No es un palindromo")
	}
}

func main() {
	
	//Ejemplo palindromo
	esPalindromo("Ama")
}

El llamado interno de los valores del map sucede de forma concurrente, siendo más rápido, pero en orden aleatorio.

Son más eficientes que Arrays & slices por la concurrencia interna de los maps

Estructura de datos llave, valor -> (en python son dict (diccionarios) en GO son maps (mapas))

la función make(), se usa para la creación de colecciones o estructuras de datos.

Los mapas siguen la siguiente estructura:

map[key]value

donde se definen el tipo de datos de la llave y el valor:

map[string]int

De esta forma se instancia un mapa:

m := make(map[string]int)

Agregando valores:

m["jose"] = 15
m["Hector"] = 12

Recorriendo un mapa:

for key, value := range (m) {
	fmt.Println(key, value)
}

package main

import "fmt"

func main() {
	m := make(map[string]int)

	m["Jose"] = 14
	m["Pepito"] = 20

	fmt.Println(m)

	//Recorrer map
	for i, v := range m {
		fmt.Println(i, v)
	}

	//Encontrar valor
	value := m["Jose"]
	fmt.Println(value)

	//Retornar si la llave esta en el diccionario
	valor, ok := m["Josep"]
	fmt.Println(valor, ok)

	valor, ok = m["Pepito"]
	fmt.Println(valor, ok)
}

Saber si es un palíndromo

// Reverse text
func reverse(text string) string {
	var textReverseString string
	for i := len(text) - 1; i >= 0; i-- {
		textReverseString += string(text[i])
	}
	return textReverseString
}

func isPalindrome(text string) bool {
	text = strings.ToLower(text)
	text = strings.ReplaceAll(text, " ", "")
	reverseText := reverse(text)
	reverseText = strings.ReplaceAll(reverseText, " ", "")
	return text == reverseText
}

func main(){
	text := "Pollo o ollo P"
	// Verificar si es un Palindromo
	fmt.Printf("¿%s ,es un Palíndromo?: %v\n", text, isPalindrome(text))
}

😎

Interesante