No tienes acceso a esta clase

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

Implementar For en Struct

17/42
Recursos

Aportes 13

Preguntas 0

Ordenar por:

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

o inicia sesi贸n.

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

package main

import "fmt"

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("------------------------------ LISTA DE TAREAS -----------------------------")
	for _, task := range t.tasks {
		fmt.Println("----------------------------------------------------------------------------")
		fmt.Println(" ")
		fmt.Println("Nombre: ", task.name)
		fmt.Println(" ")
		fmt.Println("Description: ", task.description)
		fmt.Println(" ")
	}
	fmt.Println("----------------------------------------------------------------------------")
}

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

func main() {

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

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

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

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

	lista.addToList(t3)

	lista.printList()

	lista.printListCompleted()
}

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

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

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

Lo pregunto porque cada lenguage tiene sus 鈥済uias鈥 y me gustaria saberlo para asi configurar mi VS para Go

Gracias!

No es necesario el apuntador en este m茅todo pues no se est谩 haciendo ninguna modificaci贸n al contenido de la struct.

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

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)

	
	

}

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

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

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>

Listo 馃槂

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

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

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