No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Llave valor con Maps

20/36
Recursos

Aportes 26

Preguntas 11

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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.

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

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

para eliminar un elemento nada m谩s es con delete: delete(m, 鈥淧epito鈥)

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

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 (
鈥渇mt鈥
鈥渟trings鈥
)

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(鈥淥ro鈥)
isPalindromo(鈥渁mor鈥)
isPalindromo(鈥淎ra鈥)
}

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

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

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