Ya sabemos cómo controlar el flujo de nuestros programas para que tomen decisiones y repitan tareas. Nuestros algoritmos empiezan a tener una lógica compleja. Sin embargo, a medida que un programa crece, nos enfrentamos a nuevos desafíos: el código se vuelve repetitivo, desordenado y difícil de mantener.

La solución a este problema es uno de los conceptos más elegantes de la programación: las funciones.

¿Qué es una función? 📦

Una función es un bloque de código autocontenido, al que le damos un nombre, y que está diseñado para realizar una tarea muy específica. Una vez definida, podemos «llamar» o «invocar» a esa función desde cualquier parte de nuestro programa para que ejecute su tarea.

Pensemos en una calculadora. Tiene un botón para la raíz cuadrada (√). No necesitas saber la fórmula matemática que usa internamente. Simplemente le proporcionas un número (un parámetro), pulsas el botón (la llamada a la función) y te devuelve un resultado (el valor de retorno). Una función en programación es exactamente eso: una «caja negra» que realiza un trabajo por nosotros.

La anatomía de una función: definición, cabecera y llamada anatomical_structure

Para trabajar con funciones, debemos distinguir tres momentos o conceptos clave:

• Definición: Es el proceso completo de crear la función. Incluye escribir todo el bloque de código: su nombre, sus parámetros y las instrucciones que ejecutará. En nuestro pseudocódigo, es todo lo que va desde Funcion hasta FinFuncion.
• Cabecera (o Firma): Es la primera línea de la definición. Actúa como el «DNI» de la función, especificando su nombre, los parámetros que espera recibir y (en muchos lenguajes) el tipo de dato que devolverá. La cabecera Funcion precio_final = CalcularIVA(precio_base, porcentaje_iva) nos dice todo lo que necesitamos saber para poder usar la función.
• Llamada (o Invocación): Es la instrucción que, desde otra parte del programa (como el proceso principal), ejecuta el código de la función. En una llamada, pasamos valores concretos, llamados argumentos, a los parámetros de la función. La línea precio_portatil = CalcularIVA(100, 21) es una llamada a nuestra función.

En resumen: definimos una función una sola vez, pero podemos llamarla todas las veces que necesitemos.

Las tres grandes ventajas de usar funciones ✨

Organizar nuestro código en funciones no es una simple sugerencia, es una práctica esencial que se apoya en tres pilares:

1. Reutilización (No te repitas) ♻️

Imagina que necesitas mostrar un encabezado con un formato específico en varias partes de tu programa. Sin funciones, tendrías que copiar y pegar el mismo bloque de código una y otra vez.

// Sin función
Escribir "************************"
Escribir "* INFORME DE VENTAS  *"
Escribir "************************"
// ... mucho código después ...
Escribir "************************"
Escribir "* INFORME DE ERRORES *"
Escribir "************************"

Esto es ineficiente y propenso a errores. Una función nos permite escribir el código una sola vez y reutilizarlo donde queramos.

2. Flexibilidad: parámetros y valores de retorno 🔧

Una función se vuelve realmente potente cuando puede comunicarse con el resto del programa. Esta comunicación se produce en dos direcciones: recibiendo datos para trabajar con ellos y devolviendo un resultado una vez ha terminado su tarea.

Recibiendo datos: los parámetros

Un parámetro es una variable especial que se declara en la definición/cabecera de una función y que sirve para recibir un valor desde el exterior. Gracias a ellos, una misma función puede producir resultados diferentes según los datos que le pasemos.

Una función puede tener:

• Múltiples parámetros: La mayoría de funciones necesitan varios datos para trabajar. Por ejemplo, una función para sumar necesitaría dos números.
• Un parámetro: Como en nuestro ejemplo del encabezado.
• Ningún parámetro: A veces, una función realiza una tarea que no requiere ninguna información externa, como obtener la fecha y hora actuales.

Podemos mejorar nuestro ejemplo anterior creando una función que acepte el texto del título como parámetro:

Fragmento de código

// Declaramos la función fuera del proceso principal
Funcion MostrarEncabezado(texto_titulo)
    Escribir "************************"
    Escribir "* ", texto_titulo, "   *"
    Escribir "************************"
FinFuncion

Proceso Principal
    MostrarEncabezado("INFORME DE VENTAS")
    // ... mucho código después ...
    MostrarEncabezado("INFORME DE ERRORES")
FinProceso

Ahora tenemos una única función flexible que se adapta a nuestras necesidades.

Devolviendo un resultado: el valor de retorno

Además de recibir datos, una función puede (y a menudo lo hace) devolver un valor al punto del programa donde fue llamada. Para ello, se utiliza una instrucción especial de retorno. El código que llama a la función puede entonces usar ese valor devuelto: guardarlo en una variable, usarlo en una expresión, etc.

Hay funciones que no devuelven nada (a veces se les llama «procedimientos»), ya que su único propósito es realizar una acción, como mostrar algo en pantalla.

Veámoslo con un ejemplo completo:

Vamos a crear una función que calcula el precio final de un producto aplicándole el IVA. Esta función necesitará dos parámetros (el precio base y el porcentaje de IVA) y devolverá un valor (el precio final).

Fragmento de código

// Declaramos la función fuera del proceso principal
// Recibe dos parámetros y devuelve un valor numérico
Funcion precio_final = CalcularIVA(precio_base, porcentaje_iva)
    impuesto = precio_base * (porcentaje_iva / 100)
    precio_final = precio_base + impuesto
    Devolver precio_final // Devuelve el resultado del cálculo
FinFuncion

Proceso Principal
    // Llamamos a la función con los argumentos 100 y 21
    // El valor devuelto se guarda en la variable 'precio_portatil'
    precio_portatil = CalcularIVA(100, 21)
    Escribir "El precio final del portátil es: ", precio_portatil

    // Podemos reutilizarla con otros argumentos
    precio_raton = CalcularIVA(20, 21)
    Escribir "El precio final del ratón es: ", precio_raton
FinProceso

Como puedes ver, CalcularIVA es una herramienta flexible y reutilizable gracias a sus parámetros y a su valor de retorno. La hemos definido una vez y la hemos usado para realizar dos cálculos distintos, almacenando sus resultados en variables diferentes.

3. Organización (Divide y vencerás) 🧩

Las funciones son la principal herramienta para aplicar la estrategia «divide y vencerás» a la programación. Nos permiten descomponer un problema grande y complejo en subproblemas más pequeños y manejables. Cada función se encarga de resolver uno de esos subproblemas.

Un programa para gestionar una biblioteca podría tener funciones como:

• BuscarLibroPorTitulo()
• PrestarLibroAUsuario()
• ComprobarDisponibilidad()

Este enfoque, conocido como modularidad, hace que el código sea infinitamente más fácil de leer, entender y, sobre todo, depurar. Si hay un error al prestar un libro, sabremos que debemos revisar la función PrestarLibroAUsuario().

Conclusión

Las funciones son los ladrillos con los que se construyen los programas robustos y mantenibles. Nos permiten empaquetar la lógica en unidades reutilizables, hacerla flexible mediante parámetros y organizar la complejidad de nuestros algoritmos.

A partir de ahora, piensa siempre en cómo puedes dividir tus programas en funciones que realicen tareas específicas.

Ya sabemos cómo organizar nuestro código. En las próximas entradas, empezaremos a ver cómo organizar nuestros datos de formas más complejas y eficientes, empezando por las listas.