Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 2 de 36 · De PHP a Go ✦ WebMCP implementado

Variables, constantes y tipos estáticos

8 min de lectura 4 retos

En PHP una variable puede guardar un número y, dos líneas después, un texto. En Go no: cada variable nace con un tipo y lo conserva toda su vida. En esta lección aprendes las tres formas de declarar, qué vale una variable que nadie ha rellenado y cómo se escriben las constantes.

¿De dónde vienen los nombres?

var = variable
La palabra con la que se declara una variable. En PHP no hay palabra: basta con escribir $titulo = ….
const = constant (constante)
Un valor que no cambia nunca. Igual que el const de PHP, dentro o fuera de una clase.
int = integer (número entero)
El tipo de los números sin decimales: tu int de PHP.
bool = Boole, por el matemático George Boole
El tipo que solo vale true o false, como el bool de PHP.
En 4 ideas
1/4

Cada variable de Go tiene un tipo fijo desde que nace. En PHP $prioridad = 2; y luego $prioridad = "alta"; funciona; en Go la segunda línea no compila.

1 · Tres formas de declarar

Una variable es una caja con una etiqueta. En PHP la caja es de goma: le cabe cualquier cosa. En Go la caja tiene forma: si es para números, solo entran números. Esa forma se llama tipo.

Go tiene tres maneras de crear una variable. Las tres hacen lo mismo; cambia cuánto escribes:

Gomain.go
package main

import "fmt"

func main() {
    // 1. var + nombre + tipo: la caja nace vacía (valor cero)
    var hechas int

    // 2. var + nombre + tipo + valor
    var titulo string = "Comprar pan"

    // 3. := declara y rellena; Go deduce el tipo mirando el valor
    // En PHP: $prioridad = 2;
    prioridad := 2

    // = (sin los dos puntos) cambia una variable que ya existe
    hechas = 1

    fmt.Println(titulo, prioridad, hechas)
    fmt.Printf("%T %T %T\n", titulo, prioridad, hechas)
}
FormaCuándo usarlaEn PHP
var hechas intQuieres la caja vacía y rellenarla despuésNo existe: no se declara sin valor
var titulo string = "pan"Quieres dejar el tipo bien a la vista$titulo = "pan";
titulo := "pan"Lo normal dentro de una función: corto y claro$titulo = "pan";
titulo = "leche"Cambiar una variable que ya existe$titulo = "leche";

Puedes declarar varias de golpe: var hechas, total int o titulo, prioridad := "pan", 2. Y fíjate en una regla de la lección anterior: una variable que declaras y no usas no compila (declared and not used).

2 · El tipo no cambia nunca

En PHP una variable cambia de tipo cuando quiere. En Go, una vez que prioridad es un int, lo es para siempre. Si intentas meterle un texto, el programa ni siquiera arranca:

PHP 8.5prioridad.php
<?php
declare(strict_types=1);

$prioridad = 2;

// PHP lo acepta: ahora $prioridad es un string
$prioridad = "alta";

echo get_debug_type($prioridad) . PHP_EOL;

// Imprime: string
// El fallo saldrá más tarde, cuando alguien
// haga $prioridad + 1 o la compare con 2.
Gomain.go
// Dentro de func main():
var prioridad int = 2

// No compila:
// cannot use "alta" (untyped string constant)
//     as int value in assignment
prioridad = "alta"

// Y además: declared and not used: prioridad
// Go para aquí. El programa no llega a existir.

Los dos mensajes son reales: los da el compilador al intentar construir ese programa. El primero dice «no puedo meter un texto en una caja de enteros». El segundo, que creaste prioridad y nunca la lees.

¿Por qué? · En PHP no existe

¿Por qué tipos fijos? En PHP una variable puede ser lo que quiera

En PHP el tipo de una variable se descubre mientras el programa corre. Si en una rama rara $prioridad acaba siendo "alta", nadie se entera hasta que un cliente pulsa justo ese botón y ve un TypeError, o peor, un cálculo mal hecho sin ningún error.

Go mira los tipos antes de crear el programa. Es como el control de equipaje del aeropuerto: revisan la maleta antes de subir al avión, no en pleno vuelo. Lo que ganas:

  • Los errores de tipo salen en tu ordenador al compilar, no en producción.
  • El editor sabe siempre qué hay en cada variable y te autocompleta sin adivinar.
  • Puedes renombrar o cambiar una función con confianza: si algo deja de encajar, el compilador te lo señala.

PHP se ha ido acercando con declare(strict_types=1) y los tipos en parámetros y propiedades, pero sigue comprobándolos al ejecutar. Go lo hace siempre, y antes.

3 · El valor cero: nada de null ni de indefinidas

¿Qué hay en una caja que nadie ha rellenado? En PHP, si lees una variable que no existe, te sale un Warning: Undefined variable y obtienes null. En Go no existen las variables indefinidas: toda variable nace con el valor cero de su tipo.

Gomain.go
package main

import "fmt"

func main() {
    var hechas int
    var minutos float64
    var titulo string
    var urgente bool

    // %q pone el string entre comillas para que veas que está vacío
    fmt.Printf("%d | %v | %q | %t\n", hechas, minutos, titulo, urgente)
}
TipoValor ceroLo más parecido en PHP
int, float640(int) null da 0
string"" (texto vacío)(string) null da ""
boolfalse(bool) null da false

