No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Tipos de datos primitivos

9/36
Recursos

Aportes 40

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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

Probablemente ya lo saben, pero la 鈥渦鈥 en uint, viene de 鈥渦nsigned鈥, 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)
}

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

  • int8/16/32/64: indica el tipo de dato 鈥渋nt鈥 con signo, y adem谩s el tama帽o del dato.
  • uint8/16/32/64: indica el tipo de dato 鈥渋nt鈥 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.

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

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

@osmandi 驴D贸nde usar铆as los n煤meros complejos?, alg煤n caso de uso para estudiar

Yo uso los 鈥渦int鈥 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

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

馃摝 Para comenzar a trabajar con n煤meros complejos en Go, debemos implementar el siguiente paquete:

import "math/cmplx"

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

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 (
鈥渇mt鈥
鈥渕ath鈥
)

func main() {
// Numeros enteros
fmt.Println(鈥淣umeros enteros鈥)
// int = depende del OS (32 o 64 bits)
fmt.Println(鈥渋nt = 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

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