08 Funciones en Go

🧠 Introducción

Las funciones son bloques de código que realizan tareas específicas. Nos ayudan a escribir programas más limpios, organizados y reutilizables. En Go, las funciones son muy poderosas: pueden recibir múltiples parámetros, retornar más de un valor, aceptar un número variable de argumentos y hasta ser anónimas.

1. 🧠 ¿Qué es una función?

Una función te permite:

• Ejecutar una tarea concreta.
• Evitar repetir el mismo código.
• Dividir un problema grande en partes pequeñas y manejables.

Ya has usado func main() desde el inicio. ¡Ahora vamos a crear las nuestras!

2. ✍️ Cómo definir una función

Sintaxis básica:

func nombreFuncion(parámetros) tipoRetorno {
    // Código
}

Ejemplo:

func saludo(nombre string) {
    fmt.Printf("Hola, %s\n", nombre)
}

3. ➕ Funciones con múltiples parámetros

Puedes usar tantos parámetros como necesites:

func saludoCompleto(nombre string, apellido string, edad int) {
    fmt.Printf("Hola %s %s, tienes %d años\n", nombre, apellido, edad)
}

4. 🪞 Por valor vs por referencia

Paso por valor

El valor original no se modifica.

func swap(a, b int) {
    a, b = b, a
}

a, b := 5, 9
swap(a, b)
fmt.Println(a, b) // 5 9 (no cambian)

Paso por referencia (punteros)

El valor original sí se modifica.

func swap(a, b *int) {
    *a, *b = *b, *a
}

a, b := 5, 9
swap(&a, &b)
fmt.Println(a, b) // 9 5 (sí cambian)

5. 🔙 Valores de retorno

Retorno único

func sumar(x, y int) int {
    return x + y
}

resultado := sumar(4, 6)
fmt.Println(resultado) // 10

Múltiples retornos

Ideal para retornar un resultado y un posible error.

func dividir(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("no se puede dividir por cero")
    }
    return a / b, nil
}

Retorno con nombres

func sumar(x, y int) (resultado int) {
    resultado = x + y
    return // Se retorna implícitamente
}

6. 🧮 Funciones variádicas

Permiten recibir una cantidad indefinida de argumentos del mismo tipo.

func sumarTodo(base int, numeros ...int) int {
    for _, n := range numeros {
        base += n
    }
    return base
}

fmt.Println(sumarTodo(10, 1, 2, 3)) // 16

Notas:

• Solo puedes tener un parámetro variádico.
• Debe ser el último en la lista de parámetros.
• Para pasar un slice, usa ...:

nums := []int{1, 2, 3}
fmt.Println(sumarTodo(10, nums...))

7. 👤 Funciones anónimas y closures

Función sin nombre (anónima)

doble := func(x int) int {
    return x * 2
}
fmt.Println(doble(4)) // 8

Closure: guarda estado

contador := 0
incrementar := func() int {
    contador++
    return contador
}

fmt.Println(incrementar()) // 1
fmt.Println(incrementar()) // 2

🧼 Buenas prácticas

1. Usa nombres descriptivos para funciones (sumar, dividir).
2. Divide funciones largas en otras más pequeñas.
3. Usa punteros solo cuando necesites modificar valores originales.
4. Siempre maneja los errores si tu función puede fallar.

✅ Conclusión

• Las funciones son bloques reutilizables que pueden tener parámetros, valores de retorno y comportamientos avanzados.
• En Go puedes retornar múltiples valores, usar punteros y crear funciones variádicas o anónimas.
• Dominar las funciones te permite escribir programas más organizados, limpios y mantenibles.

🛠️ Práctica recomendada

1. Escribe una función areaRectangulo(base, altura int) int que retorne el área.
2. Crea una función mostrarNombreCompleto(nombre, apellido string) que imprima el nombre.
3. Escribe una función esPar(n int) (bool) que retorne true si es par.
4. Implementa una función variádica sumarNumeros(nums ...int) int.
5. Usa punteros para modificar una variable int dentro de una función.

🚀 Siguientes pasos

Ahora que dominas las funciones, te sugiero avanzar a:

• 🧱 Structs: Crea tus propios tipos de datos.
• 🧠 Interfaces: Usa programación orientada a contratos.
• 🔒 Manejo de errores avanzado: Diseña funciones más robustas.