10 min Lógica de Programación

Funciones

Piensa en una máquina de café. Le metes dinero, pulsas el botón de "café con leche" y te da un café con leche. No necesitas saber cómo funciona por dentro: que calienta el agua, que muele los granos, que calienta la leche. Solo sabes que entra un pedido y sale un café. Eso es exactamente lo que es una función: una máquina que recibe algo, hace su trabajo, y devuelve un resultado.

Las funciones son la herramienta más poderosa para organizar tu pensamiento. En vez de resolver un problema enorme de golpe, lo troceas en problemas pequeños, y cada función resuelve uno.

Anatomía de una función

Toda función tiene cuatro partes:

Nombre: describe qué hace. Debe ser claro y específico.
Parámetros (entradas): la información que necesita para trabajar.
Cuerpo: las instrucciones que ejecuta.
Valor de retorno (salida): el resultado que devuelve.

FUNCION calcular_propina(cuenta, porcentaje)
    propina = cuenta * porcentaje / 100
    DEVOLVER propina
FIN FUNCION

// Usar la función
resultado = calcular_propina(45.00, 15)
mostrar "La propina es: " + resultado + " euros"   // 6.75 euros

Fíjate: cuenta y porcentaje son los parámetros (lo que entra). La función hace el cálculo y DEVOLVER saca el resultado. Después, puedes usar ese resultado donde quieras.

Analogía: los parámetros son los ingredientes

Si una función es una receta de cocina, los parámetros son los ingredientes. No puedes hacer una tortilla sin huevos. Y la misma receta con diferentes ingredientes da resultados diferentes:

FUNCION hacer_bocadillo(tipo_pan, relleno)
    bocadillo = tipo_pan + " con " + relleno
    DEVOLVER bocadillo
FIN FUNCION

mostrar hacer_bocadillo("baguette", "jamón y queso")
// "baguette con jamón y queso"

mostrar hacer_bocadillo("chapata", "tortilla de patatas")
// "chapata con tortilla de patatas"

mostrar hacer_bocadillo("molde", "atún con tomate")
// "molde con atún con tomate"

Misma función, diferentes parámetros, diferentes resultados. Esa es la magia de la reutilización.

La máquina de café: función con varios pasos

Vamos a formalizar la analogía de la máquina de café:

FUNCION preparar_cafe(tipo, tamano, con_azucar)
    // Paso 1: elegir la base
    SI tipo = "espresso" ENTONCES
        base = "café concentrado"
        tiempo_preparacion = 25  // segundos
    SINO SI tipo = "americano" ENTONCES
        base = "café con agua caliente"
        tiempo_preparacion = 30
    SINO SI tipo = "con leche" ENTONCES
        base = "café con leche caliente"
        tiempo_preparacion = 35
    SINO
        base = "café solo"
        tiempo_preparacion = 20
    FIN SI

    // Paso 2: ajustar el tamaño
    SI tamano = "grande" ENTONCES
        cantidad_ml = 350
        precio = 2.50
    SINO SI tamano = "mediano" ENTONCES
        cantidad_ml = 250
        precio = 2.00
    SINO
        cantidad_ml = 150
        precio = 1.50
    FIN SI

    // Paso 3: azúcar
    SI con_azucar ENTONCES
        extras = " con azúcar"
    SINO
        extras = " sin azúcar"
    FIN SI

    // Paso 4: devolver el resultado
    bebida = base + extras + " (" + cantidad_ml + "ml)"
    DEVOLVER { bebida: bebida, precio: precio, tiempo: tiempo_preparacion }
FIN FUNCION

// Usarla
mi_cafe = preparar_cafe("con leche", "grande", verdadero)
mostrar mi_cafe.bebida   // "café con leche caliente con azúcar (350ml)"
mostrar mi_cafe.precio   // 2.50
mostrar mi_cafe.tiempo   // 35

Desde fuera, solo ves: le paso el tipo, tamaño y si quiero azúcar, y me devuelve el café. No necesito saber los pasos internos. Eso se llama abstracción: ocultar la complejidad detrás de una interfaz sencilla.

Reutilización: escribe una vez, usa muchas

Sin funciones, calcular el coste de envío para tres pedidos diferentes sería así:

// SIN funciones: repetición constante
// Pedido 1
SI peso1 <= 2 ENTONCES
    coste1 = 3.99
