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

A√ļn no tienes acceso a esta clase

Crea una cuenta y contin√ļa viendo este curso

Variables, constantes y zero values

7/36
Recursos

Aportes 39

Preguntas 12

Ordenar por:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi√≥n.

Resumen:

func main() {
	//Declaracion de constantes
	const pi float64 = 3.14
	const pi2 = 3.16

	fmt.Println("Pi:", pi)
	fmt.Println("Pi2:", pi2)

	//Declaracion de varaibles
	base := 12          //Primera forma
	var altura int = 14 //Segunda forma
	var area int        //Go no compila si las variables no son usadas

	fmt.Println(base, altura, area)

	//Zero values
	//Go asigna vaalores a variables vacías
	var a int
	var b float64
	var c string
	var d bool

	fmt.Println(a, b, c, d)

	//Ejercicio
	//Calcular el √°era del cuadrado
	const baseCuadrado = 10
	areaCuadrado := baseCuadrado * baseCuadrado

	fmt.Println("El √°rea del cuadrado es:", areaCuadrado)
}```

Wow, me encanta que Go tenga estas restricciones. Al inicio pueden ser algo frustrantes, pero con el tiempo te mejoran mucho como programador. ūüėĄ

Una manera de saltarte el error de compilación por no usar una variable, es utilizar el identificador en blanco:

var _ = miVariableSinUsar

Me parece incensario el frame azul al momento de compartir pantalla. Por lo dem√°s el curso va muy bien

Para mostrar en consola el tipo de valor que declaramos existe el paquete ‚Äúreflect‚ÄĚ ūüéĀ

package main

import (
  "fmt"
  "reflect"
)

func main() {
  age := 23
  fmt.Println(reflect.TypeOf(age))
}

Bueno me gustaria comentar que he dejado todo mi codigo y graficos en este repositorio:
https://github.com/UltiRequiem/Curso-Basico-de-Programacion-en-Go-de-Platzi

También se puede realizar la declaración de variables en grupos de forma declarativa e iterativa.

package main

import "fmt"

func main() {

	// Declaracion de constantes
	const pi float64 = 3.14
	const pi2 = 3.1415

	fmt.Println("pi", pi)
	fmt.Println("pi2", pi2)

	// Declaracion de variables entera
	var area int        //normal
	var altura int = 14 // iterativa
	base := 12          // iterativa

	fmt.Println("area", area)
	fmt.Println("altura", altura)
	fmt.Println("base:", base)

	//Forma en grupo
	var (
		i int
		h bool
		s string
	)

	i = 1
	h = true
	s = "un texto cualquiera"

	fmt.Println(i)
	fmt.Println(h)
	fmt.Println(s)

	x1, y2, z3 := 1, 2, 3
	fmt.Println(x1)
	fmt.Println(y2)
	fmt.Println(z3)

	// Zero values
	var a int     // 0
	var b float64 // 0
	var c string  // ""
	var d bool    // false

	fmt.Println(a, b, c, d)

	// Area cadrado
	const baseCuadrado = 10
	areaCuadrado := baseCuadrado * baseCuadrado
	fmt.Println("Area cuadrado", areaCuadrado)
}```

‚ú® Una constante a diferencia de una variable, el valor de este nunca cambiara en el tiempo.

Para la gente que venga de JavaScript, los valores Zero Values serían siendo los falsy values

constants

const <name> <type> = <value>

variables

var <name> <type> = <value>
or
<name> <type> := <value>

Zero values

Default values, not null, when no values assigned to variables nor constants.

Si no tienes instalado git para usar el comando git init puedes desde la terminal de VS code incluso usar

winget install --id Git.Git -e --source winget

se te instalara git, yo lo que tuve que hacer despues fue cerrar todo, el VS code y la ventana de CMD que tenia abierta y volver a abrir una nueva ventana de CMD con permisos de administrador para poder ejercutar los comandos de git.

	cons pi float64 = 3.14
	//Retos
	//Area de rectangulo, trapecio y circulo
	//circle
	var radius float64 = 3
	var circle_area float64 = pi * (radius * radius)
	fmt.Println("Area de un circulo:", circle_area)
	//rectangle
	var base_rectangulo int = 6
	var altura_rectangulo int = 4
	var rectangle_area int = base_rectangulo * altura_rectangulo
	fmt.Println("Area de un rectangulo: ", rectangle_area)
	//trapecio
	var base_trapecio1 int = 4
	var base_trapecio2 int = 8
	var altura_trapecio int = 3
	var area_trapecio int = ((base_trapecio1 + base_trapecio2) * altura_trapecio) / 2
	fmt.Println("Area de un trapecio: ", area_trapecio)

