Maps

Clase 19 de 42 • Curso Práctico de Go: Creación de un Servidor Web

Clase anteriorSiguiente clase

Carlos Javier Bazan Huaman

student•

se ven muy útiles los mapas usando punteros para relacionar los valores ya trabajados anteriormente.

Jean Nuñez

student•

No solo utiles sino que te dan altura como programador, te hace ver como develop level 7 o senior

Juan David Rueda Quiroga

student•

Además que en prácticamente todos los lenguajes los usan y son muy útiles

Usuario anónimo

user•

Super.. yo recorri el map con un for :) menos codigo

for key, value := range mapTasks {
	fmt.Println("Integrante ", key)
	value.listTasks()
}

Waldo Araque

student•

interesante, excelente aporte, veo que en Go se repite mucho código... Cosa que no me gusta pero bueno. Gracias! Más aportes así!

Santiago Mendoza

student•

Hola. Creo que aún no he comprendido bien la diferencia entre los operadores := y =. Crees que puedes hacer un comentario sobre su diferencia? cuándo debo usar := y cuándo =?

Pilar Mass

student•

Hola ! Hay 3 cosas a tener en cuenta

Una es solamente declaración de una variable: la cual se hace de la forma Ej x int
Declaración e inicialización de una variable Ej x:= 5 , en esta forma no se necesita especificar el tipo de variable a diferencia del punto 1
Resignación de variable: que es cuando la variable ya existe (ya está declarada) y lo único que se necesita es cambiarle el valor con un = Ej 1 x int //Declaro x x = 2 // x ahora vale 2 Ej 2 x := 3 //Declaro e inicializo x vale 3 x = 5 // Reasigno el valor de x , x ahora vale 5

Murray Walker Greer Cifuentes

student•

hola, con := declaras una variable y con = asignas un valor

para poder asignar un valor a una variable, primero debes declarar esa variable indicandole de que tipo es y qué puede aceptar como valor.

:= es la manera corta de hacer esto: var a string = "initial"

una vez que declaras una variable como string no puedes ponerle valores con números ni otra cosa...

Alejandro Carballo

student•

Como guardo los items que tengo en mi struct en un map?

Adrian Morfi

student•

Buenas @alejocarballo,

entiendo que lo que quieres es tener instanciados una serie de "Items" dentro de un map.

Se hace de la siguiente manera:

package main

import (
	"fmt"
	"time"
)

type Item struct {
	ID          int
	Name        string
	Description string
	Created     time.Time
	Updated     time.Time
	Deleted     time.Time
}

