Implementar For en Struct

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

Fernando Eladio Alvarez Noya

student•

Por cierto, aqui les dejo mi codigo... soy muy visual y me gusta ver los mensajes!

package main

import &quot;fmt&quot;

type taskList struct {
	tasks []*task
}

type task struct {
	name        string
	description string
	completed   bool
}

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

func (t *task) tagCompleted() {
	t.completed = true
}

func (t *task) updateDescription(description string) {
	t.description = description
}

func (t *task) updateName(name string) {
	t.name = name
}

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

func (t *taskList) printList() {
	fmt.Println(&quot;------------------------------ LISTA DE TAREAS -----------------------------&quot;)
	for _, task := range t.tasks {
		fmt.Println(&quot;----------------------------------------------------------------------------&quot;)
		fmt.Println(&quot; &quot;)
		fmt.Println(&quot;Nombre: &quot;, task.name)
		fmt.Println(&quot; &quot;)
		fmt.Println(&quot;Description: &quot;, task.description)
		fmt.Println(&quot; &quot;)
	}
	fmt.Println(&quot;----------------------------------------------------------------------------&quot;)
}

func (t *taskList) printListCompleted() {
	fmt.Println(&quot;------------------------- LISTA DE TAREAS COMPLETADAS ----------------------&quot;)
	for _, task := range t.tasks {
		if task.completed {
			fmt.Println(&quot;----------------------------------------------------------------------------&quot;)
			fmt.Println(&quot; &quot;)
			fmt.Println(&quot;Nombre: &quot;, task.name)
			fmt.Println(&quot; &quot;)
			fmt.Println(&quot;Description: &quot;, task.description)
			fmt.Println(&quot; &quot;)
			fmt.Println(&quot;Completed: &quot;, task.completed)
			fmt.Println(&quot; &quot;)
		}
	}
	fmt.Println(&quot;----------------------------------------------------------------------------&quot;)
}

func main() {

	t1 := &amp;task{
		name:        &quot;Complete my Go course&quot;,
		description: &quot;Complete my Go Course from Platzi in this week&quot;,
	}

	t2 := &amp;task{
		name:        &quot;Complete my Python course&quot;,
		description: &quot;Complete my Python Course from Platzi in this week&quot;,
		completed:   true,
	}

	t3 := &amp;task{
		name:        &quot;Complete my NodeJS course&quot;,
		description: &quot;Complete my NodeJS Course from Platzi in this week&quot;,
	}

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

	lista.addToList(t3)

	lista.printList()

	lista.printListCompleted()
}

Jean Nuñez

student•

Muy bien hecho este codigo, Uffff eres grande!

Carlos Javier Bazan Huaman

student•

Podriamos imprimir las 2 listas en una sola funcion separando en orden cada tipo.

Fernando Eladio Alvarez Noya

student•

Tengo una consulta, es respecto de las buenas practicas para escribir codigo en Go:

Las identaciones de cuantos espacios deberian ser?
Se utilizan espacios en blanco o tabuladores?

Lo pregunto porque cada lenguage tiene sus "guias" y me gustaria saberlo para asi configurar mi VS para Go

Gracias!

Luis Garcia

student•

Hola, la recomendación oficial es usar gofmt o go fmt para el formato de nuestro código en go.
go fmt usa tabuladores para indentar.

Ejemplo de uso: go fmt miarchivo.go El comando arreglara el formato de tu codigo si es que lo necesita.

Yo instale la extensión de go en VS y este se encarga de arreglar el formato usando go fmt.

Aqui dejo el enlace de la documentación go. Ahí mencionan gofmt y el uso de tabuladores para la indentación.

Fernando Eladio Alvarez Noya

student•

Gracias Luis por tu respuesta, si yo estoy usando VS pero es que a veces por defecto trae una configuracion y no sabia si era la oficial! :)

Steven Javier Arevalo Poveda

student•

No es necesario el apuntador en este método pues no se está haciendo ninguna modificación al contenido de la struct.

Henrry Bourgeot

student•

Aquí adjunto mi código, tiene un separador incluido entre tareas para facilitar la visualización, y también hice una refactorización de código

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",
	}

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

	fmt.Println(lista.tasks[0])

	fmt.Println(len(lista.tasks))

	lista.agregarALista(t2)

	lista.imprimirLista()

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

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

	
	

}

Francisco Garcia [C6]

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) {
	t.tasks = append(t.tasks[:index], t.tasks[index + 1:]...)
}

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

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

type task struct{
	nombre string
	descripcion string
	completado bool
}

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

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

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

func main() {
	t1 := &task{
		nombre: 	 "Completar mi curso de Go::",
		descripcion: "Completare mi curso de Go de Platzi en esta semana::",
	}

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

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

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

	lista.agregarALista(t3)
	lista.imprimirLista()
	lista.tasks[0].marcarCompleta()
	fmt.Println("*** tareas completadas ***")
	lista.imprimirListaCompletados()
}

Daniel Alejandro Cumaco Robayo

student•

Presento una maera mas optima con menos tiempo de respuesta y mas estructurada del proyecto, queria agregar un filter para la impresion de listas, pero me veo en la nesecidad de primero ver maps para hacer algo realmente bien implementado:

