No tienes acceso a esta clase

¬°Contin√ļa aprendiendo! √önete y comienza a potenciar tu carrera

Implementar For en Struct

17/42
Recursos

Aportes 11

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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!

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