Structs para Lista de Tareas

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

Avelino Sánchez

student•

// 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: &quot;learn go&quot;,
		description: &quot;make some time to study golang&quot;,
		completed: false,
	}
	t.updateName(&quot;study&quot;)
}

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(&quot;%+v\n&quot;, 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
}

Roger Olivares

student•

gracias por el aporte, saludos

Gustavo Martínez

student•

Muy buen aporte

David Esteban Solorzano Taborda

student•

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.

Héctor Hugo Sandoval Marcelo

student•

Que no se actualizara fue inesperado o.O

Jaime Ramos

student•

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

César Augusto Sierra Mejía

student•

= se usa cuando se asigna un valor creando la variable con var var mensaje string = "Hola Mundo" O cuando se asigna un valor despues de creada la variable

:= se usa para asignar valores a variables nuevas (sin necesidad de usar var)

mensaje2 := "Mensaje de prueba"

Daniel Omar Noh Villanueva

student•

Complementado más que no usar var el usar := evita colar el tipo de dato de la variable, podría decirse que es la forma simple de declara una variable; recuerda que Go es fuertemente tipeado

ejemplo

var mensaje string = "hola"

// forma simple
mensaje := "hola"

Pilar Mass

student•

Structs es el simil a una clase de Java

Juan Marcos Caicedo Mejía

student•

Si nos vamos más a lo general, Structs en Go es similar a como tal el concepto de Objeto en los demás lenguajes de Programación.

Jean Nuñez

student•

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

Luis Garcia

student•

Buenas notas, gracias por los aportes. Recomendaría poner todos los apuntes en un solo comentario para que aportes de nuestros otros compañeros sean más visibles. :)

Henrry Bourgeot

student•

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

Henrry Bourgeot

student•

¿No sería mejor usar en los métodos del struct un puntero? ejemplo,

func (t *task) actNombre(nombre string){
 //cuerpo
}

Sergio Adrian Garay Ferrera

student•

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

Francisco José Salazar Maitan

student•

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.

Nicoll Idaly Angulo Mejia

student•

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
}

Oscar Jaramillo

student•

Interesante

Oscar Jaramillo

student•

😎

Sebastian CA

student•

You can define two types of functions for structs:

It's called receiver function and uses *
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.

Carlos Nassif Trejo Garcia

student•

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

Usuario anónimo

user•

Interesante :) gracias

Carlos Javier Bazan Huaman

student•

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

William Rodriguez

student•

Realmente es idéntico a un Setter en POO.

Avelino Sánchez

student•

@william Sí, en este caso se podrían considerar como métodos setters. Sin embargo, algo que he notado en la comunidad de Go es que los métodos setters/getters no son tan comunes así explícitamente. Así como en este ejemplo, he visto exportan métodos que pudiesen realizar las funciones de actualizar un valor.

Jean Nuñez

student•

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

Jean Nuñez

student•

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

Jean Nuñez

student•

struct avanzado muy bueno

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

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

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
}

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

Structs para Lista de Tareas

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