Es como un formulario en blanco: cada casilla ya tiene algo (un cero, un hueco vacío, una casilla sin marcar), nunca un agujero. Un contador de tareas hechas puede empezar con var hechas int y sumarle directamente, sin el $hechas = 0; de seguridad que pones en PHP.

4 · Constantes con const

Una constante es un valor grabado en piedra: lo escribes una vez y nadie lo puede cambiar. En Go se declaran con const y suelen ir fuera de las funciones, arriba del fichero.

PHP 8.5limites.php
<?php
declare(strict_types=1);

const MAX_TAREAS = 10;

final class Limites
{
    public const int MAX_ETIQUETAS = 5;
    public const string TITULO_DEFECTO = "Sin título";
}

echo MAX_TAREAS . " tareas, "
    . Limites::MAX_ETIQUETAS . " etiquetas, "
    . Limites::TITULO_DEFECTO . PHP_EOL;
Gomain.go
package main

import "fmt"

const MaxTareas = 10

// Varias constantes juntas, entre paréntesis
const (
    MaxEtiquetas  = 5
    TituloDefecto = "Sin título"
)

func main() {
    fmt.Println(MaxTareas, "tareas,", MaxEtiquetas, "etiquetas,", TituloDefecto)

    // Una constante también vale dentro de una función
    const minutosPorHora = 60
    fmt.Println(90/minutosPorHora, "hora y", 90%minutosPorHora, "minutos")
}

Si intentas MaxTareas = 20, el compilador responde con cannot assign to MaxTareas (neither addressable nor a map index expression): dicho fácil, «eso no es una caja, no puedes meter nada».

  • Nombres: Go no usa MAYUSCULAS_CON_GUIONES. Se escribe MaxTareas (pública, porque empieza por mayúscula) o maxTareas (privada del paquete), como cualquier otro nombre.
  • Solo valores simples: números, textos y true/false. Una lista o un struct no pueden ser constantes.
  • Se calculan al compilar: const Segundos = 60 * 60 se resuelve antes de ejecutar, sin coste.

¿Por qué? · En PHP no existe

¿Por qué una constante «sin tipo»? En PHP una constante es un valor y ya

const MaxTareas = 10 no dice si es int o float64. Go la guarda como un número sin tipo (untyped) y le da el tipo que haga falta en cada sitio donde la uses.

El problema que resuelve: como Go no convierte tipos solo (lo verás en la próxima lección), una constante int no se podría sumar a un float64. Gracias a que no tiene tipo, MaxTareas * 1.5 y MaxTareas + hechas funcionan los dos. Es una plastilina que toma la forma del molde donde la metes, pero solo las constantes; las variables, no.

5 · Ámbito: cada llave es una habitación

En PHP una variable creada dentro de un if sigue viva después del if. En Go, cada par de llaves { } es una habitación: lo que nace dentro se queda dentro. Desde dentro ves lo de fuera; desde fuera no ves lo de dentro.

Esto tiene una trampa famosa. Si dentro de un bloque usas := con un nombre que ya existe fuera, no cambias la de fuera: creas otra nueva con el mismo nombre que la tapa (se dice que le hace sombra):

Gomain.go
package main

import "fmt"

func main() {
    titulo := "Comprar pan"
    urgente := true

    if urgente {
        // := crea OTRA variable titulo, solo para este bloque
        titulo := "URGENTE: " + titulo
        fmt.Println("Dentro:", titulo)
    }

    // La de fuera no se ha tocado
    fmt.Println("Fuera: ", titulo)

    if urgente {
        // = cambia la de fuera, que es lo que queríamos
        titulo = "URGENTE: " + titulo
    }
    fmt.Println("Ahora: ", titulo)
}

Si alguna vez necesitas recibir un valor que no vas a usar, guárdalo en _ (el identificador vacío): es una papelera que el compilador acepta sin quejarse de «declarada y no usada». Lo verás mucho en las próximas lecciones.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Declara tu tarea

Declara titulo con el valor Comprar pan y prioridad con el valor 2, y haz que el programa imprima exactamente Tarea: Comprar pan (P2). Es tu $titulo = "Comprar pan"; de PHP.

Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.

Gomain.go · editable

Resumen

Lo que te llevas de esta lección

  1. Cada variable tiene un tipo fijo desde que nace (en PHP el tipo cambia cuando quiere).
  2. := declara y rellena, = cambia, var x T declara vacía (en PHP todo es $x = …).
  3. Lo no rellenado vale su valor cero: 0, "", false (en PHP, Undefined variable y null).
  4. const MaxTareas = 10 no se puede cambiar y se adapta al tipo donde la uses (en PHP, const MAX_TAREAS = 10;).
  5. Cada { } es una habitación, y := dentro de ella crea una variable nueva que tapa a la de fuera.

Para recordarlo: «Caja con forma, nunca vacía»

Cada variable es una caja con forma (su tipo: solo entra lo que encaja) y nunca vacía (si no la llenas, trae su valor cero). Las constantes son cajas cerradas con candado.