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

Tipos de datos primitivos

9/36
Recursos

Aportes 33

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

un resumito suave por si necesitan
//tipos de datos primitivos

//Numeros enteros
//int = Depende del OS (32 o 64 bits)
//int8 = 8bits = -128 a 127
//int16 = 16bits = -2^15 a 2^15-1
//int32 = 32bits = -2^31 a 2^31-1
//int64 = 64bits = -2^63 a 2^63-1

//Optimizar memoria cuando sabemos que el dato simpre va ser positivo
//uint = Depende del OS (32 o 64 bits)
//uint8 = 8bits = 0 a 127
//uint16 = 16bits = 0 a 2^15-1
//uint32 = 32bits = 0 a 2^31-1
//uint64 = 64bits = 0 a 2^63-1

//numeros decimales
// float32 = 32 bits = +/- 1.18e^-38 +/- -3.4e^38
// float64 = 64 bits = +/- 2.23e^-308 +/- -1.8e^308

//textos y booleanos
//string = ""
//bool = true or false

//numeros complejos
//Complex64 = Real e Imaginario float32
//Complex128 = Real e Imaginario float64
//Ejemplo : c:=10 + 8i

Reto calcular areas

package main

import (
	"fmt"
	"math"
)

func main()  {
	// Rectangle
	var high = 5
	var width = 6
	var result = high * width
	fmt.Println("Rectangle area is:", result)
	// Trapezoid
	var baseA = 38.0
	var baseB = 18.0
	var high2 = 7.0
	var result2 = ((baseA + baseB) / 2.0) * high2
	fmt.Println("Trapezoid area is:", result2)
	// Circle
	var radio = 7.0
	var result3 = math.Pi * math.Pow(radio, 2)
	fmt.Println("Circle area is:", result3)
}

Donde estaban esta clase de profesores cuando estaba en la universidad 😦, excelente clase.

  • int8/16/32/64: indica el tipo de dato “int” con signo, y además el tamaño del dato.
  • uint8/16/32/64: indica el tipo de dato “int” pero sin signo(solo positivos) y además el tamaño máximo del dato
  • int / uint : toma el tamaño de bits en el que está basado el procesador (con signo / sin signo)
  • float32: 32 bits con signo
  • float64: 64 bits con signo
  • string: se deben declarar con comillas dobles “”
  • bool: true o false
    WOW
  • complex64: números complejos (real e imaginario float32)
  • complex128: números complejos (real e imaginario float64)

Probablemente ya lo saben, pero la “u” en uint, viene de “unsigned”, es decir, sin signo, por lo que se refiere a números siempre positivos, para que puedan recordarlo fácil.

//Reto: Encontrar el area de un rectanculo, trapecio y de un circulo

base = 15
altura = 20
var base2 = 10
var radio = 11.0

//Area de un rectangulo
var areaRectangulo int = base * altura
fmt.Println("Area rectangulo: ", areaRectangulo)

//Area de un trapecio
var areaTrapecio int = (base + base2) * altura / 2
fmt.Println("Area del trapecio: ", areaTrapecio)

//Area de un circulo
var areaCirculo = math.Pi * math.Pow(radio, 2)
fmt.Println("Area del circulo: ", areaCirculo)

Dependiendo del tipo de cálculo que se quiera realizar.
Por ejemplo yo usaría uint8 para declarar edades, esto con el fin de optimizar recursos.

La razón de porqué en los intX se almacena un bit menos (int16 se almacenan hasta 2 ^ 15 dígitos) pero para los uintX se almacena la misma cantidad de bits (int16 almacena hasta 2^16 dígitos) es porque en el caso de los int, ya que permiten valores negativos, se reserva un bit en la memoria para indicar si el número que estamos almacenando es positivo o no, mientras que para los uint, ya que implícitamente indicamos que sólo son datos positivos, este bit se usa para almacenar el valor en sí. El -1 del final viene para considerar el zero-value.

Ejemplo de implementación de la mayoría de tipos:

//Data Types
	var shortInt int8 = 3
	var longInt int64 = 2313212113234256876
	var shortFloat float32 = 3.1
	var longFloat float64 = 3.153465212456432145668723312
	var text string = "string"
	var boolean bool = true
	var complex complex128 = 10 + 8i

📦 Para comenzar a trabajar con números complejos en Go, debemos implementar el siguiente paquete:

import "math/cmplx"

@osmandi ¿Dónde usarías los números complejos?, algún caso de uso para estudiar

Usar tipado en el código de Go puede mejorar el rendimiento.

// como quedaría en GO para presentar estos datos
// tendría que importar math y usar math.Exp y math.Exp2
// según se vé
// por otro lado si pongo 1.8e308 me dá error de overflow, por ello pongo 1.70e308

