1

TEMA 6: FUNCIONES
Autores: Luis Javier Herrera Maldonado
José Luis Bernier Villamor

Contenido:
1. Introducción
2. Estructura de una función
3. Parámetros formales y parámetros reales
4. Argumentos de entrada y salida
5. Ámbito de las variables
6. Comparativa entre scripts y funciones
1. Funciones 2

• Una función podemos definirla como un “programa” (script

especial) que toma unos argumentos de entrada y
devuelve unas salidas

• Las ventajas de la programación modular (programar

construyendo y utilizando módulos o funciones) son diversas!

– Agrupar instrucciones de forma que éstas se ejecuten conjuntamente a

partir de unos valores genéricos.

– Crear ‘instrucciones’ más complejas agrupando instrucciones sencillas.

– Aportar claridad e independencia a nuestros programas.

– Obtener un ahorro considerable de escritura de código redundante.

2. Estructura de una función 3

• Toda función consta de una cabecera y de un cuerpo

• La cabecera informa de:
– Nombre de la función
– Argumentos de entrada
– Argumentos de salida
• El cuerpo incluye un conjunto de instrucciones tal que:
– Podrán utilizar un conjunto de variables que denominaremos
locales (toda variable nueva dentro de una función NO GUARDA
SU NOMBRE NI VALOR FUERA DE ÉSTA)
– Podrá usar los argumentos de entrada como variables
– Podrá y deberá asignar valores los argumentos de salida
2. Estructura de una función 4

• Sintaxis:
function [y1,..., yN] = myfun(x1,..., xM)
%Comentarios
… %código justificado una tabulación a la derecha
end
• Descripción
– function [y1,...,yN] = myfun(x1,...,xM) declara una función llamada
myfun que acepta argumentos de entrada x1,... xM y devuelve
salidas y1,... yN. Esta línea de declaración debe ser la primera en
un archivo de función
• Este código de declaración, cabecera y cuerpo, deberá
guardarse como un archivo de texto .m. El nombre del
archivo deberá ser el mismo que el de la función. Los
nombres válidos de funciones deberán comenzar con un
carácter alfabético, podrán contener letras, números y
carácter subrayado.
2. Estructura de una función 5

function y = media(x)
% Función que calcula la media de los valores de un vector
%Argumentos de entrada:
% x: vector de entrada
%Argumentos de salida:
% y: media de los valores de x

suma = 0;
longitud = length(x);
for i = 1:longitud
suma = suma + x(i);
end
y = suma/longitud;
end
- Desde la línea de Comandos:
>> z = 1:99;

>> media(z)
ans =
50
2. Estructura de una función 6

function [m,s] = estadisticas(x)

% Función stat que devuelve la media y desviación estándar
de un vector de entrada
% Argumentos de entrada:
% x: vector de entrada
% Argumentos de salida:
% m: media de los valores de x
% s: desviación estándar de los valores de x
n = length(x);
m = sum(x)/n;
s = sqrt(sum((x-m).^2/n));
end

- Llamada a la función desde la línea de comandos

>> values = [12.7, 45.4, 98.9, 26.6, 53.1];
>> [ave,stdev] = estadisticas(values)
ave =
47.3400
stdev =
29.4124
3. Parámetros formales y parámetros reales 7

Parámetros formales
• Denominamos parámetros formales a los nombres de los
argumentos (y salida) de entrada de las funciones en su
declaración.
• Se usan para poder escribir la función y definir su
funcionamiento:
function [m,s] = estadisticas(x)
% Función stat que devuelve la media y desviación estándar
de un vector de entrada
% Argumentos de entrada:
% x: vector de entrada
% Argumentos de salida:
% m: media de los valores de x
% s: desviación estándar de los valores de x
n = length(x);
m = sum(x)/n;
s = sqrt(sum((x-m).^2/n));
end
3. Parámetros formales y parámetros reales 8

Parámetros actuales
• Denominamos parámetros actuales a las variables o
valores REALES (existentes en el workspace o
expresables en la línea de comandos) con los que se
llama a la función.
• Se emplean para poder utilizar la función:
>> values = [12.7, 45.4, 98.9, 26.6, 53.1];
>> [ave,stdev] = estadisticas(values)
ave =
47.3400
stdev =
29.4124
4. Argumentos de entrada y de salida 9

· Las variables nargin y nargout almacenan respectivamente el número de

argumentos de entrada y de salida de una función. Así, podríamos
programar condicionalmente según estos valores una función más genérica
function [resultado,absResultado] = sumame2(a,b)
% Función que...
% Argumentos de entrada:...
if (nargin == 2)
resultado = a + b;
elseif (nargin == 1)
resultado = a + a;
else
resultado = 0;
end
if nargout > 1
absResultado = abs(resultado);
end
end
-----------------------------------
>> value = sumame2(11,-22)
value = -11
>> [value,absValue] = sumame2(11,-22)
value = -11
absValue = 11
5. Ámbito de las variables 10

• Definimos el espacio de trabajo BASE → El espacio de

trabajo de MATLAB por defecto (con el que hemos
trabajado hasta ahora):
– En la línea de comandos y en los scripts podemos crear nuevas
variables, que serán visibles mientras que no las borremos con el
comando clear (o salgamos de MATLAB)
– Podemos visualizar el estado actual del espacio de trabajo con
whos
>> whos
Name Size Bytes Class Attributes

C 3x3 72 double
V 10x1 80 double
W 1x10 80 double
a 1x1 8 double
b 1x1 8 double
5. Ámbito de las variables 11

