Variables y Tipos de Datos

Declaracion de variables

Go ofrece dos formas de declarar variables:

Con var (explicita)

package main

import "fmt"

func main() {
	// Tipo explicito
	var nombre string = "Artiko"
	var edad int = 30

	// Tipo inferido
	var lenguaje = "Go"

	// Declaracion sin valor (usa zero value)
	var activo bool

	fmt.Println(nombre, edad, lenguaje, activo)
	// Artiko 30 Go false
}

Con := (short declaration)

package main

import "fmt"

func main() {
	// Solo funciona dentro de funciones
	nombre := "Artiko"
	edad := 30
	pi := 3.14159

	fmt.Println(nombre, edad, pi)
}

La diferencia clave: var puede usarse a nivel de paquete, := solo dentro de funciones.

Declaracion multiple

package main

import "fmt"

func main() {
	// Bloque var
	var (
		host   = "localhost"
		puerto = 8080
		debug  = false
	)

	// Short declaration multiple
	x, y, z := 1, 2, 3

	fmt.Println(host, puerto, debug, x, y, z)
}

Tipos basicos

Tabla de tipos

Tipo	Zero value	Descripcion
bool	false	Booleano
int	0	Entero (32 o 64 bits segun plataforma)
int8	0	Entero con signo de 8 bits (-128 a 127)
int16	0	Entero con signo de 16 bits
int32	0	Entero con signo de 32 bits (alias: rune)
int64	0	Entero con signo de 64 bits
uint	0	Entero sin signo (32 o 64 bits)
uint8	0	Entero sin signo de 8 bits (alias: byte)
uint16	0	Entero sin signo de 16 bits
uint32	0	Entero sin signo de 32 bits
uint64	0	Entero sin signo de 64 bits
float32	0.0	Punto flotante 32 bits (IEEE 754)
float64	0.0	Punto flotante 64 bits (IEEE 754)
complex64	(0+0i)	Numero complejo con float32
complex128	(0+0i)	Numero complejo con float64
string	""	Cadena de texto (inmutable, UTF-8)
byte	0	Alias de uint8
rune	0	Alias de int32 (punto de codigo Unicode)

Zero values

En Go toda variable tiene un valor por defecto (zero value). No existen variables sin inicializar:

package main

import "fmt"

func main() {
	var entero int
	var flotante float64
	var booleano bool
	var cadena string
	var puntero *int

	fmt.Println(entero)   // 0
	fmt.Println(flotante) // 0
	fmt.Println(booleano) // false
	fmt.Println(cadena)   // "" (string vacio)
	fmt.Println(puntero)  // <nil>
}

Esto elimina errores por variables no inicializadas que existen en C o C++.

Constantes

Las constantes se declaran con const y deben tener valor en tiempo de compilacion:

package main

import "fmt"

const Pi = 3.14159
const Version = "1.0.0"

// Bloque de constantes
const (
	KB = 1024
	MB = KB * 1024
	GB = MB * 1024
)

func main() {
	fmt.Println("Pi:", Pi)
	fmt.Println("1 GB =", GB, "bytes")
}

iota: generador de constantes

iota es un identificador que se incrementa automaticamente en bloques const:

package main

import "fmt"

// Enum con iota
type DiaSemana int

const (
	Lunes DiaSemana = iota // 0
	Martes                 // 1
	Miercoles              // 2
	Jueves                 // 3
	Viernes                // 4
	Sabado                 // 5
	Domingo                // 6
)

// Bitmask con iota
const (
	Lectura   = 1 << iota // 1
	Escritura             // 2
	Ejecucion             // 4
)

func main() {
	fmt.Println("Miercoles =", Miercoles) // 2
	fmt.Println("Lectura =", Lectura)     // 1
	fmt.Println("Escritura =", Escritura) // 2
	fmt.Println("Ejecucion =", Ejecucion) // 4

	// Combinar permisos con OR
	permisos := Lectura | Escritura
	fmt.Println("Permisos:", permisos) // 3
}