package main

import (
“fmt”
“math”
)

func main() {
// Numeros enteros
fmt.Println(“Numeros enteros”)
// int = depende del OS (32 o 64 bits)
fmt.Println(“int = depende del OS (32 o 64 bits)”)
// int8 = 8 bits = -128 a 127
fmt.Println("int8 = 8 bits = ", -math.Exp2(7), "a ", math.Exp2(7)-1)
// int16 = 16 bits = -2^15 a 2^15 -1
fmt.Println("int16 = 16 bits = ", -math.Exp2(15), "a ", math.Exp2(15)-1)
// int32 = 32 bits = -2^31 a 2^31 -1
fmt.Println("int32 = 32 bits = ", -math.Exp2(31), "a ", math.Exp2(31)-1)
// int64 = 64 bits = -2^63 a 2^63 -1
fmt.Println("int64 = 64 bits = ", -math.Exp2(63), "a ", math.Exp2(63)-1)

// Numeros enteros positivos
fmt.Println("Números enteros positivos")
// uint = depende del OS (32 o 64 bits)
fmt.Println("depende del OS (32 o 64 bits)")
// uint8 = 8 bits = 0 a 2^8 -1
fmt.Println("uint8 = 8 bits = ", 0, "a ", math.Exp2(8)-1)
// uint16 = 16 bits = 0 a 2^16 -1
fmt.Println("uint16 = 16 bits = ", 0, "a ", math.Exp2(16)-1)
// uint32 = 32 bits = 0 a 2^32 -1
fmt.Println("uint32 = 32 bits = ", 0, "a ", math.Exp2(32)-1)
// uint64 = 64 bits = 0 a 2^64 -1
fmt.Println("uint64 = 64 bits = ", 0, "a ", math.Exp2(64)-1)

// Numeros decimales
fmt.Println("Numeros decimales")
// float32 = 32 bits = +/- 1.18 10^(-38) a +/- 3.4 10^(38)
fmt.Println("float32 = 32 bits = +/-", 1.18e-38, "a  +/-", 3.4e38)
// float64 = 64 bits = +/- 2.23 10^(-308) a +/- 1.8 10^(308)
fmt.Println("float64 = 64 bits = +/-", 2.23e-308, "a  +/-", 1.79e308)

// Textos y boleanos
fmt.Println("Textos y boleanos")
// string =""
fmt.Println("string =")
// bool = true o false
fmt.Println("bool = true o false")

// Números complejos
fmt.Println("Números complejos")
// Complex64 = Real e imaginario float32
fmt.Println("// Complex64 = Real e imaginario float32")
// Complex128 = Real e imaginario float64
fmt.Println("Complex128 = Real e imaginario float64")
// Ejemplo c:= 10 + 8i

}

Valores Primitivos


Al codificar en Go podemos especificar el tipo de dato, permitiéndonos ganar gran preformas en nuestro código

Números Enteros

int Cuando no se declara el tamaño tomara la referencia del OS (Sistema operativo) (32 o 64 bits)

  • int8 8bits ⇒ -128 a 127
  • int16 16bits ⇒ -2^15 a 2^15-1
  • int32 32bits ⇒ -2^31 a 2^31-1
  • int64 64bits ⇒ -2^63 a 2^63-1

Optimizar memoria cuando sabemos que el dato siempre va ser positivo

  • uint ⇒ Depende del OS (32 o 64 bits)
  • uint8 ⇒ 8bits = 0 a 127
  • uint16 ⇒ 16bits = 0 a 2^15-1
  • uint32 ⇒ 32bits = 0 a 2^31-1
  • uint64 ⇒ 64bits = 0 a 2^63-1

Números decimales

  • float32 ⇒ 32 bits = +/- 1.18e^-38 +/- -3.4e^38
  • float64 ⇒ 64 bits = +/- 2.23e^-308 +/- -1.8e^308

Textos y booleanos

  • A diferencia de otros lenguajes de programación donde para definir una variable de tipo string es permitido utilizar “”, ‘’ o ```` en Go solo podemos utilizar las comillas dobles ""
  • boolean ⇒ Trueo False

Números complejos

  • Complex64 ⇒ Real e Imaginario float32
  • Complex128 ⇒ Real e Imaginario float64

tipar tu código es característica de un buen profesional de la programación.

js por ejemplo, acepta comillas francesas o comillas dobles, GO únicamente acepta comillas dobles para tipos string o de cadena …

Repaso para los identificadores

no se si a alguien mas se le ocurrió el experimento de restar un numero de tipo uint a otro del mismo tipo pero menor, jsjsjs

