Structs para Lista de Tareas

// Definición de un struct con propiedades
type name struct {
	propName propType
}

bool es la palabra reservada para identificar el tipo de dato boolean.

// Inicialización de un struct tipo task y llamada su método
func main() {
	t := task{
		name: "learn go",
		description: "make some time to study golang",
		completed: false,
	}
	t.updateName("study")
}

Una particularidad de Go es que al momento de estar nombrando las propiedades de una struct al momento de hacer la inicialización, es que al final de cada uno lleva coma (,) inclusive en la última propiedad; esto para tener una mayor seguridad y evitar estar olvidando que la última propiedad no debe llevar como podría suceder en otros lenguajes.

En Go existe la convención de nombrar a las variables con una única letra, esto siempre y cuando el scope del código permita ubicar a la variable y su contexto fácilmente.

fmt.Printf("%+v\n", t) // Imprime un struct mostrando llaves y valores

En Go al momento de hacer una impresión en consola podemos utilizar la función Printf() que recibe una plantilla de string en la que podemos pasarle diversos valores de caracteres para formatear de diversas maneras el valor que vamos a imprimir. https://golang.org/pkg/fmt/

// Definición de receiver functions
func (t task) updateName(name string) {
	t.name = name
}

La edicion de este video y dedl ultimo de la seccion anterior estan mal, en este repite algo en el anterior (Structs Y Receivers) se saltaron crear una funcion, ahi lo bueno es que se tienen los archivos del codigo donde pude ver que contenia o que hacia la funcion.

Que no se actualizara fue inesperado o.O

¿Cuál es la diferencia entre el = y :=?

Structs es el simil a una clase de Java

fmt.Printf() -> nos permite con los formatis imprimir llave-valor

Habiendo hecho el curso anterior de Go de la escuela Backend con Go, con la función String() puedes mejorar el formato en que se imprimen las estructuras, pruébalo

Algo interesante en el formato del Printf("+v") que usa para imprimir el task es que si lo pones dentro de la function receiver String tipicamente usada para imprimir algún struct o tipo definido como por ej:

type task struct {
	nombre      string
	descripcion string
	completado  bool
}

func (t task) String() string {
	return fmt.Sprintf("%+v", t)
}

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

	fmt.Println(t)
}

Es que go va a fallar con un error: runtime: goroutine stack exceeds

Ya que el formato %+v hace de manera interna un recorrido por las propiedades del struct, asi que si le quieren agregar la funcion String les recomiendo que usen un formato personalizado para evitar un loop infinito ej:

func (t task) String() string {
	return fmt.Sprintf(
		"Nombre: %s, Desc: %s, Completado: %t",
		t.nombre,
		t.descripcion,
		t.completado,
	)
}

Importente, revisar la edicion de este curso, por un momento pense que se regresaba.
Se repite varios procesos ya hechos en este y otros videos.

Para que se editen los paramentos

Debería pasarse como un puntero, asi go entiende que se quieren cambiar los atributos dentro del struct

// Definición de receiver functions
func (t *task) updateName(name string) {
	t.name = name
}

Interesante

😎

You can define two types of functions for structs:

1. It’s called receiver function and uses *
2. Uses nothing

We use #1 to interact with the fields of the instance that was passed and we use #2 to do the opposite. Which means that with #2 you’ll get a copy of the instance while with #1 you’ll not, you’ll be interacting with the instance itself.

Example:

package main

import "fmt"

type Data struct {
    A string
}

// #1
func (d Data) Do1() {
    d.A = "value1"
}

// #2
func (d *Data) Do2() {
    d.A = "value2"
}

func main() {
    d := Data{"unchanged"}
    d.Do1()
    fmt.Println(d.A) // Output: unchanged
    d.Do2()
    fmt.Println(d.A) // Output: value2
}

Explanation:

This program prints unchanged at first because that’s the value of d, and as you can see the function Do1() is from the type #1, so it’s interacting with a copy of the instance. However, afterwats it prints value2 after executing Do2(), because that function is from the type #2, which means that we ARE INTERACTING with the instance itself.

package main

import "fmt"

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() {
	t := task{
		nombre:      "Completar curso go",
		descripcion: "Completar el curso de go en esta semana",
	}

	fmt.Printf("%+v\n", t)

	t.marcarCompleta()
	t.actualizarNombre("Curso go")
	t.actualizarDescripcion("Completar el curso cuanto antes")
	fmt.Printf("%+v\n", t)
}

Interesante 😃 gracias

las funciones Receivers son una forma distinta de crear clases y funciones de POO.

fmt.Printf() -> te permite imprimir desde un formato, con respecto a la propiedad y el valor

en los struct al final, asi no haya nada hay que colocar una coma(,)

struct avanzado muy bueno

update para los struct, muy facil, creando una funcion donde le pasamos los valores, estas funciones no regresan valores,

como es que funciona
func (t task)

package main

import (
	"fmt"
)

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() {
	t := task{
		nombre: 	 "Completar mi curso de Go",
		descripcion: "Completare mi curso de Go de Platzi en esta semana",
	}
	fmt.Printf("%+v\n", t)
	t.marcarCompleta()
	t.actualizaNombre("Finalizar mi curso de go")
	t.actualizaDescripcion("Completar mi curso lo mas pronto posible")
	fmt.Printf("%+v\n", t)
}