SINO SI peso1 <= 5 ENTONCES
    coste1 = 5.99
SINO
    coste1 = 5.99 + (peso1 - 5) * 1.50
FIN SI
SI distancia1 > 500 ENTONCES
    coste1 = coste1 + 4.00
FIN SI

// Pedido 2: exactamente la misma lógica copiada...
SI peso2 <= 2 ENTONCES
    coste2 = 3.99
SINO SI peso2 <= 5 ENTONCES
    coste2 = 5.99
SINO
    coste2 = 5.99 + (peso2 - 5) * 1.50
FIN SI
SI distancia2 > 500 ENTONCES
    coste2 = coste2 + 4.00
FIN SI

// Y para el pedido 3, otra vez lo mismo... ¡Agotador!

Con una función, escribes la lógica una sola vez:

// CON funciones: la lógica se escribe UNA vez
FUNCION calcular_envio(peso, distancia, es_urgente)
    // Coste base según peso
    SI peso <= 2 ENTONCES
        coste = 3.99
    SINO SI peso <= 5 ENTONCES
        coste = 5.99
    SINO
        coste = 5.99 + (peso - 5) * 1.50
    FIN SI

    // Recargo por distancia
    SI distancia > 500 ENTONCES
        coste = coste + 4.00
    FIN SI

    // Recargo por urgencia
    SI es_urgente ENTONCES
        coste = coste * 1.5
    FIN SI

    DEVOLVER coste
FIN FUNCION

// Ahora calcular 3 pedidos es facilísimo
coste1 = calcular_envio(1.5, 200, falso)    // 3.99
coste2 = calcular_envio(7, 600, verdadero)   // (5.99 + 3.00 + 4.00) * 1.5 = 19.49
coste3 = calcular_envio(3, 100, falso)       // 5.99

mostrar "Envío pedido 1: " + coste1 + " euros"
mostrar "Envío pedido 2: " + coste2 + " euros"
mostrar "Envío pedido 3: " + coste3 + " euros"

Si mañana cambian las tarifas de envío, solo modificas la función. No tienes que buscar y cambiar el código en 50 sitios diferentes. Ese es el verdadero poder de las funciones.

Dividir problemas grandes en funciones pequeñas

Esta es la habilidad más importante de un programador. Piensa en pedir comida a domicilio. El proceso completo es complejo, pero se puede dividir en pasos claros, y cada paso es una función:

FUNCION validar_direccion(direccion)
    SI direccion tiene calle Y numero Y ciudad ENTONCES
        DEVOLVER verdadero
    SINO
        DEVOLVER falso
    FIN SI
FIN FUNCION

FUNCION calcular_total_pedido(lista_platos)
    total = 0
    PARA CADA plato EN lista_platos HACER
        total = total + plato.precio
    FIN PARA CADA
    DEVOLVER total
FIN FUNCION

FUNCION aplicar_descuento(total, codigo_cupon)
    SI codigo_cupon = "PRIMERA" ENTONCES
        DEVOLVER total * 0.80    // 20% descuento
    SINO SI codigo_cupon = "AMIGO" ENTONCES
        DEVOLVER total * 0.90    // 10% descuento
    SINO
        DEVOLVER total           // sin descuento
    FIN SI
FIN FUNCION

FUNCION estimar_tiempo_entrega(distancia_km)
    tiempo_base = 20   // minutos de preparación
    tiempo_viaje = distancia_km * 3   // 3 minutos por km
    DEVOLVER tiempo_base + tiempo_viaje
FIN FUNCION

// === PROGRAMA PRINCIPAL ===
// Cada función hace UNA cosa. El programa las combina.

platos = [
    { nombre: "Pizza margarita", precio: 9.50 },
    { nombre: "Ensalada césar", precio: 7.00 },
    { nombre: "Tiramisú", precio: 5.50 }
]
direccion = { calle: "Gran Vía", numero: 42, ciudad: "Madrid" }
cupon = "PRIMERA"
distancia = 4

SI validar_direccion(direccion) ENTONCES
    total = calcular_total_pedido(platos)
    total_final = aplicar_descuento(total, cupon)
    tiempo = estimar_tiempo_entrega(distancia)

    mostrar "Total: " + total_final + " euros"
    mostrar "Llegará en unos " + tiempo + " minutos"
SINO
    mostrar "Dirección no válida. Revísala e inténtalo de nuevo."
