Funciones

Introducción

Definición:

function nombre (<argumentos>) {
   <cuerpo de la funcion>
}

por ejemplo, la siguiente función pura (no tiene “side-effects”):

function multiplica (x, y) {
   return x * y;
}

y se usa:

// miVar toma como valor el producto de 3 por 2, 6
var miVar = multiplica(3,2);
// ahora miVar vale 60
miVar = multiplica(miVar,10);

Lexical Scope

Las variables declaradas fuera de funciones son “globales”.

Las variables declaradas dentro de las funciones serán locales.

Por ejemplo:

var x = "fuera";

var f1 = function() {
  var x = "dentro de f1"; // Usa "var": declaración local
};
f1();
console.log(x);
// Imprimirá: "fuera"

var f2 = function() {
  x = "dentro de f2";  // No usa "var": usa la variable global
};
f2();
console.log(x);
// Imprimirá: "dento de f2"

Closure

El scope puede ser anidado, lo que posibilita la definición de “closures”: generador parametrizada de funciones:

var gen_fun = function gen_adder( param ) {
   // param: es local a "gen_adder"
   return function(x) {  // Anónima
     return x+param
   }
}

En donde:

• param: es local a gen_adder y está disponible a todas las funciones anidadas.
• Devuelve un función anónima.

Advertencia

no develver funciones dentro de “if”.

Notación

Lo siguiente:

var square = function() {...}

es equivalente:

function square() {...}

Argumentos

Las funciones admiten cualquier número de argumentos. Aquellos que no se usan, simplemente se ignoran. Esto se puede aprovechar para hacer que las funciones acepten argumentos opcionales:

function power(base, exponent) {
  if (exponent == undefined)
    exponent = 2;
  var result = 1;
  for (var count = 0; count < exponent; count++)
    result *= base;
  return result;
}

Funciones Puras / Funciones con side-effects

Las funciones puras son aquellas que típicamente devuelven un valor. Funciones con side-effects no devuelven ningún valor pero tienen efectos: imprimir en pantalla, modificar variables globales.

Programación funcional

Recursiva

Ejemplo:

function map (funcion, matriz) {
  if (matriz.length==0) {
    return matriz;
  else {
    return new Array().concat(car = funcion(matriz.shift())).concat(map(funcion,matriz));
  }
}

function cuadrado (x) {
return x * x;
}

var miArray = new Array(1,2,3,4,5,6);
/*map devolvera una matriz cuyos elementos son el cuadrado de los elementos de miArray*/
var resultado = map(cuadrado,miArray);

Advertencia

la recursión, aunque elegante, puede resultar hasta 10 veces más lento.

Composición

Ejemplo:

function componer (f, g, x) {
   return f(g(x));
}

Orden superior

Devolvemos funciones:

function operar (operacion) {
switch (operacion){
case “rep”:
return reponer;
case “ven”:
return vender;
}
}

function reponer (cantidad) {
dinero = dinero – (cantidad * 5);
unidades = unidades + cantidad;
}

function vender (cantidad) {
dinero = dinero + (cantidad * 10);
unidades = unidades – cantidad;
}

var dinero = 1000;
var unidades = 100;
//Ahora tenemos 990 euros y 102 unidades
operar(“rep”)(2);
//y despues de vender 50, 1490 euros y 52 unidades
operar(“ven”)(50);