Tipos de Datos Primitivos en Go: Enteros, Flotantes y Booleanos
Contenido del curso
Juan Camilo Espitia
Santiago Marulanda Molina
Fernando Andres Prokopiuk
Carlos Eduardo Magallon Zepeda
IVAN DARIO CHIPATECUA CABEZAS
Miguel Andres Rendon Reyes
Platzi Team
Wilson Fernando Antury Torres
Kenyi Julberht Hancco Quispe
Fernando Borea
Fernando Andres Prokopiuk
Hernan Dario Perez Jaramillo
Kenyi Julberht Hancco Quispe
David Antonio Olivares Gonzalez
Usuario anónimo
User
Fernando Hernandez
Alejandro Martínez Valencia
Eduardo Rodriguez Cisneros
Juan Sebastián Caballero
Ana Sofía Aguirre
Henry J. Perez
Jonathan David Olivos
Wilson Fernando Antury Torres
Juan David Ayala Lizarazo
Daniel Miguel Ruiz Tinajero
Rogelio Toledo
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
El uint8 es en este rango //uint8 = 8bits = 0 a 255
Está mal la filmina de los enteros signados. Por ejemplo un int32 puede almacenar números de -2^15 a 2^15-1.
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) }
Estaría cool que añadieras con el perímetro
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 127int16 16bits ⇒ -2^15 a 2^15-1int32 32bits ⇒ -2^31 a 2^31-1int64 64bits ⇒ -2^63 a 2^63-1Optimizar memoria cuando sabemos que el dato siempre va ser positivo
uint ⇒ Depende del OS (32 o 64 bits)uint8 ⇒ 8bits = 0 a 127uint16 ⇒ 16bits = 0 a 2^15-1uint32 ⇒ 32bits = 0 a 2^31-1uint64 ⇒ 64bits = 0 a 2^63-1Números decimales
float32 ⇒ 32 bits = +/- 1.18e^-38 +/- -3.4e^38float64 ⇒ 64 bits = +/- 2.23e^-308 +/- -1.8e^308Textos y booleanos
string es permitido utilizar “”, ‘’ o ```` en Go solo podemos utilizar las comillas dobles ""Trueo FalseNúmeros complejos
Complex64 ⇒ Real e Imaginario float32Complex128 ⇒ Real e Imaginario float64Dependiendo 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.
Claro. Se llama complemento a 2
//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)
Para la formula del trapecio te recomendaría que uses float32 ya que por la fórmula en muchos casos al declararlas como enteras, no saldrá correctamente el resultado del área.
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 :O, 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
Yo te podría mencionar una en donde se utilizan numeros imaginarios en programación. Uno podría ser en analisis de audios. Para obtener las frecuencias que componen una señal de audio, se tiene que sacar la Transformada de Fourier, y en esencia se utilizan números complejos para describir cada onda componente. También, en otra aplicación más reciente es en simular procesadores cuánticos. Los estados de los Qubits (bits cuánticos) se hace con números complejos. Los bits clásicos solo pueden tomar dos valores: 0 ó 1. Pero los Qubits pueden tomar valores 0, 1 o una combinación compleja de ambos.
Yo uso los “uint” para trabajar con IDs de bases de datos
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
El %T en Go se utiliza dentro de la función fmt.Printf para imprimir el tipo de una variable. Esto es útil para depurar y entender qué tipo de datos estás manejando en tu código. Por ejemplo, si tienes una variable x, puedes usar fmt.Printf("El tipo de x es %T\n", x) para conocer su tipo exacto. Esta función mejora la claridad del código y ayuda a evitar errores de tipo.
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 :D 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.
restar entre valores uInt si el resultado es negativo el valor se va a ir al maximo de la variable y restara desde ahi en vez de quedarse en 0
var x uint8 = 1
var y uint8 = 3
fmt.Println("x:", x, " y:", y)
fmt.Println("x - y =", x-y)
x: 1 y: 3
x - y = 254
Se puede ahorrar memoria si en nuestro porgrama para guardar la edad solo se usa int8 al final nadie vive mas de lo que puede guardar el int8 127, o si no un valor que solo tenga 4 valores, si a aso se crearan muchos objetos de esto, y eso de los numero imaginarios me sorprende que se utilice en go, se usaria para cosas mas cientificas?
si yo solo defino una variable de esta forma:
a := 15
que entero toma por defecto, int8, int16, int32, int64, uint ??