Los tipos de datos que Go soporta (por defecto) son:

  • bool (verdadero o falso)
  • string (cadenas de texto)
  • int y uint (enteros)
  • float (decimales)
  • complex (numeros complejos)

Tambien estan byte (que es un uint de 8 bits) y rune (int de 32 bits), pero no los incluyo por que son ‚Äúaliases‚ÄĚ de int.

	// Perimetro de un triangulo
	const aSide int = 2
	const bSide int = 4
	const cSide int = 5

	if aSide+bSide > cSide {
		perimetTriangle := aSide + bSide + cSide
		fmt.Printf("Solution is P=aSide+bSide+cSide = %d + %d + %d = %d\n", aSide, bSide, cSide, perimetTriangle)
	} else {
		fmt.Println("Invalid input: make surea+b>c")
	}
// √°rea del cuadrado en Go :
package main

import "fmt"

func main(){
	const baseCuadrado int =10
	areaCuadrado:= baseCuadrado*baseCuadrado
	   fmt.Println(`El √°rea del cuadrado es : `, areaCuadrado)
}

Les recomiendo una extension que les dice el tipo de error sin ejecutar Go, digamos que hace validaciones en tiempo real es Error Lens

yo no veo limitantes en go, me esta gustando muchisimo el lenguaje, ojala en un futuro volverme un experto en este lenguaje, ya que le tome bastante cari√Īo.

Pueden usar Ctrl + Alt +N para ejecutar el codigo, disponible para los que usan VSC en windows

Me gusta esta forma de usar variables si llegase a haber un error puedes analizar tus variables mas rapido, lo malo es tener que comentar variables que no usas
ya veo mi codigo con una monta√Īa de variables comentadas
package main

import "fmt"

func main() {
	//Declaración de constantes
	const pi float64 = 3.14
	const pi2 = 3.1415

	fmt.Println("Pi: ", pi)
	fmt.Println("Pi2: ", pi2)

	//Declaración de variables enteras
	base := 12
	var altura int = 14
	var largo int

	fmt.Println(base, altura, largo)

	//Zero values
	var a int
	var b float64
	var c string
	var d bool

	fmt.Println(a,b,c,d)

	//√Ārea de un cuadrado

	const baseCuadrado int = 10
	areaCuadrado := baseCuadrado * baseCuadrado

	fmt.Println("El √°rea del cuadrado de base:",baseCuadrado,"es:",areaCuadrado)
}

Si no usas una variable en lugar de comentarla o imprimirla en consola yo te aconsejaría que la BORRES!

Es necesario tener en cuenta los zeros values. Estos valores son dados a variables que no tienen valor tadavía. Y en vez de que sea null, None u otra cosa, en este caso es: 0.

Go, no nos deja declarar variables y no utilizarlas. Variable que se declara, variable que se usa.

Para declarar variables enteras: number := 12 , var height int = 14, var area int.

Se puede concatenar mensajes de manera muy sencilla.

En la sintaxis, es correcto dejar un espacio después del operador de igualdad.

Ponemos la variable o tipo de puntero, luego su nombre y luego su tipo.

Los constantes nunca cambian con el tiempo. No los puedes reinicializar.

definimos constantes, con el kwrd: const

Para una sola línea de comentario, ponemos el //

Hola. Les comparto otra manera interactiva de tener el código de la clase. Han de ejecutarlo para ver la gracia.

Deseo les sea de utilidad.

Constantes:

package main

import "fmt"

func main() {

	//Declaración de constantes y ejercicio con las impresiones en consola.
	//**********************************************************************

	const pi float64 = 3.14159
	fmt.Print("\nconst pi float64 = 3.14159 >>> Declaración de constante fuertemente tipada,",
		"haciendo explícito el tipo de dato.\n\n")

	const pi2 = 3.14
	fmt.Println("const pi2 = 3.14 >>> Declaración fuertemente tipada pero con tipo definido implícitamente")

	fmt.Println()

	fmt.Println("fmt.Println() >>> Así no mas se logra un salto de línea sin imprimir nada.")
	fmt.Println()

	fmt.Println("fmt.Println(\"pi1 =\", pi) => Así imprime un valor y da un salto de línea")
	fmt.Println("pi1 =", pi)
	fmt.Println()

	fmt.Println("fmt.Println(\"pi1 =\", pi) >>> No se concatena con un + sino que se pone coma.",
		"No se define en la cadena de texto un punto donde poner el valor.",
		"Luego de cada coma resulta dando un espacio en blanco, ejemplo: 'hola_mundo'")
	fmt.Println("pi1 =", pi)
	fmt.Println()

	fmt.Println("fmt.Println(pi, pi2) >>> imprime el primer valor, un espacio y el segundo en la misma línea.")
	fmt.Println(pi, pi2)
	fmt.Println()
}

