Structs

Clase 19 de 34 • Curso de Programación en Go 2016

Diego Forero

Team Platzi•

Para definir una estructura

type <nombre estructura> struct {
        <nombre dato> <tipo dato>
        ...
}

type Course struct {
        Name string
        Slug string
        Url string
}

Para instanciar una estructura

goCourse := Course{Name: "Curso Go", Slug: "curso-go", Url: "/curso-go/"}

Diego Forero

Team Platzi•

Un struct en go simula un objeto, tiene variables que son como atributos.

Diego Forero

Team Platzi•

Otra forma de instanciar una estructura es usar la palabra reservada new

pythonCourse := new(Course)
pythonCourse.Name = "Curso Python"
pythonCourse.Slug = "curso-python"
pythonCourse.Url = "/curso-python"

Diego Forero

Team Platzi•

Con la palabra reservada type puedo crear tipos de datos a partir de otros

type platziInt int

Cuando se declare una variable de tipo platziInt esta variable va a ser de tipo entero.

Luis Manuel Navarro Rangel

student•

Aquí mi aporte, cree 3 estructuras: Course, Instructor y Career dentro del paquete platzi. Creo será más legible al momento de a utilizarla ya que será platzi.Career.

package platzi

//Course contiene los datos generales de un curso de Platzi
type Course struct {
	Name        string
	Description string
	Slug        string
	Teacher     Instructor
	Skills      []string
}

//Instructor contiene los datos de un instructor
type Instructor struct {
	FirstName     string
	LastName      string
	Twitter       string
	ProfilePicURL string
	Age           int
	Country       string
}

//Career contiene los datos de una carrera
type Career struct {
	Name        string
	Slug        string
	Description string
	Courses     []Course
}

Iván Toro

student•

Algo curioso es que cuando se instancia una estructura por medio de la palabra new a la hora de imprimirla aparece un & al inicio de la estructura, supongo que esto tiene que ver con como Go maneja los punteros, que se verán mas adelante en el curso.

package main

import "fmt"

type Text string

type Course struct {
  // name type
  name string
  class int
  skills []string
}

func main(){
  var str Text
  str = "Hi"
  fmt.Println(str) // Hi

  js := Course{name: "JavaScript", class: 35, skills: []string{"Backend, Frontend"}}
  fmt.Println(js) // {JavaScript 35 [Backend, Frontend]}
  html := new(Course)
  fmt.Println(html) // &{ 0 []}
  html.name = "HTML"
  html.class  = 40
  html.skills = []string{"Frontend"}
  fmt.Println(html) // &{HTML 40 [Frontend]}
}

Rafael Pardo Rodriguez

student•

Para que eso no suceda se imprime de esta manera

fmt.Println(*html)

Avena Support

student•

es como en C++? con la palabra reservada new se crea un puntero y hay que hacer indirección para traer su valor?

José Emanuel Castelán Cortés

student•

Hice mi ejercicio creando una carrera de dos cursos. La primera la inicie declarando toda la información al inicio y la segunda solo lo hice con el new y le fui cargando los datos.

La cuestión es que para agregar el segundo curso a la carrera, debí anteponer el struct del curso con la sintaxis de un apuntador (*course2).

Me imagino que eso voy a ver que sucede más adelante pero me gustaría saber si alguien sabe que diferencia tienen ambos modos de cargar información que requiera que el segundo necesite de un apuntador.

package main

import (
  "fmt"
)

type Course struct {
  Name string
  Slug string
  Skills []string
}

type Carrer struct {
  Name string
  Courses []Course
}

func main(){
//Curso 1 con información cargada en la declaración
  course1 := Course {Name: "Go", Slug: "go", Skills: []string {"programar","abstraccion", "lógica"}}
  fmt.Println(course1)
//Curso 2 agregado con el new y cargando información uno a uno
  course2 := new (Course)
  course2.Name = "Java"
  course2.Slug = "java"
  course2.Skills = []string {"c","programar","computacion"}
  fmt.Println(course2)

  courses := []Course {course1, *course2} //Course2 lo agrege como apuntador
  carrer1 := Carrer {Name: "Programacion" ,Courses: courses}
  fmt.Println(carrer1)
}

Yohan Graterol

teacher•

Cuando inicializas una variable con new eso genera un apuntador a un espacio en memoria y en tu caso el slice de Course recibe valores, para poder leer el valor de un puntero se debe anteponer *, de lo contrario le estás solo enviando la referencia que podría ser algo como 0xxxxx en ve de tu estructura.

José P. Carrillo E.

student•

Una estructura en Go, es algo muy parecido a lo que en los demás lenguajes llaman objets