FIN SI

Cada función es simple y fácil de entender por separado. El programa principal las combina como piezas de LEGO. Si hay un error en el cálculo del descuento, sabes exactamente dónde buscar: en la función aplicar_descuento.

Funciones que usan otras funciones

Las funciones pueden llamar a otras funciones. Esto crea una cadena donde cada pieza resuelve su parte y pasa el resultado a la siguiente:

FUNCION calcular_precio_base(producto, cantidad)
    DEVOLVER producto.precio * cantidad
FIN FUNCION

FUNCION aplicar_impuestos(subtotal, porcentaje_iva)
    DEVOLVER subtotal * (1 + porcentaje_iva / 100)
FIN FUNCION

FUNCION formatear_precio(cantidad)
    DEVOLVER cantidad + " euros"
FIN FUNCION

FUNCION generar_ticket(producto, cantidad, iva)
    // Esta función USA las tres anteriores
    subtotal = calcular_precio_base(producto, cantidad)
    total = aplicar_impuestos(subtotal, iva)
    precio_formateado = formatear_precio(total)

    mostrar "=== TICKET ==="
    mostrar producto.nombre + " x" + cantidad
    mostrar "Subtotal: " + formatear_precio(subtotal)
    mostrar "IVA (" + iva + "%): " + formatear_precio(total - subtotal)
    mostrar "TOTAL: " + precio_formateado
    mostrar "==============="
FIN FUNCION

// Una sola llamada hace todo el trabajo
camiseta = { nombre: "Camiseta premium", precio: 24.99 }
generar_ticket(camiseta, 3, 21)

La función generar_ticket no sabe cómo se calculan los impuestos ni cómo se formatea un precio. Solo sabe que puede llamar a otras funciones que lo hacen. Cada función tiene una sola responsabilidad.

Buenas prácticas con funciones

Un nombre claro: calcular_envio es mejor que hacer_cosa o funcion1.
Una sola tarea: si tu función hace demasiadas cosas, divídela en varias.
Parámetros claros: si tu función necesita 8 parámetros, probablemente hace demasiado.
Siempre DEVOLVER algo: salvo excepciones, tus funciones deben devolver un resultado.
No depender de cosas externas: una buena función trabaja solo con los parámetros que recibe, no con variables "mágicas" de fuera.

Resumen

Función: bloque de instrucciones con nombre, parámetros, cuerpo y valor de retorno.
Parámetros: los datos que la función necesita para trabajar (las entradas).
DEVOLVER: el resultado que la función produce (la salida).
Reutilización: escribe la lógica una vez, úsala cuantas veces necesites.
Dividir problemas: un problema grande se convierte en varios problemas pequeños y manejables.
Composición: las funciones pueden llamar a otras funciones para resolver tareas complejas.

Con condicionales, bucles y funciones ya tienes las tres piezas fundamentales de la lógica de programación. Todo programa del mundo, desde una app de notas hasta un videojuego, se construye combinando estas tres herramientas.

Con papel y bolígrafo, diseña en pseudocódigo las funciones para una calculadora básica. Debes crear:

sumar(a, b) que devuelve la suma de dos números.
restar(a, b) que devuelve la resta.
multiplicar(a, b) que devuelve la multiplicación.
dividir(a, b) que devuelve la división. Pero cuidado: si b es 0, debe devolver un mensaje de error en vez de intentar dividir (no se puede dividir entre cero).
calcular(a, operacion, b) que recibe dos números y el nombre de la operación ("sumar", "restar", "multiplicar", "dividir") y usa un condicional para llamar a la función correspondiente.

Luego, escribe un programa principal que use calcular para resolver esta expresión paso a paso: (10 + 5) * 3 - 8 / 2. Guarda cada resultado intermedio en una variable y muestra el resultado final.

Pistas

Las cuatro funciones básicas son muy sencillas (una línea cada una, salvo dividir que necesita un SI para comprobar si b es 0). La función calcular usa SI / SINO SI para elegir qué función llamar según la operación. Para la expresión, resuelve primero los paréntesis: paso1 = calcular(10, "sumar", 5), luego paso2 = calcular(paso1, "multiplicar", 3), luego paso3 = calcular(8, "dividir", 2), y finalmente resultado = calcular(paso2, "restar", paso3).

Anterior Bucles

Siguiente Estructuras de datos