No tienes acceso a esta clase

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

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Reg铆strate

Comienza en:

4D
20H
7M
34S

Maps

19/42
Recursos

Aportes 19

Preguntas 3

Ordenar por:

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

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

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.

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

}

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,鈥淣estor鈥)
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.