yo lo hice y todos los bits que queden en 0 se vuelven unos, y si el numero resultante es mayor a -1 entonces se resta del total de bits y el numero es menor 😮, no se como explicarlo pero por ejemplo si restamos 10 - 11 el resultado es 255 si es que usaron uint8
fantastico jaja

Reto realizado de la anterior clase:

package main

import (
	"fmt"
	"math"
)

func main(){

	const base = 80
	const base_menor = 40
	const altura = 90

	const radio = 10

	// Réctangulo:
	areaRect := base * altura
	fmt.Println("Rectángulo = ", areaRect)

	// Trapecio:
	areaTrap := (base + base_menor) / 2 * altura
	fmt.Println("Trapecio = ", areaTrap)

	// Círculo:
	areaCirc := (3.14 * math.Pow(radio, 2))
	fmt.Println("Círculo = ", areaCirc)

}```

Interesante!

package main

import (
	"fmt"
	"math"
)

func main() {
	// Area cuadrado
	const baseCuadrado = 100
	areaCuadrado := baseCuadrado * baseCuadrado
	fmt.Println("Area cuadrado:", areaCuadrado)

	// Area rectangulo
	const baseRectangulo = 50
	const alturaRectangulo = 30
	areaRectangulo := baseRectangulo * alturaRectangulo
	fmt.Println("Area rectangulo:", areaRectangulo)

	// Area circulo
	var radioCirulo float64 = 30
	areaCirculo := math.Pi * math.Pow(radioCirulo, 2)
	fmt.Println("Area circulo:", areaCirculo)
}


Para los números complejos tenemos: Complex64, que equivale a un real e imaginario float32 y el Comples128, que contiene real e imaginario float64,

string y boolean no es muy diferente a los demás lenguajes. sin embargo, algo a tener en cuenta es que para los strings, solo puedes usar comillas dobles.

En números decimales, tenemos dos: float32 = +/- 1.18e⁻³⁸ a +/- 3.4e³⁸, float64 = +/- 2.23e⁻³⁰⁸ a +/-1.8e³⁰⁸

uint8 = 0 a 2⁸-1, uint16 = 0 a 2¹⁶-1, uint32 = 0 a 2³² -1 y uint64 = 0 a 2⁶⁴-1

uint = Nuevamente depende del OS.

int64 es prácticamente lo mismo pero elevado a 63, int64 = -2⁶³ hasta 2⁶³-1

Luego tenemos que puedes guardar de 16 bits: int16 que almacena números de -2¹⁵ a 2¹⁵-1

Tenemos que podemos separar espacio en memoria para enteros de 8 bits, osea que podemos almacenar del -128 al 127.

El int a secas, es un número que va a tomar 32 o 64 bits, depediendo de tu OS.

En go la forma de declarar variables, es muy flexible, ya que podemos simplemente hacer todo como en python o podemos especificar que tipo en específico de dato queremos.

Hola. Repaso interactivo de la clase. Ejecutar para verle el sentido

package main

import "fmt"

func main() {

	fmt.Println()
	fmt.Println("Operaciones aritméticas")
	fmt.Println("***********************")
	fmt.Println()

	fmt.Println("Se declaran 2 variables:")

	x := 10
	fmt.Println("x := 10")

	y := 50
	fmt.Println("y := 50")

	fmt.Println()
	fmt.Println("suma := x + y")
	resultado := x + y

	fmt.Println("Suma:", resultado)

	fmt.Println()
	fmt.Println("resta = y - x >>> es decir:", y-x, ". Esto se hizo todo dentro de un Println")

	fmt.Println()
	fmt.Println("Se reutiliza la variable inicial en el código fuente:")
	fmt.Println("Resta = y - x")
	resultado = y - x

	fmt.Println("Resta:", resultado)

	fmt.Println()
	fmt.Println("multiplicación := x * y")
	resultado = x * y

	fmt.Println("Multiplicación:", resultado)

	fmt.Println()
	fmt.Println("División = y / x >>> Parte Entera")
	resultado = y / x

	fmt.Println("ParteEntera:", resultado)

	fmt.Println()
	fmt.Println("División = y % x >>> Módulo")
	resultado = y % x

	fmt.Println("Residuo:", resultado)

	fmt.Println()
	fmt.Println("Incremental = x++")
	x++

	fmt.Println("Incrementando X:", x)

	fmt.Println()
	fmt.Println("División = y / x >>> (50 / 11) Parte Entera")
	resultado = y / x

	fmt.Println("ParteEntera:", resultado)

	fmt.Println()
	fmt.Println("División = y % x >>> (50 % 11) Módulo")
	resultado = y % x

	fmt.Println("Residuo:", resultado)

	fmt.Println()
	fmt.Println("Decremental = x--")
	x--

	fmt.Println("Incrementando X:", x)
}

interesante esta clase