No tienes acceso a esta clase

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

Llave valor con Maps

20/36
Recursos

Aportes 17

Preguntas 7

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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

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

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