¿Cómo funcionan las funciones y los múltiples valores de retorno en Go?

Question

Accepted Answer

Las funciones de Go se declaran con `func`, y una característica distintiva es **múltiples valores de retorno** — una función puede devolver varios valores a la vez. Esto se usa de forma generalizada, especialmente para el idioma `(result, error)` que define el manejo de errores de Go.

## Función básica

```go
func add(a int, b int) int {     // params with types, then the return type
    return a + b
}

func greet(name string) string {
    return "Hello, " + name
}
// shorthand for same-typed params: func add(a, b int) int
```

## Múltiples valores de retorno — la característica definitoria

```go
func divide(a, b int) (int, error) {     // returns BOTH a result AND an error
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil    // nil error = success
}

// callers handle both — the ubiquitous Go error pattern
result, err := divide(10, 2)
if err != nil {
    log.Fatal(err)       // handle the error
}
fmt.Println(result)
```

Devolver `(value, error)` es EL idioma para el manejo de errores en Go — en lugar de excepciones, las funciones devuelven errores como valores que los llamadores verifican explícitamente. Esto hace que el manejo de errores sea visible e imposible de ignorar silenciosamente.

## El patrón comma-ok

```go
// many built-ins return (value, ok) — a boolean for "did it work?"
value, ok := myMap["key"]   // ok = false if the key is missing
if ok { ... }

v, ok := someInterface.(string)   // type assertion with ok
```

## Valores de retorno nombrados

```go
func split(sum int) (x, y int) {   // named returns
    x = sum * 4 / 9
    y = sum - x
    return   // "naked return" — returns the named values
}
```

## Funciones variádicas

```go
func sum(nums ...int) int {     // accepts any number of ints
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3)          // 6
sum(nums...)          // spread a slice into args
```

## Las funciones son ciudadanos de primera clase

```go
var op func(int, int) int = add   // assign functions to variables
func apply(fn func(int) int, x int) int { return fn(x) }  // pass as arguments
```

## Por qué es importante

Las funciones de Go son centrales, y **múltiples valores de retorno** son una de las características distintivas del lenguaje — permiten el idioma `(result, error)` que *es* el enfoque de Go para el manejo de errores (verificación explícita de errores como valores en lugar de excepciones).

Este patrón, utilizado en prácticamente todos los programas de Go, hace que el manejo de errores sea visible e intencional.

El idioma comma-ok relacionado (`value, ok :=`) aparece en toda la aplicación (acceso a mapas, aserciones de tipo, recepciones de canales).

Entender múltiples retornos, el patrón de error, retornos nombrados, funciones variádicas y funciones de primera clase es esencial para leer y escribir Go idiomático — y la filosofía de error-como-valor es una de las diferencias conceptuales más importantes entre Go y lenguajes basados en excepciones.