¿Cómo declaras variables y cuáles son los tipos básicos de Go?

Question

Accepted Answer

Go es de tipo estático con varias formas de declarar variables. La más común es la **declaración abreviada** `:=`, que deduce el tipo. Los tipos básicos de Go cubren números, strings, booleanos y más.

## Declaración de variables

```go
var x int = 42        // full form: explicit type and value
var y = 42            // type inferred → int
var z int             // declared, ZERO-valued (z = 0)

name := "Ann"         // short declaration (:=) — infers type, INSIDE functions only
count := 10

var a, b = 1, "two"   // multiple at once
const Pi = 3.14159     // constant (compile-time)
```

`:=` es la forma idiomática dentro de funciones — concisa con deducción de tipos. `var` se usa a nivel de paquete y cuando quieres un tipo explícito o solo el valor cero.

## Los tipos básicos

```go
// integers
int, int8, int16, int32, int64     // signed (int is platform-sized, usually 64-bit)
uint, uint8, ..., uint64           // unsigned
byte                                // alias for uint8
rune                                // alias for int32 — a Unicode code point

// floating point
float32, float64                    // float64 is the default for decimals

// others
string                              // immutable UTF-8 text
bool                               // true / false
complex64, complex128              // complex numbers
```

## Valores cero — sin variables "sin inicializar"

```go
var i int       // 0
var f float64   // 0.0
var s string    // "" (empty)
var b bool      // false
var p *int      // nil
```

Una característica crucial de Go: cada variable declarada obtiene automáticamente un **valor cero** sensato — no hay valores indefinidos/basura. Esto hace que el código sea más seguro y significa que a menudo puedes omitir la inicialización explícita.

## Las conversiones de tipos son explícitas

```go
var i int = 42
var f float64 = float64(i)   // MUST convert explicitly — no implicit coercion
var u uint = uint(f)
// i + f  → ❌ compile error: mismatched types
```

Go requiere **conversiones explícitas** de tipos — nunca mezcla tipos implícitamente, evitando una clase de errores sutiles.

## Por qué es importante

Comprender las declaraciones de variables y tipos de Go es fundamental para escribir cualquier código Go.

La declaración abreviada `:=` idiomática con deducción mantiene el código conciso, mientras que `var` y las constantes cumplen sus funciones.

La **garantía de valor cero** (cada variable se inicializa de forma segura) es una característica distintiva e importante de Go que elimina errores de variables sin inicializar y forma patrones idiomáticos (por ejemplo, una estructura con valor cero a menudo es utilizable).

Y la insistencia de Go en **conversiones de tipos explícitas** (sin coerción implícita) es una elección de seguridad deliberada que previene el tipo de errores numéricos silenciosos que otros lenguajes permiten.

Conocer los tipos básicos (especialmente `rune` para Unicode, `byte` y que `int`/`float64` son los predeterminados) es conocimiento esencial cotidiano.