Conversiones de tipo

Go no tiene conversiones implicitas. Toda conversion debe ser explicita:

package main

import "fmt"

func main() {
	// int a float
	entero := 42
	flotante := float64(entero)

	// float a int (trunca, no redondea)
	pi := 3.99
	truncado := int(pi) // 3

	// int entre distintos tamanios
	var grande int64 = 1000
	var chico int32 = int32(grande)

	// string a []byte y viceversa
	texto := "Hola"
	bytes := []byte(texto)
	deVuelta := string(bytes)

	fmt.Println(flotante, truncado, chico, deVuelta, bytes)
	// 42 3 1000 Hola [72 111 108 97]
}

Intentar mezclar tipos sin conversion genera error:

// ESTO NO COMPILA
var a int32 = 10
var b int64 = 20
// c := a + b  // error: mismatched types int32 and int64

// Solucion: convertir explicitamente
c := int64(a) + b

Type alias vs Type definition

package main

import "fmt"

// Type definition: crea un tipo NUEVO
type Celsius float64
type Fahrenheit float64

// Type alias: solo un nombre alternativo (mismo tipo)
type Entero = int

func main() {
	var temp Celsius = 100.0
	// var f Fahrenheit = temp // ERROR: tipos incompatibles

	// Conversion explicita necesaria
	var f Fahrenheit = Fahrenheit(temp*9/5 + 32)

	// Type alias es intercambiable
	var n Entero = 42
	var m int = n // OK: mismo tipo subyacente

	fmt.Println(temp, "C =", f, "F")
	fmt.Println("n:", n, "m:", m)
}

fmt.Printf y verbos de formato

fmt.Printf permite formateo preciso con verbos:

Verbo	Descripcion	Ejemplo
%v	Valor por defecto	fmt.Printf("%v", 42) → 42
%+v	Valor con nombres de campo (structs)	{Nombre:Go}
%#v	Representacion Go del valor	main.Config{...}
%T	Tipo de la variable	fmt.Printf("%T", 42) → int
%d	Entero decimal	fmt.Printf("%d", 42) → 42
%b	Entero binario	fmt.Printf("%b", 10) → 1010
%o	Entero octal	fmt.Printf("%o", 8) → 10
%x	Entero hexadecimal	fmt.Printf("%x", 255) → ff
%f	Float decimal	fmt.Printf("%f", 3.14) → 3.140000
%.2f	Float con 2 decimales	fmt.Printf("%.2f", 3.14) → 3.14
%s	String	fmt.Printf("%s", "hola") → hola
%q	String con comillas	fmt.Printf("%q", "hola") → "hola"
%p	Puntero	fmt.Printf("%p", &x) → 0xc0000...
%t	Booleano	fmt.Printf("%t", true) → true

package main

import "fmt"

func main() {
	nombre := "Go"
	version := 1.22
	anio := 2024
	activo := true

	fmt.Printf("Lenguaje: %s v%.2f (%d)\n", nombre, version, anio)
	fmt.Printf("Activo: %t\n", activo)
	fmt.Printf("Tipo de version: %T\n", version)
	fmt.Printf("Anio en hex: %x\n", anio)
	// Lenguaje: Go v1.22 (2024)
	// Activo: true
	// Tipo de version: float64
	// Anio en hex: 7e8
}

Ejercicios

1. Declara variables de cada tipo basico e imprime sus zero values
2. Crea un enum de colores usando iota y una funcion que retorne el nombre como string
3. Implementa una funcion que convierta Celsius a Fahrenheit usando type definition

Resumen

• var para declaracion explicita, := para inferencia dentro de funciones
• Go no tiene conversiones implicitas: usa tipo(valor)
• Toda variable tiene un zero value por defecto
• const con iota permite crear enums y bitmasks
• type crea tipos nuevos, type X = Y crea aliases
• fmt.Printf con verbos (%v, %d, %s, %T) para formateo

Navegacion