Hola mundo en Go

1

Introducción al Curso de Golang

2

¿Qué es, por qué y quienes utilizan Go?

3

Instalar Go en Linux

4

Instalar Go en Mac

5

Instalar Go en Windows

6

Nuestras primeras líneas de código con Go

Variables, funciones y documentación

7

Variables, constantes y zero values

8

Operadores aritméticos

9

Tipos de datos primitivos

10

Paquete fmt: algo más que imprimir en consola

11

Uso de funciones

12

Go doc: La forma de ver documentación

Estructuras de control de flujo y condicionales

13

El poder de los ciclos en Golang: for, for while y for forever

14

Operadores lógicos y de comparación

15

El condicional if

16

Múltiple condiciones anidadas con Switch

17

El uso de los keywords defer, break y continue

Estructuras de datos básicas

18

Arrays y Slices

19

Recorrido de Slices con Range

20

Llave valor con Maps

21

Structs: La forma de hacer clases en Go

22

Modificadores de acceso en funciones y Structs

Métodos e interfaces

23

Structs y Punteros

24

Stringers: personalizar el output de Structs

25

Interfaces y listas de interfaces

Concurrencia y Channels

26

¿Qué es la concurrencia?

27

Primer contacto con las Goroutines

28

Channels: La forma de organizar las goroutines

29

Range, Close y Select en channels

Manejo de paquetes y Go Modules

30

Go get: El manejador de paquetes

31

Go modules: Ir más allá del GoPath con Echo

32

Modificando módulos con Go

Despedida del curso

33

Despedida

Bonus

34

Cheat Sheet Go

35

Librerías para desarrollo web con Go

36

Data Science con Go

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Structs: La forma de hacer clases en Go

21/36
Recursos

Aportes 29

Preguntas 3

Ordenar por:

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

Los Structs ya se me hacian conocido del lenguaje C https://www.tutorialspoint.com/cprogramming/c_structures.htm

Sobre la definición, un struct es simplemente una colección de campos.

Estas fueron algunas cosas que se me ocurrieron agregarle 👇

package main

import "fmt"

type car struct {
	brand   string
	year    int
	seating int
	color   string
	owner   string
}