Declaración de variables:

package main

import "fmt"

func main() {

	//Declaración de Variables
	//***********************************

	fmt.Println()
	fmt.Println("Declaración de variables enteras.")
	fmt.Println("*********************************")
	fmt.Println()

	var altura int = 14
	fmt.Println("var altura int = 14 >>> Declaración explícita. Además se asigna un valor.")
	fmt.Println("Altura:", altura)
	fmt.Println()

	var area int
	fmt.Println("var area int >>> Declaración explícita de variable, sin asignación")
	fmt.Println("area:", area, "Nunca le asigné un valor, pero internamente toma un 'zero value'.")
	fmt.Println()

	base := 12
	fmt.Println("base := 12 >>> Dos puntos significa declaración de variable, el igual hace la asignación del valor")
	fmt.Println("El valor de 'base' es:", base, "esto ha sido a partir de una declaración implícita")
	fmt.Println()

	area = base * altura
	fmt.Println("area = base * altura >>> Así hice la operación")
	fmt.Println("Area:", area)
	fmt.Println()
}

Zero Values:

package main

import "fmt"

func main() {

	//Valores por defecto

	fmt.Println()
	fmt.Println("Valores por defecto")
	fmt.Println("*******************")
	fmt.Println()

	var a int
	var b float64
	var c string
	var d bool

	fmt.Println("var a int >>>", a)
	fmt.Println("var b float64 >>>", b)
	fmt.Println("var c string >>>", c)
	fmt.Println("var d bool >>>", d)
}

Mezclando constantes y variables:

package main

import "fmt"

func main() {

	//Combinando variables y constantes:

	fmt.Println()
	fmt.Println("Combinando variables y constantes")
	fmt.Println("*********************************")
	fmt.Println()

	const baseCuadrado = 10
	fmt.Println("const baseCuadrado = 10")

	areaCuadrado := baseCuadrado * baseCuadrado
	fmt.Println("areaCuadrado := baseCuadrado * baseCuadrado")

	fmt.Println("areaCuadrado:", areaCuadrado)
}
package main

import "fmt"

func main() {
	// Declaracion de constantes
	const pi float64 = 3.1415
	const pi2 = 3.14

	fmt.Println("pi", pi)
	fmt.Println("pi2", pi2)

	// Declaracion de variables enteras
	base := 12
	var altura int = 14
	var area int

	fmt.Println(base, altura, area)

	// Zero values
	var a int
	var b float64
	var c string
	var d bool

	fmt.Println(a, b, c, d)

	// Area de un cuadrado
	const baseCuadrada = 10
	areaCuadrado := baseCuadrada * baseCuadrada

	fmt.Println("Area cuadrado:", areaCuadrado)

}

Zero values: valores por defecto que toman las variables al ser declaradas pero sin asignación de valor inicial.

  • int: 0
  • float: 0
  • string: ‚Äú‚ÄĚ (empty string)
  • bool: false

Quiero compartir el siguiente error que aparece en la línea

package main

gopls requires a module at the root of your workspace.
You can work with multiple modules by opening each one as a workspace folder.
Improvements to this workflow will be coming soon, and you can learn more here:
https://github.com/golang/tools/blob/master/gopls/doc/workspace.md.go list

Agradezco cualquier sugerencia al respecto. ūüöÄ

Les dejo el codigo para calcular el area de un cuadrado:

package main

import "fmt"

func main() {
	// Area de un cuadrado
	const baseCuadrado int = 24
	areaCuadrado := baseCuadrado * baseCuadrado

	fmt.Println("El √°rea del cuadrado vale: ", areaCuadrado)

}

Me funciona sin declarar el tipo de variable, lo cual entiendo que poner el tipo de variable es una buena practica.

        //Zero values
        var a int
        var b float64
        var c string
        var d bool

        fmt.Println("\na int:", a,"\nb float64:", b,"\nc string:", c,"\nd bool:", d)