Llave valor con Maps

JSON tu me escuchas?

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

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

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

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.

😎

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)
}

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()
}

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)
    }
  }
}

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”)
}

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

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)
}

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

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

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