• Espacio de trabajo BASE y scripts:

– Los scripts, por tanto, USAN el espacio de trabajo BASE en sus
cálculos y operaciones. Implicaciones a resaltar:
• Cualquier variable nueva que se declare dentro del script,
estará disponible tras su ejecución en el espacio de trabajo
BASE
• Cualquier cambio con el comando clear dentro de un script
tiene efecto en el espacio de trabajo BASE
5. Ámbito de las variables 12

• Sin embargo, las funciones crean de forma automática un

espacio de trabajo PROPIO, y distinto en cada
ejecución de la función.
• En este espacio de trabajo estarán disponibles:
– Las variables “locales”, declaradas dentro de la función
– Los argumentos de entrada a la función
→ ojo!!! cambios en los argumentos de entrada no tienen efecto
fuera de la función!!!, esto es,
• es como si fuesen variables locales declaradas dentro de la
función
• pero cuyo valor inicial es el valor que tomaba la variable inicial
pasada como parámetro
5. Ámbito de las variables 13

function q = variableLocal(p)
% Función ejemplo que toma un valor p y lo modifica. Además genera un
% variable a para comprobar que dicha variable se pierde tras la
% ejecución (tras cerrarse el espacio de trabajo de la función)
a = 2;
disp(['-->en variableLocal, creo la variable a: ',num2str(a)]);
p=12;
disp(['-->en variableLocal, p pasa a valer: ', num2str(p)]);
q =p;
end
---------------------------------------------

% Script de prueba CASO A

p = 44
whos
disp(['En el espacio de trabajo base, p vale: ', num2str(p)]);
variableLocal(p);
disp(['En el espacio de trabajo base, p vale: ',num2str(p)]);
whos
5. Ámbito de las variables 14

• Ejecución del script:

p =
44
Name Size Bytes Class Attributes
ans 1x1 8 double
p 1x1 8 double
En el espacio de trabajo base, p vale: 44
-->en variableLocal, creo la variable a: 2
-->en variableLocal, p pasa a valer: 12
En el espacio de trabajo base, p vale: 44
Name Size Bytes Class Attributes
ans 1x1 8 double
p 1x1 8 double
• Qué pasa con la variable local a? → no aparece en el espacio
de trabajo base!!
• Qué pasa con el valor de p? → pese a que se modifica dentro
de la función, ésta modificación se pierde!!
5. Ámbito de las variables 15

function q = variableLocal(p)
% Función ejemplo que toma un valor p y lo modifica. Además genera un
% variable a para comprobar que dicha variable se pierde tras la
% ejecución (tras cerrarse el espacio de trabajo de la función)
a = 2;
disp(['-->en variableLocal, creo la variable a: ', num2str(a) ]);
p=12;
disp(['-->en variableLocal, p pasa a valer: ', num2str(p) ]);
q = p;
end
--------------------------------------------

% Script de prueba
p = 44
whos
disp(['En el espacio de trabajo base, p vale: ',num2str(p) ]);
p = variableLocal(p);
disp(['En el espacio de trabajo base, p vale: ',num2str(p) ]);
whos
5. Ámbito de las variables 16

p =
44
Name Size Bytes Class Attributes
ans 1x1 8 double
p 1x1 8 double
En el espacio de trabajo base, p vale: 44
-->en variableLocal, creo la variable a: 2
-->en variableLocal, p pasa a valer: 12
En el espacio de trabajo base, p vale: 12
Name Size Bytes Class Attributes
ans 1x1 8 double
p 1x1 8 double

Qué pasa con el valor de p? → ahora sí se ha modificado, PERO

NO DENTRO DE LA FUNCIÓN, SINO PORQUE SE HA
ALMACENADO EL VALOR DEVUELTO POR ÉSTA
5. Ámbito de las variables 17

• Existe la posibilidad de crear variables globales, que

aparecerán en todos los espacios de trabajo que se
deseen (el BASE y en tantas funciones como queramos).
• Para ello se incluye la siguiente instrucción en el espacio
de trabajo donde se desee utilizarla la variable como
global:
global var;
• A partir de entonces la variable var, podrá ser accedida y
modificada, y su valor y modificaciones se conservarán
entre un espacio y otro
• AHORA BIEN, LAS VARIABLES GLOBALES DAN
INFINITOS PROBLEMAS, (depuración: imposibildad de
detectar un error al programar, conflictos entre nombres
iguales,etc.) CON LO QUE NO LAS USAREMOS:
NUNCA SE USAN EN PROGRAMACIÓN
ESTRUCTURADA SALVO HONRADAS EXCEPCIONES
6. Diferencias entre scripts y funciones 18

• Puede ser difícil comprender la diferencia entre una y

otra, pues ambas se pueden usar igualmente para
resolver ciertos problemas en MATLAB. Sin embargo su
funcionamiento es totalmente diferente. Notemos además
– Ambas funciones y scripts se guardan como ficheros .m
pero:
– Un script es una secuencia de comandos de MATLAB
– En las funciones la primera línea es la definición de la misma
– Las variables en las funciones son locales (se crean en un nuevo
espacio de trabajo que desaparece al finalizar la función), en los
scripts están en el espacio de trabajo BASE, y además pueden
acceder a variables de éste
– Las funciones pueden aceptar datos a traves de los argumentos
de entrada y devolver datos a traves de los argumentos de salida
– Las funciones tienen que tener el mismo nombre en el fichero que
el nombre de la misma función