func main() {
	
	//Creacion del objeto
	mapObject := make(map[string]Item)
	
	//Instanciacion de tus objetos
	mapObject["Item_0"] = Item{ID: 0, Name: "Item 0", Description: "This is Item 0", Created: time.Now(), Updated: time.Now(), Deleted: time.Now()}
	mapObject["Item_1"] = Item{ID: 1, Name: "Item 1", Description: "This is Item 1", Created: time.Now(), Updated: time.Now(), Deleted: time.Now()}
	mapObject["Item_2"] = Item{ID: 2, Name: "Item 2", Description: "This is Item 2", Created: time.Now(), Updated: time.Now(), Deleted: time.Now()}
	mapObject["Item_3"] = Item{ID: 3, Name: "Item 3", Description: "This is Item 3", Created: time.Now(), Updated: time.Now(), Deleted: time.Now()}
	mapObject["Item_4"] = Item{ID: 4, Name: "Item 4", Description: "This is Item 4", Created: time.Now(), Updated: time.Now(), Deleted: time.Now()}

	for i := 0; i < len(mapObject); i++ {
		fmt.Println(mapObject[fmt.Sprint("Item_", i)])
	}

}
```

Espero te sirva!

Andres Pinzon

student•

Para los que van arrancando a codear con este tema de maps y en GO.

Los mapas son muy importantes por una sencilla razón, te permite almacenar información y luego consultarla en tiempo constante.

Es decir si tú tienes una lista con números únicos por ejemplo, para encontrar un número, debes hacer un for e ir comparando hasta encontrar el correcto.

Con un mapa tú ya sabes la key específica y la memoria sabe donde está ese pedacito de información, así que irá de una y te regresará el dato que buscabas.

Fernando Alberto Velasquez Aguilera

student•

package main

import (
	"fmt"
)

type task struct {
	nombre string
	descripcion string
	completado bool
}

type taskList struct {
	tasks []*task
}

func (t *taskList) agregarLista( tl *task){
		t.tasks = append(t.tasks, tl)
}

func (t *taskList) eliminarDelista(index int){
	t.tasks = append(t.tasks[:index], t.tasks[index + 1:]...)
}

func (t *task) marcarCompleta() {
	t.completado = true
}
func (t *task) actualizarDescripcion(descripcion string)  {
	t.descripcion = descripcion
}
func (t *task) actualizarNombre(nombre string)  {
	t.nombre = nombre
}

func (t *taskList) imprimirListaCompletados(){

	
	for _, tarea := range t.tasks {

		if tarea.completado{
			fmt.Println("---------------------------------------------------------")
			fmt.Println("Nombre:",  tarea.nombre)
			fmt.Println("Descripcion:",  tarea.descripcion)
			fmt.Println("---------------------------------------------------------")
		
		}
	}
}

func (t *taskList) imprimirLista(){

	for _, tarea := range t.tasks {
		fmt.Println("---------------------------------------------------------")
		fmt.Println("Nombre:",  tarea.nombre)
		fmt.Println("Descripcion:",  tarea.descripcion)
		fmt.Println("---------------------------------------------------------")
	
	}
}

func main(){
	t1 := &task {
		nombre: "Completar mi curso de GO",
		descripcion: "Completar mi curso de go esta semana",
	}
	t2 := &task {
		nombre: "Completar mi curso de PHP",
		descripcion: "Completar mi curso de PHP esta semana",
	}
	t3 := &task {
		nombre: "Completar mi curso de Linux",
		descripcion: "Completar mi curso de Linux esta semana",
	}

	lista := &taskList{
		tasks: []*task {
			t1, t2, t3,
		},
	}
	lista.agregarLista(t3)
	lista.imprimirLista()
	lista.tasks[0].marcarCompleta()
	fmt.Println("LISTAS COMPLETADAS")
//	lista.imprimirListaCompletados()

mapaTareas := make(map[string]*taskList)

mapaTareas["Fernando"] = lista



t4 := &task {
	nombre: "Completar mi curso de Seguridad",
	descripcion: "Completar mi curso de Seguridad esta semana",
}
t5 := &task {
	nombre: "Completar mi curso de Nodejs",
	descripcion: "Completar mi curso de Nodejs esta semana",
}
lista2 := &taskList{
	tasks: []*task {
		t4, t5, 
	},
}


mapaTareas["foxxfiles"] = lista2
fmt.Println("Tareas de foxxfiles")
mapaTareas["foxxfiles"].imprimirLista()
}```

IfElse Group

student•

Para el caso en la que estamos usando el map para la listas de tareas. No es necesario el puntero, si sólo vamos a imprimir sus valores. En caso de que tomemos esa lista de tareas para modificarla, si seria útil. Estoy entendiendo bien el conceptos de punteros?

Jorge Quevedo

student•

Una consulta, existe el tipo de dato "object" en go? Como sucede en java

Fredy Red Ramos Pomari

student•

Hasta donde tengo entendido en go no existe el tipo Object

Avelino Sánchez

student•

No existe como tal un Object por ser multiparadigma y no completamente orientado a objetos. No sé cual sea el comportamiento que buscas replicar, pero algo que te podría servir es el uso de interface{} de manera genérica. Lo puedes usar para solicitar parámetros o para definir tipos. Esto sería similar como cuando en Java define algo únicamente como Object y recibir básicamente lo que sea.

func foo(i interface{}) {
    // some code ...
    map[string]interface{}
}

