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 4 de 36 · De PHP a Go ✦ WebMCP implementado

Funciones: varios retornos y variádicas

9 min de lectura 4 retos

Las funciones de Go se parecen mucho a las de PHP con tipos, con dos superpoderes: pueden devolver varios valores a la vez y así avisan de los errores sin excepciones. En esta lección escribes funciones, devuelves resultado y error, recibes cualquier número de argumentos y pasas funciones como si fueran datos.

¿De dónde vienen los nombres?

func = function (función)
La palabra para declarar una función. En PHP es function; Go la acorta.
nil = Del latín nihil (nada)
El «no hay nada» de Go: lo usa, por ejemplo, un error cuando no hubo error. Es el null de PHP.
err = error
No es una palabra del lenguaje, solo el nombre que todo el mundo da a la variable del error. Úsalo tú también.
En 4 ideas
1/4

Los tipos van detrás del nombre: func Etiqueta(titulo string, hecha bool) string. En PHP van delante: function etiqueta(string $titulo, bool $hecha): string.

1 · Declarar una función

Una función es una receta: le das ingredientes (los parámetros), hace su trabajo y te devuelve un plato (el resultado). En Go los tipos se escriben siempre, y van detrás del nombre.

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

function etiqueta(string $titulo, bool $hecha): string
{
    $marca = $hecha ? "x" : " ";
    return "[{$marca}] {$titulo}";
}

function progreso(int $hechas, int $total): string
{
    return "{$hechas}/{$total}";
}

echo etiqueta("Comprar pan", true) . PHP_EOL;
echo progreso(3, 4) . PHP_EOL;
Gomain.go
package main

import "fmt"

// Etiqueta pinta una tarea como «[x] Comprar pan».
func Etiqueta(titulo string, hecha bool) string {
    marca := " "
    if hecha {
        marca = "x"
    }
    return "[" + marca + "] " + titulo
}

// Si varios parámetros seguidos son del mismo tipo,
// el tipo se escribe una sola vez.
func Progreso(hechas, total int) string {
    return fmt.Sprintf("%d/%d", hechas, total)
}

