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 15 de 36 · De clases a structs ✦ WebMCP implementado

nil, valores cero y comma ok: isset y ?? en Go

9 min de lectura 4 retos

En PHP casi todo puede ser null, y te pasas el día con isset(), ?? y ?->. En Go un string o un int nunca son nil: siempre tienen un valor, aunque sea el valor cero. Y para saber si algo «está», Go usa un truco de dos valores: el comma ok.

¿De dónde vienen los nombres?

nil = del latín nihil (nada)
El «nada» de Go, tu null. Pero solo existe para punteros, slices, maps, interfaces, funciones y canales.
ok = el «OK» de toda la vida
No es una palabra del lenguaje: es solo el nombre que todo el mundo da al bool que dice si algo salió bien o existe. Podrías llamarlo existe.
any = any (cualquiera)
Otro nombre de interface{}: una caja donde cabe un valor de cualquier tipo. Es tu mixed de PHP.
En 4 ideas
1/4

Todo tipo tiene valor cero (0, "", false, struct con todo a cero) y muchos sirven tal cual: un slice nil admite append. En PHP sería que $tareas[] = $t; funcione sin declarar $tareas = []; antes, pero sin aviso.

1 · El valor cero: nada está «sin definir»

Ya lo viste en el módulo 01: toda variable de Go nace con un valor. No hay Undefined variable ni variables «a medio hacer». Piensa en un formulario en blanco: los huecos están vacíos, pero el formulario existe y se puede leer.

TipoValor ceroEn PHP sería
int, float6400, 0.0
string""''
boolfalsefalse
Tarea (struct)Tarea{}: todos sus campos a ceronew Tarea() con valores por defecto
*Tarea, []Tarea, map[int]Tarea, anynilnull

Lo mejor es que muchos valores cero sirven tal cual. Go lo llama «hacer útil el valor cero»:

Gomain.go
package main

import "fmt"

func main() {
    // Un slice nil: len 0 y append funciona sin inicializarlo
    var titulos []string
    fmt.Println(len(titulos), titulos == nil)
    titulos = append(titulos, "Comprar pan")
    fmt.Println(titulos)

    // Contar con un map: si la clave no está, m[k] da 0 y ++ sigue de ahí
    porEtiqueta := map[string]int{}
    for _, e := range []string{"casa", "trabajo", "casa"} {
        // En PHP: $porEtiqueta[$e] = ($porEtiqueta[$e] ?? 0) + 1;
        porEtiqueta[e]++
    }
    fmt.Println(porEtiqueta)
}

2 · nil: el null que no vale para todo

nil significa «no apunta a nada» o «todavía no hay nada». Solo lo pueden valer los tipos que por dentro son una referencia: punteros, slices, maps, interfaces (como any), funciones y canales.

Un string no es uno de ellos. Si intentas titulo = nil, el compilador te para. Mensaje real:

./main.go:7:14: cannot use nil as string value in assignment

¿Por qué? · En PHP no existe

¿Por qué un string no puede ser nil? En PHP ?string es normal

En PHP, en cuanto una propiedad es ?string, cada sitio que la usa tiene que acordarse del null: strlen(null) avisa de que está obsoleto, trim(null) igual, y una función con string estricto lanza TypeError. Tony Hoare, que inventó el null en 1965, lo llamó su «error de los mil millones de dólares».

Go corta el problema de raíz: un string es siempre un texto, como mucho vacío. Nunca tienes que comprobar si es nil antes de usarlo. Cuando de verdad necesitas distinguir «vacío» de «no hay», lo dices a propósito:

  • Con un bool al lado: (Tarea, bool) o el v, ok de la sección siguiente.
  • Con un puntero: *string sí puede ser nil (y entonces sí tienes que comprobarlo, como en PHP).

Equivalencia POO · PHP → Go

Lo que en PHP resuelve el null (opcionales, «no encontrado», comprobar tipos), en Go se reparte entre nil, el valor cero y el ok.

PHPGoQuién lo ve
?Tarea (puede ser null)(Tarea, bool) o *TareaQuien llama, que tiene que mirar el bool o el nil
nullnilSolo punteros, slices, maps, interfaces, funciones y canales
isset($m[$k])_, ok := m[k]Cualquiera que lea el map
$m[$k] ?? 'defecto'v, ok := m[k] + if !okCualquiera que lea el map
$t?->tituloif t != nil { t.Titulo }No hay operador: se comprueba a mano
$v instanceof Tareat, ok := v.(Tarea)Solo con valores dentro de una interfaz (any)

3 · Comma ok: tu isset() y tu ??

Si lees una clave que no está en un map, Go no da error ni null: te da el valor cero. Eso es cómodo, pero tiene trampa: ¿el título vacío es porque la tarea tiene título vacío o porque no existe?

Para saberlo, pide dos valores: el segundo es un bool que dice si la clave estaba. Se llama «comma ok» por la coma que los separa.

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