Leandro World

student•

package main

import "fmt"

func main() {
	// Crear mapa
	m1 := make(map[string]int)
	// Asignar valor
	m1["a"] = 8
	// Imprimir
	fmt.Println(m1)
	// Consultar valor por llave
	fmt.Println(m1["a"])
}

Julián David

student•

package main

import (
	"fmt"
)

type task struct {
	nombre      string
	descripcion string
	completado  bool
}

type taskList struct {
	tasks []*task
}

func (t *task) marcarCompleta() {
	t.completado = true
}
func (t *task) actualizarDescripcion(descripcion string) {
	t.descripcion = descripcion
}
func (t *task) actualizarNombre(nombre string) {
	t.nombre = nombre
}
func (tl *taskList) agregarLista(t *task) {
	tl.tasks = append(tl.tasks, t)
}

func (tl *taskList) agregarListaConIndice(t *task, index int) {
	tl.tasks = append(tl.tasks[:index], append([]*task{t}, tl.tasks[index:]...)...)
}

func (tl *taskList) eliminarDelista(index int) {
	tl.tasks = append(tl.tasks[:index], tl.tasks[index+1:]...)
}

func (tl *taskList) imprimirListaCompletados() {
	for _, tarea := range tl.tasks {
		if tarea.completado {
			fmt.Println("*******************************************************")
			fmt.Println("Nombre:", tarea.nombre)
			fmt.Println("Descripcion:", tarea.descripcion)
			fmt.Println("*******************************************************")

		}
	}
}

func (tl *taskList) imprimirLista() {
	for _, tarea := range tl.tasks {
		fmt.Println("*******************************************************")
		fmt.Println("Nombre:", tarea.nombre)
		fmt.Println("Descripcion:", tarea.descripcion)
		fmt.Println("Completado:", tarea.completado)
		fmt.Println("*******************************************************")
	}
}

func (tl *taskList) getIndice(t *task) int {
	for i, tarea := range tl.tasks {
		if tarea == t {
			return i
		}
	}
	return -1
}

func main() {
	t1 := &task{
		nombre:      "Completar mi curso de go",
		descripcion: "Completar mi curso de go esta semana",
	}
	t2 := &task{
		nombre:      "Completar mi curso de git",
		descripcion: "Completar mi curso de git este mes",
	}
	t3 := &task{
		nombre:      "Completar mi curso de sql",
		descripcion: "Completar mi curso de sql la otra semana",
	}

	lista := &taskList{
		tasks: []*task{
			t1, t2,
		},
	}

	lista.agregarLista(t3)
	lista.tasks[lista.getIndice(t3)].marcarCompleta()

	mapaTareas := make(map[string]*taskList)

	mapaTareas["Fernando"] = lista

	t4 := &task{
		nombre:      "Completar mi curso de Seguridad",
		descripcion: "Completar mi curso de Seguridad esta semana",
	}
	t5 := &task{
		nombre:      "Completar mi curso de Nodejs",
		descripcion: "Completar mi curso de Nodejs esta semana",
	}

	lista2 := &taskList{
		tasks: []*task{
			t4, t5,
		},
	}

	t6 := &task{
		nombre:      "Completar mi curso de Python",
		descripcion: "Completar mi curso de Python esta semana",
	}

	lista2.agregarListaConIndice(t6, 1)

	t6.marcarCompleta()

	mapaTareas["foxxfiles"] = lista2

	fmt.Println("Tareas de Fernando")
	mapaTareas["Fernando"].imprimirLista()
	
	fmt.Println("Tareas de foxxfiles")
	mapaTareas["foxxfiles"].imprimirLista()

	fmt.Println("LISTAS COMPLETADAS")
	lista.imprimirListaCompletados()

}

Juan Pablo Meza Gazabón

student•

Hello there, this is my code version of the exercise

package main

import "fmt"

type Task struct {
	name        string
	description string
	done        bool
}

type TaskList struct {
	tasks []*Task
}

