Tipos de datos primitivos

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

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

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

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)

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.

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

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

📦 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

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

No se puede hacer operaciones matemáticas entre números de diferente tipos (por ejemplo int y uint).

Aquí esta una referencia de como se vería esta clase en código (admito que los float y los complex se me hicieron difíciles de representar):

Les dejo mis apuntes 😄
If you specify the type of data, the program will be more efficient

package main

import (
	"fmt"
	"math"
)

func main() {
	//PRIMITIVE DATA TYPES

	//ints : Integer
	{
		//int
		var a int = 1 //Depending on the OS it will assign 32 or 64 bits
		//int8
		var b int8 = -128 //8 bits (-128 to 127)
		//int16
		var c int16 = -int16(math.Pow(2, 15)) //16 bits (-2^15 to 2^15-1)
		//int32
		var d int32 = -int32(math.Pow(2, 31)) //32 bits (-2^31 to 2^31-1)
		//int64
		var e int64 = -int64(math.Pow(2, 63)) //64 bits (-2^63 to 2^63-1)
		fmt.Println(a, " ", b, " ", c, " ", d, " ", e)
	}

	//uint : Positive Integer
	{
		//uint
		var a uint //Depending on the OS it will assign 32 or 64 bits
		//uint8
		var b uint8 = uint8(math.Pow(2, 8)) - 1 //8 bits (0 to 2^8 - 1)
		//uint16
		var c uint16 = uint16(math.Pow(2, 16)) - 1 //16 bits (0 to 2^16 - 1)
		//int32
		var d uint32 = uint32(math.Pow(2, 32)) - 1 //32 bits (0 to 2^32 - 1)
		//uint64
		var e uint64 = uint64(math.Pow(2, 64)) - 1 //64 bits (0 to 2^64 - 1)
		fmt.Println(a, " ", b, " ", c, " ", d, " ", e)
	}

	//float: decimal numbers
	{
		var a float32 = 3.4e38  //32 bits - +/- 1.18e-38 to +/- 3.4e38
		var b float64 = 1.8e307 //64 bits - +/- 2.23e-308 to +/- 1.8e308
		fmt.Println(a, " ", b, " ")
	}

	//string: text
	{
		var a string = "Hello World" // string must be declared with "" and not with any other type of commas
		fmt.Println(a)
	}

	//bool: true or false
	{
		var a bool = true
		var b bool = false
		fmt.Println(a, " ", b, " ")
	}

	//complex: complex numbers
	{
		var a complex64 = 10 + 10i      //Real part and imaginary, both float32
		var b complex128 = 1000 + 2000i //Real part and imagniary, both float64
		fmt.Println(a, " ", b, " ")
	}
}

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

Solo agregando que es importante ver que son los alias y como crear tus propios tipos de variables.

Esto porque existe la runa (rune)

package main

import "fmt"

func main() {
	// Calcular el área de un cuadrado. Formula: base * base
	const baseCuadrado = 10
	areaCuadrado := baseCuadrado * baseCuadrado
	fmt.Println("areaCuadrado:", areaCuadrado)

	// Calcular el área de un triangulo. Formula: (base * altura) / 2
	const baseTriangulo = 10
	const alturaTriangulo = 25
	areaTriangulo := (baseTriangulo * alturaTriangulo) / 2
	fmt.Println("areaTriangulo:", areaTriangulo)

	// Calcular el área de un circulo. Formula: pi * (radio * radio)
	const pi = 3.14
	const radioCirculo = 4
	areaCirculo := pi * (radioCirculo * radioCirculo)
	fmt.Println("areaCirculo:", areaCirculo)

	// Calcular el área de un trapecio. Formula: (altura * (baseMayor + baseMenor))/ 2
	const alturaTrapecio = 50
	const baseTrapecioMayor = 18
	const baseTrapecioMenor = 7
	areaTrapecio := (alturaTrapecio * (baseTrapecioMayor + baseTrapecioMenor)) / 2
	fmt.Println("areaTrapecio:", areaTrapecio)

}

Creo que la afirmación de que se gana un buen perfomance en tu código en caso de poner los tipos no es muy acertada.

Los tipos son inferidos en tiempo de compilación, por lo que no debe haber diferencia en tiempo de ejecución.

Reto clase anterior:

// Rectángulo
	var baseR int = 10
	var alturaR int = 50

	result = baseR * alturaR

	fmt.Println("Rectangulo:", result)

	// Trapecio
	var baseMenor int = 10
	var baseMayor int = 50
	var alturaT int = 5

	result = ((baseMayor + baseMenor) / 2) * alturaT

	fmt.Println("Trapecio:", result)

	// Circulo

	resultF := math.Pi * math.Pow(5, 2)

	fmt.Println("Circulo:", resultF)

Se lee bastante razonable el manejo de tipos de datos, simple y sustancioso

// 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

}

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

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