Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Maps

19/42
Recursos

Aportes 18

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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

Super… yo recorri el map con un for 😃 menos codigo

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

😃

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 =?

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

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

}
 

Primer ejemplo de map:

import "fmt"


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

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.------")

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

}

Que p con la sintaxis de Go

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

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

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{"bob": 5} 

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

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

-Maps: es una estructura de datos donde existe una llave y un valor, es similar a Los objetos en JavaScript y a los diccionarios en Python

	mapaTareas["Juanda"] = lista

	t4:= &task{
		nombre: 	 "Completar mi curso de PHP->",
		descripcion: "Completare mi curso de PHP de Platzi en esta semana->",
	}

	t5 := &task{
		nombre: 	 "Completar mi curso de Angular..",
		descripcion: "Completare mi curso de Angular de Platzi en esta semana..",
	}

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

	mapaTareas["Isabel"] = lista2

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

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

Los maps son mucho más lentos de iterar que los slices, ojo. 👀
Sucede que si accedes con un index entonces slice es más rápido. Los maps hacen una búsqueda previa para acceder al valor.

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.