func (t *TaskList) AddTask(task *Task) {
	t.tasks = append(t.tasks, task)
}

// remove task
func (t *TaskList) RemoveTask(task *Task) {
	for i, taskValue := range t.tasks {
		if taskValue == task {
			t.tasks = append(t.tasks[:i], t.tasks[i+1:]...)
			break
		}
	}
}

// update task
func (t *TaskList) UpdateTask(task *Task) {
	for i, taskValue := range t.tasks {
		if taskValue == task {
			t.tasks[i] = task
			break
		}
	}
}

func (t *Task) doneTask() {
	t.done = true
}

func main() {

	taskMap := map[string]*TaskList{
		"Mauro": {
			tasks: []*Task{
				{"Task 1", "Description 1", false},
				{"Task 2", "Description 2", false},
				{"Task 3", "Description 3", false},
				{"Task 4", "Description 4", false},
			},
		},
		"JP": {
			tasks: []*Task{
				{"Task1 week2", "Description 1", false},
				{"Task2 week2", "Description 2", false},
				{"Task3 week2", "Description 3", false},
				{"Task4 week2", "Description 4", false},
			}},
		"Gineth": {
			tasks: []*Task{
				{"Task1 week3", "Description 1", false},
				{"Task2 week3", "Description 2", false},
				{"Task3 week3", "Description 3", false},
				{"Task4 week3", "Description 4", false},
			}},
	}

	for key, v := range taskMap {

		fmt.Printf("Las tareas de %s son: \n", key)
		for _, task := range v.tasks {
			fmt.Printf("%s\n", task.name)
		}
	}

}

Lorena Cardona Tovar

student•

Primer ejemplo de map:

import "fmt"


func main() {
	
	m1 := make(map[string]int)
	m1["a"] = 8
	fmt.Println(m1)
	fmt.Println(m1["a"])
}

Cristian Rodriguez Morales

student•

Una lista un poco mas elaborada.