func main() {
	myCar := car{brand: "Toyota", year: 2018, seating: 10, color: "Rojo", owner: "Eliaz Bobadilla"}
	fmt.Println("Los Datos de mi auto son:", myCar)

Esto esta mas documentado aquí.

Clase en código enchulado:

package main

import "fmt"

type car struct {
	brand string
	year  int
}

func main() {

	fmt.Println()
	fmt.Println("=======")
	fmt.Println("STRUCTS")
	fmt.Println("=======")
	fmt.Println()

	fmt.Println("En otros lenguajes existe la estructura llamada Clase, donde se definen atributos y métodos. ")
	fmt.Println("En Go no existe esta estructura pero ofrece 'structs' que según tiene mas poder.")
	fmt.Println()

	fmt.Println("Declaración:")
	fmt.Println("------------")
	fmt.Println()

	fmt.Println("Se declara como otro bloque de función, pero cambiando func por 'type' y luego del nombre se coloca 'struct'")
	fmt.Println("type car struct { ... }")
	fmt.Println()

	fmt.Println("se declaran sus atributos como pares nombre-tipo, uno por línea, tal cual como en el código de este archivo.")
	fmt.Println("atributico string")
	fmt.Println()

	fmt.Println("Primera forma de instanciación:::")
	fmt.Println("---------------------------------")
	fmt.Println()

	myCar := car{brand: "Renault", year: 2021}

	fmt.Println("myCar := car{brand: \"Renault\", year: 2021}")
	fmt.Println()

	fmt.Println("FMT Imprime: ")
	fmt.Println(myCar)
	fmt.Println()

	fmt.Println("Otra forma de imprimirlo en consola:")
	fmt.Printf("Structsito = %+v", myCar)
	fmt.Println()

	fmt.Println()
	fmt.Println("Instanciación como una clase vacía:")
	fmt.Println("-----------------------------------")
	fmt.Println("")

	fmt.Println("Se intancia así: ")
	fmt.Println("var otherCar car")
	fmt.Println()

	fmt.Println("Y se va asignando los valores de cada atributo:")
	fmt.Println("otherCar.brand = \"Chevrolet\"")
	fmt.Println()

	var otherCar car
	otherCar.brand = "Chevrolet"

	fmt.Println("Si un atributo del struct no se inicializa, toma un Zero Value, y por lo tanto se imprime así lo referente al año:")

	fmt.Println(otherCar)
	fmt.Println()

	fmt.Println()
}

Metodos jeje

package main

type Person struct {
	name        string
	last        string
	phoneNumber uint32
}

func (p Person) getName() string {
	return p.name
}


func main(){
	daniel := Person{
		name:        "Daniel",
		last:        "Franc",
		phoneNumber: 4061022,
	}

	println(daniel.last)

	daniel.last = "Franco"

	println(daniel.last)

	println(daniel.getName())
}

Por lo que veo son miembros publicos por defecto, como las structs de C++

Hincapié

Si es que así les resulta largo:

type usuario struct{
  nombre   string
  edad     int
  dni      int
  sexo     string
}

Intente compactar así:

type usuario struct{
  nombre, sexo string
  edad, dni    int
}

car

package main

import "fmt"

type car struct {
	brand string
	model string
	year  int
	color string
}

func main() {
	myCar := car{brand: "Ford",model: "Bronco sport", year: 2022, color: "Black"}
	fmt.Println(myCar)

	//Otra manera
	var otherCar car
	otherCar.brand = "Ferrari"
	fmt.Println(otherCar)
}

//Impresiones
//{Ford Bronco sport 2022 Black}
//{Ferrari  0 }

Experimento

type car struct {
	brand    string
	year     int
	countGas func()
}

func main(){
	var otherCar = car{}
	otherCar.brand = "Chevrolette"
	otherCar.countGas = func() { fmt.Println("Gas", "54") }
	fmt.Println(otherCar)
	otherCar.countGas()
}

Funcionó

<package main

import "fmt"

type car struct {
	brand       string
	year        int
	color       string
	height      float32
	width       float32
	weight      float32
	cylinders   int
	engine_type string
	price       float64
}

func main() {
	my_car := car{brand: "Honda", year: 2018, color: "blue", height: 1.47,
		width: 4.56, weight: 1140, cylinders: 4, engine_type: "line", price: 388900}

	fmt.Println(my_car)
}
> 
package main

import "fmt"

//Estructuras es igual a clases

type car struct {
	brand string
	year  int
	color string
	model string
}

func main() {
	myCar := car{brand: "Ford", year: 2020, color: "Green", model: "T"}
	fmt.Println(myCar)

	//Otra manera

	var otherCar car
	otherCar.brand = "Ford"
	otherCar.year = 2020
	otherCar.color = "Green"
	otherCar.model = "T"
	fmt.Println(otherCar)

}

muy familiar desde java

package main

import “fmt”

//Creando nuestro struct
type car struct {
brand string
year int
colors string
motor string
}

func main() {
myCar := car{brand: “Ford”, year: 2020, colors: “Blue”, motor: “3600 HP”}
fmt.Println(myCar)

//Otra manera
var otherCar car
otherCar.brand = "Ferrari"
fmt.Println(otherCar)

}

Mi Struct de Car

type car struct {
	owner string
	year  uint
	brand string
	model string
	color string
}

struct dentro de struct

type anotherStruct struct {
	val string
}

type Car struct {
	brand string
	year uint16
	model string
	subClass anotherStruct
}

func StructingBabyyyy (){
	ferrari := Car{brand: "Ferrari",
					year: 2020,
					model: "Roma",
					subClass: anotherStruct{val: "coupe",}}
					

	ford := Car{brand: "Ford"}

	fmt.Println(ferrari)
	fmt.Println(ford)
}

Ejemplo de uso de Structs con funciones (metodos). Calcluo de área y perimetro de un rectangulo dado ancho y alto(atributos)
fuente

package main

import "fmt"

type rect struct {
    width, height int
}

func (r *rect) area() int {
    return r.width * r.height
}

func (r rect) perim() int {
    return 2*r.width + 2*r.height
}

func main() {
    r := rect{width: 10, height: 5}

    fmt.Println("area: ", r.area())
    fmt.Println("perim:", r.perim())

    rp := &r
    fmt.Println("area: ", rp.area())
    fmt.Println("perim:", rp.perim())
}

Recuerdo los struct de C++

hola que ace solo el blanco más blanco lo hace

Que bonito Go, todo así estructurado así, bien bonito todo, ayyy me enamora, gocito bello.

Buen día este es mi aporte con una función.

package main

import "fmt"

type car struct {
	pilot string
	brand string
	year  int
	drive func(pilot string, brand string, year int) string
}

func main() {
	var myCar = car{pilot: "Mario Styven",
		brand: "Ford", year: 2020,
		drive: func(name string, brand string, year int) string {
			return fmt.Sprintf("Hola %s, estoy conduciendo en un %s modelo %d", name, brand, year)
		}}

	fmt.Println(myCar.drive(myCar.pilot, myCar.brand, myCar.year))

}

Muy interesante…

Bueno para mi que no había usado C, está bastante útil.

Los structs son la manera de definir una variable con diferentes tipos de datos. Parecen ser igual que en C.

package main

import "fmt"

type car struct {
	brand string
	year int
	color string
}



func main() {
	myCar := car{brand: "Ford", year: 2020}
	fmt.Println(myCar)

	var otherCar car
	otherCar.brand = "Ferrari"
	fmt.Println(otherCar)
}

type Car struct {
brand string
year int
color string
placa string
serial string
}

Lo veria como una entidad, como el ejemplo clasico de la universidad, la clase persona que tiene la informacion completa de alguien como sus nombres, apellidos, edad, numero de identificacion y direccion de residencia, lo interesante es ver que podemos acceder a estos campos establecidos dentro del struct con el “.”, aun me resulta confuso un poco dimensionar un Struct como una clase de POO ya que, si bien en teoria puedo en ambas interactuar con metodos (que no se si hablas de las funciones o hay metodos tambien) y acceder a campos, hay algo en usabilidad que cambia, continuemos con el curso a ver que tal!

CODIGO:

package main

import (
	"fmt"
)

type  car struct {
	brank string
	model string
	year int
	motor string
	cylinder string
	power string
	torque string
	gearbox string
	traction string
	color string
	seating int
}

func main() {
	myCar := car {
		brank: "Jeep",
		model: "Wrangler Unlimited Rubicon",
		year: 2020,
		motor: "V6 3.6L",
		cylinder: "3604 CC",
		power: "280 HP, 6400 RPM",
		torque: "35.4 Kgf.m @ 4100 rpm",
		gearbox: "Rock-Trac Active On Demand.",
		traction: "4x4",
		color: "Black",
		seating: 5,
	}
	fmt.Println("===============================")
	fmt.Println("brank =", myCar.brank)
	fmt.Println("model =", myCar.model)
	fmt.Println("year =", myCar.year)
	fmt.Println("moto =", myCar.motor)
	fmt.Println("cylinder = ", myCar.cylinder)
	fmt.Println("power =", myCar.power)
	fmt.Println("torque =", myCar.torque)
	fmt.Println("traction =", myCar.traction)
	fmt.Println("color = ", myCar.color)
	fmt.Println("seating = ", myCar.seating)
	fmt.Println("===============================")
}

RESULTADO:

===============================
brank = Jeep
model = Wrangler Unlimited Rubicon
year = 2020
moto = V6 3.6L
cylinder =  3604 CC
power = 280 HP, 6400 RPM
torque = 35.4 Kgf.m @ 4100 rpm
traction = 4x4
color =  Black
seating =  5
===============================
type Car struct {
	brand string
	year  int
	model string
	color string
	power float32
}