package main

import "fmt"

// Utilities
func nextPow2(number int) (cnt int) {
	for cnt = 2; number != 1; number >>= 1 {
		cnt <<= 1
	}
	return cnt
}

// list
type tasksList struct {
	tasks  []*task
	length int
	front  int
}

func createList() *tasksList {
	return &tasksList{make([]*task, 2), 2, -1}
}

func (tl *tasksList) add(element ...*task) {
	newLen := tl.front + len(element) + 1
	if tl.length < newLen {
		newPrt := tl.tasks
		tl.length = nextPow2(newLen)
		tl.tasks = make([]*task, tl.length)
		copy(tl.tasks, newPrt)
	}
	copy(tl.tasks[tl.front+1:], element)
	tl.front = tl.front + len(element)
}

func (tl *tasksList) remove(index int) {
	tl.tasks[tl.front] = nil
	tl.front -= 1
}

func (tl *tasksList) printList() {
	fmt.Printf("%+v\n", *tl)
	for _, value := range (*tl).tasks {
		fmt.Printf("%+v\n", value)
	}
}

// task
type task struct {
	_title       string
	_description string
	_done        bool
}

func (t *task) title(str string) {
	t._title = str
}

func (t *task) description(str string) {
	t._description = str
}

func (t *task) done(done bool) {
	t._done = done
}

func createTask(title string, description string, done bool) *task {
	instance := task{}
	instance.title(title)
	instance.description(description)
	instance.done(done)
	return &instance
}

// main
func main() {

	task1 := createTask("Complete course", "Platzi go course", false)
	task2 := createTask("Incomplete course", "Platzi python course", false)
	task3 := createTask("Total course", "Platzi ruby course", true)
	task4 := createTask("In course", "Platzi C course", false)
	task5 := createTask("Total course", "Platzi ruby C course", true)

	tasksContainer := createList()
	tasksContainer.add(task1, task2, task3, task4, task5)
	tasksContainer.printList()
}

Braejan Arias

student•

Función que retorna los elementos completados de una lista de tareas.

<code>
func (t *taskList) getCompletedTaskList() *taskList {
	result := &taskList{
		tasks: []*task{},
	}
	for _, task := range t.tasks {
		if task.completed {
			result.add(task)
		}
	}
	return result
}
</code>

Usuario anónimo

user•

Listo :)

Brian Toro

student•

Así solucione yo el problema de imprimir las tareas

func (tl *taskList) printListOFTasks(){
	for _ , task := range tl.tasks{
		fmt.Println(task.name)
		fmt.Println(task.description)
	}
}

func (tl *taskList) printTasksCompleted(){
	for _ , task := range tl.tasks{
		if (task.complete){
			fmt.Println(task.name)
		}
	}
}

func (tl *taskList) printTaskUncompleted() {
	for _, task := range tl.tasks {
		if (!task.complete) {
			fmt.Println(task.name)
		}
	}
}

Cristian Felipe Patiño Cáceres

student•

En mi caso realicé otra función para encapsular la función de imprimir cada tarea

func (tl *taskList) prinTask(t *task) {
	fmt.Println("{")
	fmt.Println("  name task:", t.name)
	fmt.Println("  description task:", t.description)
	fmt.Println("  isCompleted:", t.isCompleted)
	fmt.Println("}")
}

func (tl *taskList) printAllTasks() {
	fmt.Println("---------- ALL TASK ----------")
	for _, task := range tl.tasks {
		tl.prinTask(task)
	}
}

func (tl *taskList) printCompletedTasks() {
	fmt.Println("---------- COMPLETED TASK ----------")
	for _, task := range tl.tasks {
		if task.isCompleted {
			tl.prinTask(task)
		}
	}
}

Daniel Omar Noh Villanueva

student•

Les comparto mi script para capturar n tareas como gusten e imprimir las mismas

package main

import (
	"os"
	"fmt"
	"bufio"
	"strconv"
)

type taskList struct {
	tasks []*task
}

type task struct {
	name		string
	description	string
	complete	bool
}

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

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

func (t *task) checkDone() {
	t.complete = true
}

func (t *task) uptadeDescription(description string) {
	t.description = description
}

func (t *task) uptadeTask(name string) {
	t.name = name
}

func (tl * taskList) printTasks() {
	for _, task := range tl.tasks {
		fmt.Println("Task", task.name)
		fmt.Println("Description", task.description)
	}
}

func main() {
	t := &task{}
	list := &taskList{}

	fmt.Println("Ingresa cantidad de tareas a agregar")
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()

	count, _ := strconv.Atoi(scanner.Text())

	for i := 0; i < count; i++ {
		fmt.Println("Ingresa tarea:")
		scanner := bufio.NewScanner(os.Stdin)
		scanner.Scan()

		t.uptadeTask(scanner.Text())

		fmt.Println("Ingresa descripción:")
		scanner.Scan()

		t.uptadeDescription(scanner.Text())

		list.addToList(t)
	}

	fmt.Println("Tareas agregadas")
	list.printTasks()
}

Implementar For en Struct

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