Funciones y subprocesos en pseudocódigo

Para qué sirven

Cuando un programa crece, empiezas a repetir las mismas líneas: calcular un área, mostrar un saludo, revisar si un número es par. En lugar de copiarlas, las escribes una vez, les pones un nombre y las llamas cada vez que las necesitas. Eso es una función o un subproceso.

Tienen la misma estructura, pero con una diferencia:

Si lo que necesitas es una respuesta (un número, un texto, Verdadero o Falso), usa una función. Si solo necesitas que algo suceda, usa un subproceso.

La función: devuelve un valor

Una función se declara con Funcion, el nombre de la variable que guardará el resultado, una flecha, el nombre de la función y sus parámetros entre paréntesis. Dentro, el resultado se guarda en esa variable, y eso es lo que devuelve:

Funcion a <- AreaRectangulo(base, altura)
    a <- base * altura
FinFuncion

Algoritmo areas
    Escribir AreaRectangulo(3, 4)
    Escribir AreaRectangulo(5, 2) + 1
FinAlgoritmo

Aquí a es el resultado de la función. Como devuelve un valor, la llamada se puede usar en cualquier lugar donde iría un número: en un Escribir, en una suma, en una condición.

Una función también puede devolver texto:

Funcion t <- Etiqueta(n)
    Si n >= 6 Entonces
        t <- "Aprobado"
    SiNo
        t <- "Reprobado"
    FinSi
FinFuncion

Algoritmo calificacion
    Leer c
    Escribir Etiqueta(c)
FinAlgoritmo

El subproceso: hace algo, sin devolver nada

Un subproceso no tiene variable de resultado. Se llama como una instrucción suelta:

SubProceso Saludar(nombre)
    Escribir "Hola, ", nombre
FinSubProceso

Algoritmo saludos
    Saludar("Ana")
    Saludar("Luis")
FinAlgoritmo

Escribimos Saludar una vez y la usamos dos veces con datos distintos. Esa es la ventaja: si mañana quieres cambiar el saludo, lo cambias en un solo lugar.

Parámetros: por valor y Por Referencia

Los parámetros son los datos que le pasas a la función entre paréntesis. Hay dos formas de pasarlos.

Por valor (lo normal)

La función recibe una copia. Si la cambia, la variable de afuera no se entera:

SubProceso Duplicar(n)
    n <- n * 2
    Escribir "Dentro: ", n
FinSubProceso

Algoritmo copia
    x <- 5
    Duplicar(x)
    Escribir "Fuera: ", x
FinAlgoritmo

Por referencia

Con Por Referencia, la función trabaja con la variable original, y lo que cambie adentro se ve afuera:

SubProceso Duplicar(n Por Referencia)
    n <- n * 2
FinSubProceso

Algoritmo referencia
    x <- 5
    Duplicar(x)
    Escribir x
FinAlgoritmo

Es la forma de lograr que un subproceso «devuelva» más de un valor, como en el intercambio de dos variables:

SubProceso Intercambiar(a Por Referencia, b Por Referencia)
    aux <- a
    a <- b
    b <- aux
FinSubProceso

Algoritmo cambio
    p <- 1
    q <- 2
    Intercambiar(p, q)
    Escribir p, " ", q
FinAlgoritmo

Un parámetro Por Referencia necesita una variable al llamar, no un valor suelto: Duplicar(x) sirve, Duplicar(5) no, porque no hay una caja donde guardar el cambio.

Cada función tiene sus propias variables

Las variables que creas dentro de una función existen solo ahí, y las del algoritmo no se ven adentro. Jaguar no tiene variables globales: lo que una función necesita se lo pasas por parámetros.

SubProceso MostrarTotal()
    Escribir total
FinSubProceso

Algoritmo a
    total <- 10
    MostrarTotal()
FinAlgoritmo

La función no ve el total del algoritmo. Se arregla pasándolo como parámetro:

SubProceso MostrarTotal(total)
    Escribir total
FinSubProceso

Algoritmo a
    total <- 10
    MostrarTotal(total)
FinAlgoritmo

Que cada función tenga sus variables evita sorpresas: puedes usar i o suma en todas sin que se mezclen. Si te sale un error así, está explicado en «No encuentro la variable».

Los arreglos se comparten

Los arreglos son la excepción: cuando se lo pasas a una función, no se copia, sino que se comparte. Lo que la función cambie en sus casillas se ve afuera, sin necesidad de Por Referencia:

SubProceso LlenarCon(v, valor, n)
    Para i <- 1 Hasta n Hacer
        v[i] <- valor
    FinPara
FinSubProceso

Algoritmo arreglo
    Dimension notas[3]
    LlenarCon(notas, 7, 3)
    Escribir notas[1] + notas[3]
FinAlgoritmo

Más sobre arreglos en la guía de arreglos.

Recursión: una función que se llama a sí misma

Una función puede llamarse a sí misma. Es útil cuando un problema se parte en uno más chico del mismo tipo, como el factorial: 5! = 5 × 4!. Necesita un caso base, el momento en que responde sin llamar de nuevo, o no termina nunca:

Funcion r <- Factorial(n)
    Si n <= 1 Entonces
        r <- 1
    SiNo
        r <- n * Factorial(n - 1)
    FinSi
FinFuncion

Algoritmo recursion
    Escribir Factorial(5)
FinAlgoritmo

El caso base es n <= 1, y cada llamada se acerca a él restando uno. Si olvidas el caso base, aparece el error «Demasiadas llamadas a funciones».

Dónde se escriben

Las funciones y los subprocesos se pueden escribir antes o después del Algoritmo; Jaguar los encuentra igual:

Algoritmo despues
    Escribir Doble(21)
FinAlgoritmo

Funcion r <- Doble(n)
    r <- n * 2
FinFuncion

Por orden, lo normal es ponerlas arriba, antes del algoritmo, para que quien lea el programa conozca las piezas antes de ver cómo se usan.

Los errores más comunes

• Pasar un número distinto de argumentos: «'Suma' recibe 2 valores, pero se le dieron 1». Hay que dar un dato por cada parámetro. Está explicado en errores al usar funciones.
• Una función que termina sin dar valor: olvidaste guardar el resultado en la variable que nombra la función.
• Recursión sin caso base: las llamadas no terminan nunca.
• Usar como nombre una palabra del lenguaje: Mostrar, Leer o y ya significan algo, y no sirven de nombre.

Preguntas frecuentes