func (t *taskList) imprimirLista() {
	fmt.Println("--------------------------------")
	fmt.Println("Lista de registros. Registros encontrados ", len(t.tasks))
	fmt.Println("--------------------------------")

	for i, lista := range t.tasks {

		fmt.Println("Registro ", i+1, " de ", len(t.tasks))
		fmt.Println("--------------------------------")
		fmt.Println("Titulo: ", lista.nombre)
		fmt.Println("Descripcion", lista.descripcion)
		fmt.Println("--------------------------------")
	}
	fmt.Println("-------Fin.------")

}```

Carlos Nassif Trejo Garcia

student•

package main

import (
	"fmt"
)

type taskList struct {
	tasks []*task
}

func (t *taskList) agregarALista(tl *task) {
	t.tasks = append(t.tasks, tl)
}

func (t *taskList) eliminarDeLista(index int) {
	// ... desempaquetar los elementos
	t.tasks = append(t.tasks[:index], t.tasks[index+1:]...)
}

func (t *taskList) imprimirLista() {
	for _, e := range t.tasks {
		fmt.Println("\nNombre", e.nombre, "\nDescripcion", e.descripcion, "\nCompletado", e.completado)
	}
}

func (t *taskList) imprimirCompletados(done bool) {
	for _, e := range t.tasks {
		if e.completado != done {
			continue
		}
		fmt.Println("\nNombre", e.nombre, "\nDescripcion", e.descripcion, "\nCompletado", e.completado)
	}
}

type task struct {
	nombre      string
	descripcion string
	completado  bool
}

func (t *task) marcarCompleta() {
	t.completado = true
}

func (t *task) actualizarDescripcion(desc string) {
	t.descripcion = desc
}

func (t *task) actualizarNombre(nombre string) {
	t.nombre = nombre
}

func main() {
	t0 := &task{
		nombre:      "Completar curso go",
		descripcion: "Completar el curso de go en esta semana",
	}
	t1 := &task{
		nombre:      "Completar curso Python",
		descripcion: "Completar el curso de go en esta semana",
		completado:  true,
	}
	t2 := &task{
		nombre:      "Completar curso Mongo",
		descripcion: "Completar el curso de go en esta semana",
	}
	t3 := &task{
		nombre:      "Completar curso Node",
		descripcion: "Completar el curso de go en esta semana",
	}
	t4 := &task{
		nombre:      "Completar curso C#",
		descripcion: "Completar el curso de go en esta semana",
	}
	t5 := &task{
		nombre:      "Completar curso Programacion basica",
		descripcion: "Completar el curso de go en esta semana",
	}

	lista := &taskList{
		tasks: []*task{
			t0, t1,
		},
	}

	lista2 := &taskList{
		tasks: []*task{
			t3, t4, t5,
		},
	}

	lista.agregarALista(t2)

	fmt.Println("TAREAS COMPLETADAS")
	lista.imprimirCompletados(true)

	fmt.Println("TAREAS PENDIENTES")
	lista.imprimirCompletados(false)

	mapaTareas := make(map[string]*taskList)

	mapaTareas["Carlos"] = lista
	mapaTareas["Nestor"] = lista2

	fmt.Println("Tareas de Carlos")
	mapaTareas["Carlos"].imprimirLista()

	fmt.Println("Tareas de Nestor")
	mapaTareas["Nestor"].imprimirLista()

}

Luis Martinez

student•

Que p con la sintaxis de Go

Jovan Fernández

student•

Información sobre maps https://codingornot.com/13-go-to-go-maps-en-golang

Jean Nuñez

student•

make nos permite crear este tipo de structura de datos, com: Map

Jean Nuñez

student•

make(map[tipodato]*List) para asignar los valores

Avelino Sánchez

student•

Map es una estructura llave-valor. Esto quiere decir que relaciona una llave (cuyo valor no forzoso tiene que ser int a diferencia de los índices de arrays ó slices) hacia un valor. La sintaxis de un map es map[KeyType]ValueType.

Hay 2 maneras de inicializar maps cada una con sus diferencias:

// Inicializa un mapa definiendo el espacio previamente de 15 elementos 
m := make(map[string]int32, 15)

// Inicializa un mapa con un par de llave-valor iniciales
m := map[string]int{&quot;bob&quot;: 5}

Utilizando la palabra reservada make lo que permite es definir e instanciar un map, pero sin valores iniciales, únicamente con su capacidad.

Cristian Camilo Sosa Pinzon

student•

Para eliminar un elemento del mapa podemos hacer: delete(mapaTareas,"Nestor") cuando lo intente imprimir mostrará: <nil>

Maps

Introducción a Go

Mi primer programa en Go

Instalación en Mac y Windows

Instalar VS Code

Comandos básicos de Go

Analizando un programa en Go

Nuestra Primera Aplicación Go

Descripción del proyecto 1: Calculadora

Leer inputs desde la consola

Manejo de errores y uso de If

Switch

Lista de Tareas

Structs y Receivers

Descripción del proyecto 2: Lista de Tareas

Structs para Lista de Tareas

Punteros

Punteros en Structs

Uso de Slices

Ciclo For

Implementar For en Struct

Interfaces

¿Qué es una interfaz?

Maps

¿Por qué las Interfaces?

Creando la Interfaz Animal

Imprimiendo el contenido de una Página Web usando Interfaces

Goroutines y Channels

Introducción al problema de la Concurrencia

GoRoutines

Channels

Implementación de Goroutines y channels

Construyendo un Servidor Web

Ciclos While y For

Descripción de Servidor Web

Creando el Servidor

Manejando rutas en backend

¿Qué es un Middleware?

Manejando Request HTTP

Asignando Rutas HTTP

Agregando Middlewares

Agregando Multiples Middlewares

Agregando otro Middleware

Manejando POST

Manejando Modelos y JSON

Respondiendo Request JSON

Go Modules creando nuestro primer módulo en Go

Implementando nuestro primer módulo en Go

Conclusiones del Curso y siguientes pasos