$titulos = [1 => "Comprar pan", 2 => ""];

// isset() da false si la clave no está... o si vale null
var_dump(isset($titulos[2]));
var_dump(isset($titulos[3]));

// ?? pone un valor por defecto si no está
echo ($titulos[3] ?? "(no existe)") . PHP_EOL;
Gomain.go
package main

import "fmt"

func main() {
    titulos := map[int]string{1: "Comprar pan", 2: ""}

    // Sin ok: la 3 no existe, pero da "" igual que la 2
    fmt.Printf("%q %q\n", titulos[2], titulos[3])

    // En PHP: isset($titulos[2])
    _, ok := titulos[2]
    fmt.Println(ok)

    // En PHP: $titulos[3] ?? "(no existe)"
    titulo, ok := titulos[3]
    if !ok {
        titulo = "(no existe)"
    }
    fmt.Println(titulo)
}

Lo verás muchas veces escrito así, todo en el if. La variable t solo existe dentro del if y su else:

Gomain.go
if t, ok := tareas[id]; ok {
    fmt.Println("encontrada:", t.Titulo)
} else {
    fmt.Println("no hay tarea", id)
}

4 · Type assertion: ¿qué hay en la caja any?

Una variable de tipo any es una caja donde cabe cualquier cosa, como un mixed de PHP. Para sacar lo de dentro con su tipo de verdad, se usa una type assertion («afirmación de tipo»): v.(string). Y también admite comma ok, para no romper si el tipo no es el que esperabas.

Gomain.go
package main

import "fmt"

type Tarea struct {
    ID     int
    Titulo string
}

func Describir(v any) string {
    // En PHP: if (is_string($v)) { ... }
    if s, ok := v.(string); ok {
        return "texto: " + s
    }
    // En PHP: if ($v instanceof Tarea) { ... }
    if t, ok := v.(Tarea); ok {
        return "tarea: " + t.Titulo
    }
    return fmt.Sprintf("otra cosa: %v", v)
}

func main() {
    fmt.Println(Describir("Comprar pan"))
    fmt.Println(Describir(Tarea{ID: 1, Titulo: "Repasar Go"}))
    fmt.Println(Describir(42))
}

5 · nil en punteros: el ?-> que no existe

Un puntero *Tarea sí puede ser nil, y entonces pasa lo mismo que en PHP con null->titulo: si lees un campo, el programa se para. Go no tiene ?->, así que se comprueba con un if:

Gomain.go
package main

import "fmt"

type Tarea struct {
    ID     int
    Titulo string
}

// Devuelve nil si no la encuentra (como un ?Tarea de PHP)
func Buscar(tareas []Tarea, id int) *Tarea {
    for i := range tareas {
        if tareas[i].ID == id {
            return &tareas[i]
        }
    }
    return nil
}

func main() {
    tareas := []Tarea{{ID: 1, Titulo: "Comprar pan"}}

    // En PHP: echo $t?->titulo ?? "(no hay)";
    t := Buscar(tareas, 7)
    if t != nil {
        fmt.Println(t.Titulo)
    } else {
        fmt.Println("(no hay)")
    }
}

Por eso en Go se prefiere devolver (Tarea, bool) cuando basta: con un bool el compilador te obliga a recogerlo, y con un puntero nil es fácil olvidarse del if.

La pregunta que te vas a hacer

«Vale, pero… ¿y el $_POST['titulo'] ?? '' de mis formularios?»

En Go, r.FormValue("titulo") (del paquete net/http) ya te devuelve el valor cero "" si el campo no viene: es tu ?? '' de serie. Si necesitas distinguir «vino vacío» de «no vino», miras el map r.PostForm con comma ok. Lo verás en el módulo 07.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

El ?? de los títulos

Completa TituloO(titulos map[int]string, id int) string: devuelve el título de la tarea id o (sin título) si no existe la clave. Ojo: si la clave existe con título vacío, devuelve "". Es el $titulos[$id] ?? '(sin título)' 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. Todo tiene valor cero y muchos sirven tal cual: append a un slice nil, m[k]++ en un map vacío (en PHP, ($m[$k] ?? 0) + 1).
  2. nil es tu null, pero solo para punteros, slices, maps, interfaces y funciones: un string nunca es nil (adiós ?string).
  3. v, ok := m[k] es tu isset() y tu ?? en una línea.
  4. s, ok := v.(string) mira qué hay en una caja any sin romper (en PHP, is_string() o instanceof).
  5. Un puntero nil se comprueba a mano con if p != nil (en PHP, ?->); si basta, devuelve (Tarea, bool).

Para recordarlo: «Pregunta con coma: valor, ok»

Cada vez que en PHP escribirías isset() o ??, en Go pides dos cosas separadas por una coma: el valor y si estaba. Si no preguntas, Go no te grita: te da el valor cero.