Curso Go #2: Variables, Tipos de Datos y Constantes en Go
Introduccion: Variables y Tipos en Go - Parte 2 de 10
Bienvenido a la Parte 2 de 10 del Curso de Go desde Cero. En el articulo anterior instalamos Go y escribimos nuestro primer programa Hola Mundo. Ahora vamos a aprender los conceptos fundamentales que usaras en absolutamente todos los programas que escribas: variables, tipos de datos y constantes.
Go es un lenguaje de tipado estatico, lo que significa que cada variable tiene un tipo definido en tiempo de compilacion. Esto puede parecer restrictivo al principio si vienes de lenguajes como Python o JavaScript, pero es una ventaja enorme: el compilador atrapa errores antes de que tu programa se ejecute.
Tipos de datos basicos en Go
Go tiene un conjunto de tipos primitivos bien definidos. Estos son los que usaras con mas frecuencia:
Tipos numericos enteros
| Tipo | Tamano | Rango |
|---|---|---|
int | 32 o 64 bits (depende de la plataforma) | Numero entero con signo |
int8 | 8 bits | -128 a 127 |
int16 | 16 bits | -32768 a 32767 |
int32 | 32 bits | -2 mil millones a 2 mil millones |
int64 | 64 bits | Rango muy amplio |
uint | 32 o 64 bits | Solo numeros positivos |
Tipos numericos decimales
| Tipo | Precision |
|---|---|
float32 | Precision simple (7 digitos) |
float64 | Precision doble (15 digitos) - el mas usado |
Otros tipos fundamentales
string: Cadena de texto (inmutable en Go)bool: Valor booleano (trueofalse)byte: Alias deuint8, usado para datos binariosrune: Alias deint32, representa un caracter Unicode
1package main
2
3import "fmt"
4
5func main() {
6 var entero int = 42
7 var decimal float64 = 3.14159
8 var texto string = "Hola Go"
9 var activo bool = true
10 var letra byte = 'A'
11 var emoji rune = '🚀'
12
13 fmt.Println(entero, decimal, texto, activo, letra, string(emoji))
14}int para enteros y float64 para decimales. Solo usa tipos con tamano especifico (int32, int64) cuando necesites control preciso sobre la memoria o estes trabajando con APIs que lo requieran.
Declaracion de variables: var y :=
Go ofrece varias formas de declarar variables. Veamos cada una:
Declaracion con var (forma larga)
1package main
2
3import "fmt"
4
5func main() {
6 // Declaracion con tipo explicito y valor
7 var nombre string = "Carlos"
8 var edad int = 30
9
10 // Declaracion con tipo pero sin valor (usa el valor cero)
11 var salario float64
12 var casado bool
13
14 // Declaracion multiple en un bloque
15 var (
16 ciudad string = "Ciudad de Mexico"
17 pais string = "Mexico"
18 codigo int = 52
19 )
20
21 fmt.Println(nombre, edad)
22 fmt.Println("Salario:", salario, "Casado:", casado)
23 fmt.Println(ciudad, pais, codigo)
24}Declaracion corta con := (la mas usada)
Dentro de funciones, puedes usar el operador := para declarar e inicializar variables de forma concisa. Go infiere el tipo automaticamente:
1package main
2
3import "fmt"
4
5func main() {
6 nombre := "Ana" // Go infiere: string
7 edad := 25 // Go infiere: int
8 peso := 65.5 // Go infiere: float64
9 esEstudiante := true // Go infiere: bool
10
11 fmt.Printf("Nombre: %s, Edad: %d, Peso: %.1f, Estudiante: %t\n",
12 nombre, edad, peso, esEstudiante)
13}:= solo funciona dentro de funciones. No puedes usarlo a nivel de paquete (fuera de funciones). Para variables a nivel de paquete, debes usar var.
Declaracion multiple en una linea
1package main
2
3import "fmt"
4
5func main() {
6 // Multiples variables del mismo tipo
7 var a, b, c int = 1, 2, 3
8
9 // Multiples variables con :=
10 x, y, z := "hola", 42, true
11
12 fmt.Println(a, b, c)
13 fmt.Println(x, y, z)
14}Valores cero (zero values)
En Go, toda variable declarada sin un valor inicial recibe automaticamente un valor cero segun su tipo. Esto es diferente a otros lenguajes donde las variables no inicializadas contienen basura de memoria o lanzan errores.
| Tipo | Valor cero |
|---|---|
int, float64 | 0 |
string | "" (cadena vacia) |
bool | false |
| Punteros, slices, maps | nil |
1package main
2
3import "fmt"
4
5func main() {
6 var entero int
7 var decimal float64
8 var texto string
9 var booleano bool
10
11 fmt.Printf("int: %d\n", entero) // 0
12 fmt.Printf("float64: %f\n", decimal) // 0.000000
13 fmt.Printf("string: '%s'\n", texto) // ''
14 fmt.Printf("bool: %t\n", booleano) // false
15}Inferencia de tipos
Cuando usas := o var sin tipo explicito, Go infiere el tipo basandose en el valor asignado:
1package main
2
3import "fmt"
4
5func main() {
6 a := 42 // int (no int8, no int32, siempre int)
7 b := 3.14 // float64 (no float32)
8 c := "Go" // string
9 d := true // bool
10 e := 'A' // rune (int32), no byte
11
12 fmt.Printf("a: %T\n", a) // int
13 fmt.Printf("b: %T\n", b) // float64
14 fmt.Printf("c: %T\n", c) // string
15 fmt.Printf("d: %T\n", d) // bool
16 fmt.Printf("e: %T\n", e) // int32
17}El verbo %T del paquete fmt imprime el tipo de una variable. Es muy util para depuracion.
int para enteros (no int32 ni int64) y float64 para decimales (no float32). Si necesitas otro tipo especifico, debes declararlo explicitamente.
Constantes con const e iota
Las constantes son valores que no cambian durante la ejecucion del programa. Se declaran con la palabra clave const:
1package main
2
3import "fmt"
4
5func main() {
6 const pi float64 = 3.14159265358979
7 const appName = "MiApp"
8 const maxReintentos = 3
9
10 fmt.Println("App:", appName)
11 fmt.Println("Pi:", pi)
12 fmt.Println("Max reintentos:", maxReintentos)
13
14 // Esto causaria un error de compilacion:
15 // pi = 3.14 // cannot assign to pi
16}Constantes con iota
iota es un generador de constantes enumeradas en Go. Empieza en 0 y se incrementa automaticamente en cada linea dentro de un bloque const:
1package main
2
3import "fmt"
4
5// Dias de la semana como constantes enumeradas
6const (
7 Domingo = iota // 0
8 Lunes // 1
9 Martes // 2
10 Miercoles // 3
11 Jueves // 4
12 Viernes // 5
13 Sabado // 6
14)
15
16// Tamanos de archivo usando iota con expresiones
17const (
18 _ = iota // ignorar el primer valor (0)
19 KB = 1 << (10 * iota) // 1 << 10 = 1024
20 MB // 1 << 20 = 1048576
21 GB // 1 << 30 = 1073741824
22 TB // 1 << 40
23)
24
25func main() {
26 fmt.Println("Lunes:", Lunes)
27 fmt.Println("Viernes:", Viernes)
28 fmt.Println("1 KB =", KB, "bytes")
29 fmt.Println("1 MB =", MB, "bytes")
30 fmt.Println("1 GB =", GB, "bytes")
31}iota es la forma idiomatica de Go para crear enumeraciones. Otros lenguajes tienen enum como palabra clave, pero Go usa const + iota para lograr lo mismo de forma mas flexible.
Conversion de tipos (casting)
Go es estricto con los tipos: no hay conversiones implicitas entre tipos diferentes. Debes convertir explicitamente:
1package main
2
3import "fmt"
4
5func main() {
6 // Conversion entre numericos
7 var entero int = 42
8 var decimal float64 = float64(entero)
9 var pequeno int32 = int32(entero)
10
11 fmt.Println(entero, decimal, pequeno)
12
13 // Conversion entre string y numeros
14 // Necesitas el paquete strconv
15 var num int = 65
16 var letra string = string(num) // Esto da "A" (caracter ASCII), NO "65"
17 fmt.Println("string(65):", letra) // A
18
19 // Para convertir un numero a su representacion en texto:
20 // usa fmt.Sprintf o strconv.Itoa
21 texto := fmt.Sprintf("%d", num)
22 fmt.Println("Sprintf:", texto) // "65"
23}string(65) no da "65", sino "A" (el caracter Unicode 65). Para convertir un numero a texto, usa fmt.Sprintf("%d", numero) o strconv.Itoa(numero). Este es un error muy comun en principiantes de Go.
Conversiones con strconv
1package main
2
3import (
4 "fmt"
5 "strconv"
6)
7
8func main() {
9 // Entero a string
10 edad := 25
11 edadTexto := strconv.Itoa(edad)
12 fmt.Println("Edad como texto:", edadTexto)
13
14 // String a entero
15 texto := "42"
16 numero, err := strconv.Atoi(texto)
17 if err != nil {
18 fmt.Println("Error:", err)
19 } else {
20 fmt.Println("Numero:", numero)
21 }
22
23 // String a float64
24 precioTexto := "19.99"
25 precio, err := strconv.ParseFloat(precioTexto, 64)
26 if err != nil {
27 fmt.Println("Error:", err)
28 } else {
29 fmt.Println("Precio:", precio)
30 }
31}El paquete fmt: Println, Printf y Sprintf
El paquete fmt es uno de los mas usados en Go. Ya has visto Println, pero tiene funciones mucho mas poderosas:
fmt.Println: impresion simple
1fmt.Println("Hola", "mundo") // Hola mundo (agrega espacio y salto de linea)
2fmt.Println("Valor:", 42, true) // Valor: 42 truefmt.Printf: impresion formateada
Usa verbos de formato para controlar como se muestra cada valor:
| Verbo | Descripcion | Ejemplo |
|---|---|---|
%d | Entero decimal | fmt.Printf("%d", 42) -> 42 |
%f | Punto flotante | fmt.Printf("%.2f", 3.14159) -> 3.14 |
%s | String | fmt.Printf("%s", "Go") -> Go |
%t | Booleano | fmt.Printf("%t", true) -> true |
%T | Tipo de la variable | fmt.Printf("%T", 42) -> int |
%v | Valor por defecto | fmt.Printf("%v", algo) |
%+v | Valor con nombres de campo | Util para structs |
1package main
2
3import "fmt"
4
5func main() {
6 nombre := "Go"
7 version := 1.23
8 anio := 2009
9 esGenial := true
10
11 fmt.Printf("Lenguaje: %s\n", nombre)
12 fmt.Printf("Version: %.2f\n", version)
13 fmt.Printf("Creado en: %d\n", anio)
14 fmt.Printf("Es genial: %t\n", esGenial)
15 fmt.Printf("Tipo de version: %T\n", version)
16
17 // Sprintf retorna un string en lugar de imprimir
18 resumen := fmt.Sprintf("%s fue creado en %d", nombre, anio)
19 fmt.Println(resumen)
20}Println para impresiones rapidas y Printf cuando necesites control sobre el formato. Sprintf es igual que Printf pero retorna el string en lugar de imprimirlo.
Ejercicios practicos
Pon en practica lo aprendido con estos ejercicios. Intenta resolverlos antes de ver la solucion:
Ejercicio 1: Ficha personal
Crea un programa que declare variables para tu nombre, edad, altura, ciudad y si eres estudiante. Imprime todo con formato usando Printf.
1package main
2
3import "fmt"
4
5func main() {
6 nombre := "Ana Garcia"
7 edad := 28
8 altura := 1.65
9 ciudad := "Guadalajara"
10 esEstudiante := false
11
12 fmt.Printf("=== Ficha Personal ===\n")
13 fmt.Printf("Nombre: %s\n", nombre)
14 fmt.Printf("Edad: %d anios\n", edad)
15 fmt.Printf("Altura: %.2f m\n", altura)
16 fmt.Printf("Ciudad: %s\n", ciudad)
17 fmt.Printf("Estudiante: %t\n", esEstudiante)
18}Ejercicio 2: Calculadora de area
Calcula el area de un circulo dado su radio, usando una constante para Pi:
1package main
2
3import "fmt"
4
5func main() {
6 const pi = 3.14159265358979
7 radio := 5.0
8
9 area := pi * radio * radio
10 perimetro := 2 * pi * radio
11
12 fmt.Printf("Radio: %.1f\n", radio)
13 fmt.Printf("Area: %.2f\n", area)
14 fmt.Printf("Perimetro: %.2f\n", perimetro)
15}Ejercicio 3: Conversion de temperatura
Convierte una temperatura de Celsius a Fahrenheit y Kelvin:
1package main
2
3import "fmt"
4
5func main() {
6 celsius := 37.0
7 fahrenheit := (celsius * 9.0 / 5.0) + 32.0
8 kelvin := celsius + 273.15
9
10 fmt.Printf("%.1f C = %.1f F = %.2f K\n", celsius, fahrenheit, kelvin)
11}Ya dominas los tipos de datos, las variables y las constantes en Go. Estos son los bloques de construccion que usaras en cada programa que escribas. En el proximo articulo (Parte 3 de 10) aprenderemos sobre estructuras de control: sentencias if, switch y bucles for, que te permitiran darle logica y repeticion a tus programas.
Comments
Sign in to leave a comment
No comments yet. Be the first!