func main() {
    fmt.Println(Etiqueta("Comprar pan", true))
    fmt.Println(Progreso(3, 4))
}
  • El tipo del resultado va después de los paréntesis, sin los dos puntos de PHP: ) string {.
  • Sin resultado, no se escribe nada: func main() {. Es el : void de PHP.
  • Si prometes un resultado, tienes que devolverlo en todos los caminos. Si un camino se queda sin return, el compilador dice missing return.
  • Go no tiene el operador ?:. Se escribe con un if, como en Etiqueta.

¿Por qué? · En PHP no existe

¿Por qué no hay valores por defecto ni argumentos con nombre? En PHP los uso a diario

En PHP puedes escribir function crear(string $titulo, int $prioridad = 1) y llamarla como crear(titulo: "pan"). Go no tiene ni lo uno ni lo otro, ni dos funciones con el mismo nombre y distintos parámetros.

La idea es que al leer una llamada sepas exactamente qué pasa, sin ir a mirar la declaración. Crear("pan", 1) dice todo lo que recibe. Cuando una función necesita muchas opciones, en Go se le pasa un struct con campos (lo verás en el módulo 04), que hace el mismo papel que los argumentos con nombre y se lee igual de claro.

2 · Devolver varios valores

En PHP una función devuelve una cosa. Si quieres dos, las metes en un array y las sacas con [$a, $b] = …. En Go puedes devolver varias directamente, como quien te da el cambio y el tique a la vez:

Gomain.go
package main

import "fmt"

// Reparte divide los minutos entre las tareas:
// devuelve los minutos de cada una y los que sobran.
func Reparte(minutos, tareas int) (int, int) {
    return minutos / tareas, minutos % tareas
}

func main() {
    // En PHP: [$cada, $sobran] = reparte(100, 3);
    cada, sobran := Reparte(100, 3)
    fmt.Println("Cada tarea:", cada, "minutos. Sobran:", sobran)

    // Si un valor no te interesa, va a la papelera _
    _, resto := Reparte(50, 4)
    fmt.Println("Sobran:", resto)
}

El uso estrella de esto es avisar de errores. La función devuelve el resultado y, al final, un valor de tipo error. Si todo fue bien, el error es nil (nada). Si algo falló, el error dice qué.

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

function validaTitulo(string $titulo): string
{
    $titulo = trim($titulo);
    if ($titulo === "") {
        throw new InvalidArgumentException("el título está vacío");
    }
    return $titulo;
}

try {
    echo validaTitulo("  Comprar pan ") . PHP_EOL;
    echo validaTitulo("   ") . PHP_EOL;
} catch (InvalidArgumentException $e) {
    echo "Error: " . $e->getMessage() . PHP_EOL;
}
Gomain.go
package main

import (
    "errors"
    "fmt"
    "strings"
)

// ValidaTitulo limpia el título y avisa si queda vacío.
func ValidaTitulo(titulo string) (string, error) {
    titulo = strings.TrimSpace(titulo)
    if titulo == "" {
        // En PHP: throw new InvalidArgumentException(...)
        return "", errors.New("el título está vacío")
    }
    // nil: no hubo error
    return titulo, nil
}

func main() {
    for _, entrada := range []string{"  Comprar pan ", "   "} {
        titulo, err := ValidaTitulo(entrada)
        if err != nil {
            fmt.Println("Error:", err)
            continue
        }
        fmt.Println(titulo)
    }
}

¿Por qué? · En PHP no existe

¿Por qué devolver el error en vez de lanzar una excepción? En PHP existe try/catch

Una excepción en PHP es un salto invisible: sale de la función y vuela hasta el catch que la atrape, que puede estar muy lejos… o no existir. Mirando validaTitulo($x) no sabes si puede fallar; tienes que leer su código o confiar en el PHPDoc.

En Go el error está en la firma: (string, error) te dice a gritos «esto puede fallar». Y como el resultado viene con el error al lado, lo normal es tratarlo justo ahí, con if err != nil. Es más código, pero el camino del fallo se ve tan claro como el camino bueno.

Lo verás a fondo en el módulo 06, donde se crean errores propios como ErrTareaNoEncontrada.

3 · Resultados con nombre

Puedes ponerles nombre a los resultados. Nacen como variables con su valor cero y un return a secas devuelve lo que valgan en ese momento:

Gomain.go
// Reparte, ahora con los resultados con nombre:
// cada y sobran nacen valiendo 0.
func Reparte(minutos, tareas int) (cada, sobran int) {
    cada = minutos / tareas
    sobran = minutos % tareas
    // return a secas: devuelve cada y sobran
    return
}

4 · Funciones variádicas: cualquier número de argumentos

Una función variádica acepta tantos argumentos como quieras, como una bolsa de la compra donde caben dos cosas o veinte. Se escribe ... delante del tipo del último parámetro. Dentro, los argumentos llegan juntos en una lista (un slice, que verás a fondo en el módulo 02) y se recorren con for … range (lo verás en la próxima lección).

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

function totalMinutos(int ...$minutos): int
{
    return array_sum($minutos);
}

echo totalMinutos() . PHP_EOL;
echo totalMinutos(10, 20, 30) . PHP_EOL;

// Repartir un array como argumentos
$hoy = [15, 45];
echo totalMinutos(...$hoy) . PHP_EOL;
Gomain.go
package main

import "fmt"

// TotalMinutos suma las duraciones que le pases.
func TotalMinutos(minutos ...int) int {
    total := 0
    // _ es la posición, que aquí no hace falta
    for _, m := range minutos {
        total += m
    }
    return total
}

func main() {
    fmt.Println(TotalMinutos())
    fmt.Println(TotalMinutos(10, 20, 30))

    // Repartir una lista como argumentos: los ... van DETRÁS
    // En PHP: totalMinutos(...$hoy)
    hoy := []int{15, 45}
    fmt.Println(TotalMinutos(hoy...))
}

Ya conoces una función variádica: fmt.Println recibe cuantos valores le pases. Por eso fmt.Println("Tarea", titulo, prioridad) funciona con tres argumentos y con diez.

5 · Funciones como valores

En Go una función es un valor más: puedes guardarla en una variable o pasársela a otra función. Es como darle a alguien una receta en vez de un plato: él decide cuándo cocinarla. En PHP 8.1+ lo haces con el first-class callable strtoupper(...).

Gomain.go
package main

import (
    "fmt"
    "strings"
)

// AplicaATitulo recibe una función y la usa sobre el título.
// func(string) string es el TIPO: «función que recibe un string y devuelve un string».
func AplicaATitulo(titulo string, f func(string) string) string {
    return f(titulo)
}

func main() {
    // En PHP: $mayusculas = strtoupper(...);
    mayusculas := strings.ToUpper
    fmt.Println(mayusculas("comprar pan"))

    fmt.Println(AplicaATitulo("  repasar go ", strings.TrimSpace))
    fmt.Println(AplicaATitulo("llamar al banco", strings.ToUpper))
}

El tipo de una función se escribe con sus parámetros y su resultado: func(string) string. Las funciones anónimas que «recuerdan» variables (los closures, el function () use ($x) de PHP) tienen su propia lección en el módulo 06.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Marca de hecha

Completa Etiqueta(titulo string, hecha bool) string para que devuelva [x] <titulo> si la tarea está hecha y [ ] <titulo> (con un espacio entre los corchetes) si no lo está. Por ejemplo, Etiqueta("Comprar pan", true) devuelve [x] Comprar pan. En PHP sería "[" . ($hecha ? "x" : " ") . "] {$titulo}".

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. func Nombre(param tipo) resultado con el tipo detrás (en PHP, function nombre(tipo $param): resultado).
  2. Varios resultados con return a, b y se recogen con a, b := … (en PHP, devolver un array y [$a, $b] = …).
  3. El error va el último y vale nil si todo fue bien: if err != nil (en PHP, throw y try/catch).
  4. ...int recibe muchos argumentos y lista... los reparte (en PHP, int ...$x y ...$lista).
  5. Una función es un valor: se guarda y se pasa (en PHP, strtoupper(...) y el tipo callable).

Para recordarlo: «El plato y la nota»

PPlato
titulo
NNota
err

Una función de Go te entrega el plato (el resultado) y, al lado, una nota (el error). Si la nota está en blanco (nil), te lo comes; si trae algo escrito, lees la nota antes de tocar el plato.