Implementar For en Struct

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 “guias” 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()
}