JSON tu me escuchas?
Hola mundo en Go
Introducción al Curso de Golang
¿Qué es, por qué y quienes utilizan Go?
Instalar Go en Linux
Instalar Go en Mac
Instalar Go en Windows
Nuestras primeras líneas de código con Go
Variables, funciones y documentación
Variables, constantes y zero values
Operadores aritméticos
Tipos de datos primitivos
Paquete fmt: algo más que imprimir en consola
Uso de funciones
Go doc: La forma de ver documentación
Estructuras de control de flujo y condicionales
El poder de los ciclos en Golang: for, for while y for forever
Operadores lógicos y de comparación
El condicional if
Múltiple condiciones anidadas con Switch
El uso de los keywords defer, break y continue
Estructuras de datos básicas
Arrays y Slices
Recorrido de Slices con Range
Llave valor con Maps
Structs: La forma de hacer clases en Go
Modificadores de acceso en funciones y Structs
Métodos e interfaces
Structs y Punteros
Stringers: personalizar el output de Structs
Interfaces y listas de interfaces
Concurrencia y Channels
¿Qué es la concurrencia?
Primer contacto con las Goroutines
Channels: La forma de organizar las goroutines
Range, Close y Select en channels
Manejo de paquetes y Go Modules
Go get: El manejador de paquetes
Go modules: Ir más allá del GoPath con Echo
Modificando módulos con Go
Despedida del curso
Despedida
Bonus
Cheat Sheet Go
Librerías para desarrollo web con Go
Data Science con Go
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 17
Preguntas 7
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()
}
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 losmaps
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)
m["jose"] = 15
m["Hector"] = 12
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
Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.