## 2.

7 Funciones
---

Las funciones de JavaScript se **definen** mediante la palabra reservada

`function`

```js
function suma(a, b) {
return a+b;
}
```

* No es obligatorio que las funciones tengan una instrucción de tipo `return` para
devolver valores.
* Cuando una función no devuelve ningún valor o cuando en la instrucción
`return`sin ningún valor, devuelve `undefined`.

Para **llamar** a una función se indica su nombre junto con la lista de parámetros
esperados

* En los parámetros podemos poner operaciones que se evaluarán antes de pasarlos a

la función

```js
var resultado1 = suma(2, 3); //5
var resultado2 = suma(4+3-5, 13%5); //5
```

* Como JavaScript no define tipos de variables, no es posible asegurar que los

parámetros que se pasan a una función sean los del tipo adecuado para las
operaciones que realiza la función.
* Si a una función se le pasan más parámetros que los que ha definido, *los
parámetros sobrantes se ignoran*.
* *Si se pasan menos parámetros* que los que ha definido la función, al resto de
parámetros hasta completar el número correcto se les asigna el valor `undefined`.

**Funciones anidadas:** Una función puede contener en su interior otras funciones

anidadas

```js
/*

Calcular la suma del cuadrado de dos números.

Para ello, se define en el interior de la función otra función que calcula el
cuadrado del número que se le pasa.

Para obtener el resultado final, la función sumaCuadrados() hace uso de la

función anidada `cuadrado()`.

*/
function sumaCuadrados(a, b)
{
function cuadrado(x)
{ return x*x;
}

return cuadrado(a) + cuadrado(b);

}
```

**Funciones anónimas o literals:**, consiste en definir una función sin usar un

nombre, son útiles cuando se van a utilizar una vez .

```js
// función anónima
var miFuncion = function(a, b) { return a+b; }
```

**Protegiendo llamadas a una función con menos argumentos de los estipulados.**

Cuando una función recibe menos parámetros, a los parámetros faltantes se les
asigna el valor `undefined`.

Puede ser necesario proteger a la aplicación frente a posibles valores incorrectos

en sus parámetros.

```js

function suma(a, b)
{
if(isNaN(b))
{
b = 0;
}
return a + b;
}
resultado = suma(2,"hola"); // Res: 2
resultado = suma(2); // Res: 2

```

La función del ejemplo anterior comprueba que `b` sea un número para poder realizar
correctamente la suma. En caso de que no lo sea (es decir, que sea `null`,
`undefined` o cualquier valor válido distinto de un número) se le asigna el valor
`0` para que la función pueda devolver un resultado válido.

JavaScript permite prescindir de la comprobación anterior y obtener el mismo

resultado mediante el siguiente truco que hace uso del operador `OR` (`||`):

```js

function suma(a, b) {
b = b || 0;
return a + b;
resultado = suma(2,"hola"); // Res: 2hola
resultado = suma(2); // Res: 2
}
```

En el ejemplo anterior, si a la función no se le pasa el parámetro `b`,

automáticamente se asigna el valor `0` a ese parámetro. El truco funciona porque el
comportamiento del operador lógico `OR` (y también el del operador `AND`) es más
complejo de lo que se ha explicado anteriormente.

* Si el primer operando de un OR es `true` o cualquier otro valor que se puede

transformar en `true`, se devuelve directamente el valor de ese operando.
* En otro caso, se evalúa el segundo operando y se devuelve directamente su valor.

```js
alert(true || false); // true
alert(3 || false); // 3
alert(true || 5); // true
alert(false || true); // true
alert(false || 5); // 5
alert(3 || 5); // 3
```

De esta forma, si se utilizan las siguientes llamadas a la función:

```js
// en todos los casos la variable b vale 0
suma(3); // b->indefinida -> false, entonces b||0 es cero
suma(3, null); // b-> null -> false, mismo caso b||0 es cero
suma(3, false); // b-> false, mismo caso b||0 es cero
```

**objeto array arguments**

El objeto array `arguments` contiene todos los parámetros con los que se ha
invocado a la función, y solamente está definido dentro de la función.

```js
function suma(a, b)
{
alert(arguments.length); // 2
alert(arguments[0]); // 3
alert(arguments[1]); // 5
alert(arguments[2]); // undefinided
return a + b;
}
suma(3, 5);
```

El array `arguments` permite crear funciones con un número variable de argumentos:

```js
function mayor()
{
alert(arguments.callee); // muestra el código fuente de la función que se está
ejecutando
var elMayor = arguments[0];
for(var i=1; i<arguments.length; i++)
{
if(arguments[i] > elMayor)
{
elMayor = arguments[i];
}
}
alert(elMayor);

var variable1 = mayor(1, 3, 5, 8); // 8

var variable2 = mayor(4, 6, 9, 1, 2, 3, 4, 5); //9
```

Técnicamente, `arguments` no es un array, sino que es un objeto de tipo

`Arguments`. Sin embargo, por sus propiedades y sus métodos de acceso, se puede
considerar como si fuera un array.

La propiedad `arguments.calle` guarda el código fuente de la función.

* La propiedad `arguments.callee.length` indica el número de parámetros que se
incluyen en la **definición** de la función
* `arguments.length` indica el número de parámetros con los que se ha llamado a
la función.

```js
function suma(a, b) {
alert(arguments.callee.length); // 2
alert(arguments.length); // 4
return a + b;
}
suma(3, 5, 7, 9);
```