Yojan Antonio Pardo Zabala

student•

pues yo hice un ejercicio asi

type Person struct{
  name string
  id int
  age int
}
func main(){
  person1 := Person{name:"laura",id:2554558,age:21}
  person2 := new(Person)
  person2.name = "yojan"
  person2.id = 1532586664
  person2.age = 21
}

Edilberto Medina

student•

Aquí mi aporte, hay 2 carreras y 2 cursos para cada carrera. Las carreras y los cursos están dentro de slices:

package main

import (

	"fmt"
)

//Estructura
type Course struct {//Creando dato Course de tipo de dato struct

	Name string
	Duration int
	Level string
	Cost float32

}
//Estructura
type Career struct {//Creando dato Career de tipo de dato struct

	Name string
	Courses []Course//Slice Courses de tipo de dato Course
}
//Estructura
type University struct{//Creando dato University de tipo de dato struct

	Careers []Career//Slice Careers de tipo de dato Career
}



func main() {

	university:=University{ //Instanciando Estructura

		Careers: []Career {//Agregando datos al slice Careers

			Career{//Tipo de dato Career que se agrega al indice cero(Ya que es el primer dato) del slice Careers
				Name:"Career1",
				Courses: []Course{//Agregando datos al slice Courses

					Course{//Tipo de dato Course que se agrega al indice 0(Ya que es el primer dato) del slice Courses del indice 0 del slice Careers
						Name:"Course1",
						Duration: 80,
						Level: "Basic",
						Cost: 800,
					},

					Course{//Tipo de dato Course que se agrega al indice 1(Ya que es el segundo dato) del slice Courses del indice 0 del slice Careers

						Name:"Course2",
						Duration: 120,
						Level: "Intermediate",
						Cost: 320,

					},

				},
			},

			Career{
				Name:"Career2",//Tipo de dato Career que se agrega al indice uno(Ya que es el segundo dato) del slice Careers
				Courses: []Course{

					Course{//Tipo de dato Course que se agrega al indice 0(Ya que es el primer dato) del slice Courses del indice 1 del slice Careers
						Name:"Course3",
						Duration: 50,
						Level: "Basic",
						Cost: 480,
					},

					Course{//Tipo de dato Course que se agrega al indice 1(Ya que es el segundo dato) del slice Courses del indice 1 del slice Careers

						Name:"Course4",
						Duration: 90,
						Level: "Advanced",
						Cost: 600,

					},

				},
			},
		},

	}

	fmt.Println(university.Careers[0].Name)	//Imprime el nombre de la carrera 1
	fmt.Println(university.Careers[0].Courses[0])//Imprime los datos del curso 1 de la carrera 1
	fmt.Println(university.Careers[0].Courses[1])//Imprime los datos del curso 2 de la carrera 1
	fmt.Println(university.Careers[1].Name)	//Imprime el nombre de la carrera 2
	fmt.Println(university.Careers[1].Courses[0])//Imprime los datos del curso 1 de la carrera 2
	fmt.Println(university.Careers[1].Courses[1])//Imprime los datos del curso 2 de la carrera 2
}```

Hans Piña

student•

Me recordó a GraphQL jaja

Ernesto Ventas Fernandez

student•

Maday Choque

student•

package main
import "fmt"

func main(){
    platziCourse := PlatziCourse{Name: "Go",Slug: "go",Skills: []string{"1", "2"}}
    platziCourse1 := new(PlatziCourse)
    platziCourse1.Name = "Python"
    platziCourse1.Slug = "python"
    platziCourse1.Skills = []string{"backend"}
    platziCareer := PlatziCareer{PlatziCourse{Name: "Frontend",Slug: "js",Skills: []string{"basico", "avanzado"}}}
    fmt.Println(platziCourse)
    fmt.Println(platziCourse1)
    fmt.Println(platziCareer)
}

type PlatziCourse struct {
    Name string
    Slug string
    Skills []string
}

type PlatziCareer struct {
    PlatziCourse
}

Raul Castro Palmett

student•

Una estructura básica:

package models

import (
	"fmt"
)

// PlatziCourse almacena la informacion de un curso en platzi
type PlatziCourse struct {
	Name   string
	Slug   string
	Skills []string
}

// PlatziCareer Almacena una carrera con sus cursos
type PlatziCareer struct {
	Career  PlatziCourse
	Courses []PlatziCourse
}

func main() {
	carrera := PlatziCareer{
		Career: PlatziCourse{Name: "Go", Slug: "go", Skills: []string{"Basic"}},
		Courses: []PlatziCourse{
			PlatziCourse{Name: "Go Basic", Slug: "go basic", Skills: []string{"Very Basic"}},
		},
	}
	fmt.Println(carrera)
}

Jose L. Figueroa

student•

Les comparto mi ejercicio:

Tengo una struct principal llamada PlatziCareer que es la estructura para la carreras de Platzi, que dentro de ella se llama a la struct PlatziCourse, que es la struct para los cursos de las carreras de Platzi y dentro de ella llama a PlatziInstructor, que contiene la info del instructor de cada uno de los corsos de las carreras.

type PlatziCourse struct {
	Name    string
	Slug    string
	Teacher PlatziInstructor
	Skills  []string
}

type PlatziInstructor struct {
	Name           string
	ProfilePicture string
	TeachesCourses []string
}

type PlatziCareer struct {
	Course PlatziCourse
}

func main() {
	platziCareer := PlatziCareer{
		Course: PlatziCourse{Name: "Go", Slug: "/cursos/go", Teacher: PlatziInstructor{Name: "Yohan Graterol", ProfilePicture: "yohan-graterol.jpg", TeachesCourses: []string{"Intruducción a Go", "Go", "Bases de Datos con MongoDB"}}, Skills: []string{"Desarrollo Backend", "Desarrollo Templates"}},
	}
	fmt.Println(platziCareer)
}

![Captura de pantalla 2018-10-28 a la(s) 23.58.49.png](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202018-10-28%20a%20la%28s%29%2023.58.49-6e7fcb3d-5f64-4e4e-870f-28818dbdb20a.jpg)

Jose L. Figueroa

student•

Les comparto mi ejercicio:

type PlatziCourse struct {
	Name    string
	Slug    string
	Teacher PlatziInstructor
	Skills  []string
}

type PlatziInstructor struct {
	Name           string
	ProfilePicture string
	TeachesCourses []string
}

type PlatziCareer struct {
	Course PlatziCourse
}

func main() {
	platziCareer := PlatziCareer{
		Course: PlatziCourse{Name: "Go", Slug: "/cursos/go", Teacher: PlatziInstructor{Name: "Yohan Graterol", ProfilePicture: "yohan-graterol.jpg", TeachesCourses: []string{"Intruducción a Go", "Go", "Bases de Datos con MongoDB"}}, Skills: []string{"Desarrollo Backend", "Desarrollo Templates"}},
	}
	fmt.Println(platziCareer)
}

Jose L. Figueroa

student•

Es posible usar arreglos de estructuras??? Y si sí, como puedo utilizarlos???

Federico Fernandez

student•

type Estructura struct{
	Palabra string
	Numero int
}
var arregloEstructuras []Estructura

Rafael Pardo Rodriguez

student•

Puedes usarlos convirtiendolos en formato json,

type persona struct {
	name string `json:"name"` // por ejemplo
}

Luego tienes que aprender a usar el package json Te dejo un link

José Emanuel Castelán Cortés

student•

Comparando como funcionan las interfaces de Java y Python, yo lo siento muy ineficiente. Sería mejor descartar la sobrecarga de funciones si se usa Go, al menos que haya una alternativa de POO en Go que lo mejore.

Qenta SAS

student•

type Estudio struct {
	Name    string
	Persona string
	Skills  []string
}

type Curso struct {
	Name     string
	Slug     string
	Profesor string
	Videos   int
}

type Cursos struct {
	Name string
	Slug string
	Url  string
}

func main() {
	Objeto := Estudio{Name: "Go", Persona: "Zerofelx", Skills: []string{"Backend", "Frontend"}}
	fmt.Print(Objeto)

	fmt.Print("\n")

	// Crear instancia

	Objeto1 := new(Estudio)
	Objeto1.Name = "JavaScript"
	Objeto1.Persona = "Zerofelx"
	Objeto1.Skills = []string{"Backend", "Frontend", "Node.JS"}

	fmt.Print(Objeto1)
	fmt.Print("\n")

	objetoCurso := Curso{Name: "Golang", Slug: "Go", Profesor: "Yograterol", Videos: 30}
	fmt.Print(objetoCurso)
	fmt.Print("\n")

	objetoCurso2 := new(Curso)
	objetoCurso2.Name = "Javascript"
	objetoCurso2.Slug = "Js"
	objetoCurso2.Profesor = "Leonardo Dicaprio"
	objetoCurso2.Videos = 30
	fmt.Print(objetoCurso2)
	fmt.Print("\n")
}

Christian Armando Consuelo Mayén

student•

¿O sea que las structs es similar a los maps pero de varios tipos de datos?

Diego Forero

Team Platzi•

Un struct es más parecido a la definición de un objeto que tiene atributos.