Funciones

Definir funciones

Declaracin de funcin

Una definicin de funcin (tambin denominada declaracin de funcin o expresin de funcin) consta de la palabra clave function, seguida de:

• El nombre de la funcin.
• Una lista de parmetros de la funcin, entre parntesis y separados por comas.
• Las declaraciones de JavaScript que definen la funcin, encerradas entre llaves, { ... }.

Por ejemplo, el siguiente cdigo define una funcin simple llamada square ("cuadrado"):

function square(number) {
  return number * number;
}

La funcin square toma un parmetro, llamado number. La funcin consta de una declaracin que dice devuelva el parmetro de la funcin (es decir, number) multiplicado por s mismo. La instruccin return especifica el valor devuelto por la funcin:

return number * number;

Los parmetros primitivos (como un number) se pasan a las funciones por valor; el valor se pasa a la funcin, pero si la funcin cambia el valor del parmetro, este cambio no se refleja globalmente ni en la funcin que llama.

Si pasas un objeto (es decir, un valor no primitivo, como Array o un objeto definido por el usuario) como parmetro y la funcin cambia las propiedades del objeto, ese cambio es visible fuera de la funcin, como se muestra en el siguiente ejemplo:

function myFunc(theObject) {
  theObject.make = 'Toyota';
}

[parcial]var mycar = { make: 'Honda', model: 'Accord', year: 1998 };
var x, y;

x = mycar.make; // x obtiene el valor "Honda"

myFunc(mycar);
y = mycar.make; // y obtiene el valor "Toyota"
                // (la propiedad make fue cambiada por la funcin)

Expresiones function

Si bien la declaracin de funcin anterior sintcticamente es una declaracin, las funciones tambin se pueden crear mediante una expresin function.

Esta funcin puede ser annima; no tiene por qu tener un nombre. Por ejemplo, la funcin square se podra haber definido como:

const square = function (number) {
  return number * number;
};
var x = square(4); // x obtiene el valor 16

Sin embargo, puedes proporcionar un nombre con una expresin function. Proporcionar un nombre permite que la funcin se refiera a s misma y tambin facilita la identificacin de la funcin en el seguimiento de la pila de un depurador:

const factorial = function fac(n) {
  return n < 2 ? 1 : n * fac(n - 1);
};

console.log(factorial(3));

Las expresiones function son convenientes cuando se pasa una funcin como argumento a otra funcin. El siguiente ejemplo muestra una funcin map que debera recibir una funcin como primer argumento y un arreglo como segundo argumento.

function map(f, a) {
  let result = []; // Crea un nuevo arreglo
  let i; // Declara una variable
  for (i = 0; i != a.length; i++) result[i] = f(a[i]);
  return result;
}

En el siguiente cdigo, la funcin recibe una funcin definida por una expresin de funcin y la ejecuta por cada elemento del arreglo recibido como segundo argumento.

function map(f, a) {
  let result = []; // Crea un nuevo arreglo
  let i; // Declara una variable
  for (i = 0; i != a.length; i++) result[i] = f(a[i]);
  return result;
}
const f = function (x) {
  return x * x * x;
};
let numbers = [0, 1, 2, 5, 10];
let cube = map(f, numbers);
console.log(cube);

La funcin devuelve: [0, 1, 8, 125, 1000].

En JavaScript, una funcin se puede definir en funcin de una condicin. Por ejemplo, la siguiente definicin de funcin define myFunc solo si num es igual a 0:

var myFunc;
if (num === 0) {
  myFunc = function (theObject) {
    theObject.make = "Toyota";
  };
}

Adems de definir funciones como se describe aqu, tambin puedes usar el constructor Function para crear funciones a partir de una cadena en tiempo de ejecucin, muy al estilo de eval().

Un mtodo es una funcin que es propiedad de un objeto. Obten ms informacin sobre objetos y mtodos en Trabajar con objetos.

Llamar funciones

Definir una funcin no la ejecuta. Definirla simplemente nombra la funcin y especifica qu hacer cuando se llama a la funcin.

Llamar a la funcin en realidad lleva a cabo las acciones especificadas con los parmetros indicados. Por ejemplo, si defines la funcin square, podras llamarla de la siguiente manera:

square(5);

La declaracin anterior llama a la funcin con un argumento de 5. La funcin ejecuta sus declaraciones y devuelve el valor 25.

Las funciones deben estar dentro del mbito cuando se llaman, pero la declaracin de la funcin se puede elevar (cuando aparece debajo de la llamada en el cdigo), como en este ejemplo:

console.log(square(5));
/* ... */
function square(n) {
  return n * n;
}

El mbito de una funcin es la funcin en la que se declara (o el programa completo, si se declara en el nivel superior).

console.log(square) // square se eleva con un valor inicial undefined.
console.log(square(5)) // Error de tipo no detectado: square no es una funcin
const square = function(n) {
return n \* n;
}

Los argumentos de una funcin no se limitan a cadenas y nmeros. Puedes pasar objetos completos a una funcin. La funcin show_props() (definida en Trabajar con objetos es un ejemplo de una funcin que toma un objeto como argumento.

Una funcin se puede llamar a s misma. Por ejemplo, aqu hay una funcin que calcula factoriales de forma recursiva:

function factorial(n) {
  if (n === 0 || n === 1) return 1;
  else return n * factorial(n - 1);
}

Luego, podras calcular los factoriales de 1 a 5 de la siguiente manera:

var a, b, c, d, e;
a = factorial(1); // a obtiene el valor 1
b = factorial(2); // b obtiene el valor 2
c = factorial(3); // c obtiene el valor 6
d = factorial(4); // d obtiene el valor 24
e = factorial(5); // e obtiene el valor 120

Hay otras formas de llamar funciones. A menudo hay casos en los que una funcin se tiene que llamar dinmicamente, o el nmero de argumentos de una funcin vara, o en los que el contexto de la llamada a la funcin se tiene que establecer en un determinado objeto especfico en tiempo de ejecucin.

Resulta que las funciones en s mismas son objetos y, a su vez, estos objetos tienen mtodos. (Consulta el objeto Function. Uno de estos, el mtodo apply(), se puede utilizar para lograr este objetivo.

mbito de function

No se puede acceder a las variables definidas dentro de una funcin desde cualquier lugar fuera de la funcin, porque la variable se define solo en el mbito de la funcin. Sin embargo, una funcin puede acceder a todas las variables y funciones definidas dentro del mbito en el que est definida.

En otras palabras, una funcin definida en el mbito global puede acceder a todas las variables definidas en el mbito global. Una funcin definida dentro de otra funcin tambin puede acceder a todas las variables definidas en su funcin principal y a cualquier otra variable a la que tenga acceso la funcin principal.

// Las siguientes variables se definen en el mbito global
var num1 = 20,
  num2 = 3,
  name = "Chamahk";

// Esta funcin est definida en el mbito global
function multiply() {
  return num1 * num2;
}

multiply(); // Devuelve 60

// Un ejemplo de funcin anidada
function getScore() {
  var num1 = 2,
    num2 = 3;

  function add() {
    return name + " anot " + (num1 + num2);
  }

  return add();
}

getScore(); // Devuelve "Chamahk anot 5"

mbito y la pila de funciones

Recursin

Una funcin se puede referir y llamarse a s misma. Hay tres formas de que una funcin se refiera a s misma:

1. El nombre de la funcin
2. arguments.callee
3. Una variable dentro del mbito que se refiere a la funcin

Por ejemplo, considera la siguiente definicin de funcin:

var foo = function bar() {
  // las instrucciones van aqu
};

Dentro del cuerpo de la funcin, todos los siguientes son equivalentes:

1. bar()
2. arguments.callee()
3. foo()

Una funcin que se llama a s misma se conoce como una funcin recursiva. En cierto modo, la recursividad es anloga a un bucle. Ambas ejecutan el mismo cdigo varias veces y ambas requieren una condicin (para evitar un bucle infinito, o ms bien, una recursividad infinita en este caso).

Por ejemplo, el siguiente bucle...

var x = 0;
while (x < 10) {
  // "x < 10" es la condicin del bucle
  // hacer cosas
  x++;
}

...se puede convertir en una declaracin de funcin recursiva, seguida de una llamada a esa funcin:

function loop(x) {
  if (x >= 10)
    // "x >= 10" es la condicin de salida (equivalente a "!(x < 10)")
    return;
  // hacer cosas
  loop(x + 1); // la llamada recursiva
}
loop(0);

Sin embargo, algunos algoritmos no pueden ser simples bucles iterativos. Por ejemplo, obtener todos los nodos de una estructura de rbol (como DOM) es ms fcil a travs de la recursividad:

function walkTree(node) {
  if (node == null)
    //
    return;
  // hacer algo con el nodo
  for (var i = 0; i < node.childNodes.length; i++) {
    walkTree(node.childNodes[i]);
  }
}

En comparacin con la funcin loop, cada llamada recursiva en s misma hace muchas llamadas recursivas aqu.

Es posible convertir cualquier algoritmo recursivo en uno no recursivo, pero la lgica suele ser mucho ms compleja, y hacerlo requiere el uso de una pila.

De hecho, la recursividad en s misma usa una pila: la pila de funciones. El comportamiento similar a una pila se puede ver en el siguiente ejemplo:

function foo(i) {
  if (i < 0) return;
  console.log("inicio: " + i);
  foo(i - 1);
  console.log("fin: " + i);
}
foo(3);

// Produce:

// inicio: 3
// inicio: 2
// inicio: 1
// inicio: 0
// fin: 0
// fin: 1
// fin: 2
// fin: 3

Funciones anidadas y cierres

Puedes anidar una funcin dentro de otra funcin. La funcin anidada (interna) es privada de su funcin contenedora (externa).

Tambin forma un cierre. Un cierre es una expresin (comnmente, una funcin) que puede tener variables libres junto con un entorno que une esas variables (que "cierra" la expresin).

Dado que una funcin anidada es un cierre, significa que una funcin anidada puede "heredar" los argumentos y variables de su funcin contenedora. En otras palabras, la funcin interna contiene el mbito de la funcin externa.

Para resumir:

• Solo se puede acceder a la funcin interna desde declaraciones en la funcin externa.

• La funcin interna forma un cierre: la funcin interna puede usar los argumentos y variables de la funcin externa, mientras que la funcin externa no puede usar los argumentos y variables de la funcin interna.

El siguiente ejemplo muestra funciones anidadas:

function addSquares(a, b) {
  function square(x) {
    return x * x;
  }
  return square(a) + square(b);
}
a = addSquares(2, 3); // devuelve 13
b = addSquares(3, 4); // devuelve 25
c = addSquares(4, 5); // devuelve 41

Dado que la funcin interna forma un cierre, puedes llamar a la funcin externa y especificar argumentos tanto para la funcin externa como para la interna:

function outside(x) {
  function inside(y) {
    return x + y;
  }
  return inside;
}
fn_inside = outside(3); // Piensa en ello como: dame una funcin que agregue 3 a lo que sea que le des
// eso
result = fn_inside(5); // devuelve 8

result1 = outside(3)(5); // devuelve 8

Preservacin de variables

Observa cmo se conserva x cuando se devuelve inside. Un cierre debe conservar los argumentos y variables en todos los mbitos a los que hace referencia. Dado que cada llamada proporciona argumentos potencialmente diferentes, se crea un nuevo cierre para cada llamada a outside. La memoria se puede liberar solo cuando el inside devuelto ya no es accesible.

Esto no es diferente de almacenar referencias en otros objetos, pero a menudo es menos obvio porque uno no establece las referencias directamente y no las puede inspeccionar.

Funciones multianidadas

Las funciones se pueden anidar de forma mltiple. Por ejemplo:

• Una funcin (A) contiene una funcin (B), que a su vez contiene una funcin (C).
• Ambas funciones B y C forman cierres aqu. Por tanto, B puede acceder a A y C puede acceder a B.
• Adems, dado que C puede acceder a B que puede acceder a A, C tambin puede acceder a A.

Por tanto, los cierres pueden contener mltiples mbitos; contienen de forma recursiva el mbito de las funciones que la contienen. Esto se llama encadenamiento de alcance. (La razn por la que se llama "encadenamiento" se explica ms adelante).

Considera el siguiente ejemplo:

function A(x) {
  function B(y) {
    function C(z) {
      console.log(x + y + z);
    }
    C(3);
  }
  B(2);
}
A(1); // registra 6 (1 + 2 + 3)

En este ejemplo, C accede a y de B y a x de A.

Esto se puede hacer porque:

1. B forma un cierre que incluye a A (es decir, B puede acceder a los argumentos y variables de A).
2. C forma un cierre que incluye a B.
3. Debido a que el cierre de B incluye a A, el cierre de C incluye a A, C puede acceder a los argumentos y variables de B y de A. En otras palabras, C encadena los mbitos de B y A, en ese orden.

Sin embargo, lo contrario no es cierto. A no puede acceder a C, porque A no puede acceder a ningn argumento o variable de B, del que C es una variable. Por lo tanto, C permanece privado solo para B.

Conflictos de nombres

Cuando dos argumentos o variables en el mbito de un cierre tienen el mismo nombre, hay un conflicto de nombres. Tiene ms prioridad el mbito anidado. Entonces, el mbito ms interno tiene la mayor prioridad, mientras que el mbito ms externo tiene la ms baja. Esta es la cadena de mbito. El primero de la cadena es el mbito ms interno y el ltimo es el mbito ms externo. Considera lo siguiente:

function outside() {
  var x = 5;
  function inside(x) {
    return x * 2;
  }
  return inside;
}

outside()(10); // devuelve 20 en lugar de 10

El conflicto de nombre ocurre en la declaracin return x y est entre el parmetro x de inside y la variable x de outside. La cadena de mbito aqu es {inside, outside, objeto global}. Por lo tanto, x de inside tiene precedencia sobre x de outside y 20 (x) de inside se devuelve en lugar de 10 (x de outside).

Cierres

Los cierres son una de las caractersticas ms poderosas de JavaScript. JavaScript permite el anidamiento de funciones y otorga a la funcin interna acceso completo a todas las variables y funciones definidas dentro de la funcin externa (y todas las dems variables y funciones a las que la funcin externa tiene acceso).

Sin embargo, la funcin externa no tiene acceso a las variables y funciones definidas dentro de la funcin interna. Esto proporciona una especie de encapsulacin para las variables de la funcin interna.

Adems, dado que la funcin interna tiene acceso a el mbito de la funcin externa, las variables y funciones definidas en la funcin externa vivirn ms que la duracin de la ejecucin de la funcin externa, si la funcin interna logra sobrevivir ms all de la vida de la funcin externa. Se crea un cierre cuando la funcin interna de alguna manera se pone a disposicin de cualquier mbito fuera de la funcin externa.

var pet = function (name) {
  // La funcin externa define una variable llamada "name"
  var getName = function () {
    return name; // La funcin interna tiene acceso a la variable
    // "name" de la funcin externa
  };
  return getName; // Devuelve la funcin interna, exponindola as a mbitos externos
};
myPet = pet("Vivie");

myPet(); // Devuelve "Vivie"

Puede ser mucho ms complejo que el cdigo anterior. Se puede devolver un objeto que contiene mtodos para manipular las variables internas de la funcin externa.

var createPet = function (name) {
  var sex;

  return {
    setName: function (newName) {
      name = newName;
    },

    getName: function () {
      return name;
    },

    getSex: function () {
      return sex;
    },

    setSex: function (newSex) {
      if (
        typeof newSex === "string" &&
        (newSex.toLowerCase() === "male" || newSex.toLowerCase() === "female")
      ) {
        sex = newSex;
      }
    },
  };
};

var pet = createPet("Vivie");
pet.getName(); // Vivie

pet.setName("Oliver");
pet.setSex("male");
pet.getSex(); // male
pet.getName(); // Oliver

En el cdigo anterior, la variable name de la funcin externa es accesible para las funciones internas, y no hay otra forma de acceder a las variables internas excepto a travs de las funciones internas. Las variables internas de las funciones internas actan como almacenes seguros para los argumentos y variables externos. Contienen datos "persistentes" y "encapsulados" para que trabajen las funciones internas. Las funciones ni siquiera tienen que estar asignadas a una variable o tener un nombre.

var getCode = (function () {
  var apiCode = "0]Eal(eh&2"; // Un cdigo que no queremos que los externos puedan modificar...

  return function () {
    return apiCode;
  };
})();

getCode(); // Devuelve el apiCode

var createPet = function (name) {
  // La funcin externa define una variable llamada "name".
  return {
    setName: function (name) {
      // La funcin envolvente tambin define una variable llamada "name".
      name = name; // Cmo accedemos al "name" definido por la funcin externa?
    },
  };
};

Usar el objeto arguments

El arguments de una funcin se mantiene en un objeto similar a un arreglo. Dentro de una funcin, puedes abordar los argumentos que se le pasan de la siguiente manera:

arguments[i];

donde i es el nmero ordinal del argumento, comenzando en 0. Entonces, el primer argumento que se pasa a una funcin sera arguments[0]. El nmero total de argumentos se indica mediante arguments.length.

Usando el objeto arguments, puedes llamar a una funcin con ms argumentos de los que formalmente declara aceptar. Esto suele ser til si no sabes de antemano cuntos argumentos se pasarn a la funcin. Puedes usar arguments.length para determinar el nmero de argumentos que realmente se pasan a la funcin, y luego acceder a cada argumento usando el objeto arguments.

Por ejemplo, considera una funcin que concatena varias cadenas. El nico argumento formal para la funcin es una cadena que especifica los caracteres que separan los elementos a concatenar. La funcin se define de la siguiente manera:

function myConcat(separator) {
  var result = ""; // inicia list
  var i;
  // itera a travs de arguments
  for (i = 1; i < arguments.length; i++) {
    result += arguments[i] + separator;
  }
  return result;
}

Puedes pasar cualquier nmero de argumentos a esta funcin, y concatena cada argumento en una "lista" de cadenas:

// devuelve "red, orange, blue, "
myConcat(", ", "red", "orange", "blue");

// devuelve "elephant; giraffe; lion; cheetah"
myConcat("; ", "elephant", "giraffe", "lion", "cheetah");

// devuelve "sage. basil. oregano. pepper. perejil. "
myConcat(". ", "salvia", "albahaca", "organo", "pimienta", "perejil");

Consulta el objeto Function en la referencia de JavaScript para obtener ms informacin.

Parmetros de funcin

A partir de ECMAScript 2015, hay dos nuevos tipos de parmetros: parmetros predeterminados y parmetros resto.

Parmetros predeterminados

En JavaScript, los parmetros de las funciones estn predeterminados en undefined. Sin embargo, en algunas situaciones puede resultar til establecer un valor predeterminado diferente. Esto es exactamente lo que hacen los parmetros predeterminados.

Sin parmetros predeterminados (preECMAScript 2015)

En el pasado, la estrategia general para establecer valores predeterminados era probar los valores de los parmetros en el cuerpo de la funcin y asignar un valor si eran undefined.

En el siguiente ejemplo, si no se proporciona ningn valor para b, su valor sera undefined al evaluar a * b, y una llamada a multiply normalmente habra devuelto NaN. Sin embargo, esto se evita con la segunda lnea de este ejemplo:

function multiply(a, b) {
  b = typeof b !== "undefined" ? b : 1;

  return a * b;
}

multiply(5); // 5

Con parmetros predeterminados (posECMAScript 2015)

Con parmetros predeterminados, ya no es necesaria una verificacin manual en el cuerpo de la funcin. Simplemente puedes poner 1 como valor predeterminado para b en el encabezado de la funcin:

function multiply(a, b = 1) {
  return a * b;
}

multiply(5); // 5

Para obtener ms detalles, consulta parmetros predeterminados en la referencia.

Parmetros rest

La sintaxis del parmetro rest nos permite representar un nmero indefinido de argumentos como un arreglo.

En el siguiente ejemplo, la funcin multiply usa parmetros rest para recopilar argumentos desde el segundo hasta el final. Luego, la funcin los multiplica por el primer argumento.

function multiply(multiplier, ...theArgs) {
  return theArgs.map((x) => multiplier * x);
}

var arr = multiply(2, 1, 2, 3);
console.log(arr); // [2, 4, 6]

Funciones Flecha

Una expresin de funcin flecha (anteriormente, y ahora conocida incorrectamente como funcin de flecha gruesa) tiene una sintaxis ms corta en comparacin con las expresiones de funcin y no tiene su propio this, arguments, super o new.target. Las funciones flecha siempre son annimas. Consulta tambin esta publicacin del blog hacks.mozilla.org: "ES6 en profundidad: funciones flecha".

Dos factores influyeron en la introduccin de las funciones flecha: funciones ms cortas y no vinculantes de this.

Funciones ms cortas

En algunos patrones funcionales, las funciones ms cortas son bienvenidas. Compara:

var a = ["Hidrgeno", "Helio", "Litio", "Berilio"];

var a2 = a.map(function (s) {
  return s.length;
});

console.log(a2); // logs [8, 6, 7, 9]

var a3 = a.map((s) => s.length);

console.log(a3); // logs [8, 6, 7, 9]

Sin this separado

Hasta las funciones flecha, cada nueva funcin defina su propio valor this (un nuevo objeto en el caso de un constructor, indefinido en llamadas a funciones en modo estricto, el objeto base si la funcin se llama como un "mtodo de objeto", etc.). Esto result ser poco menos que ideal con un estilo de programacin orientado a objetos.

function Person() {
  // El constructor Person() define `this` como l mismo.
  this.age = 0;

  setInterval(function growUp() {
    // En modo no estricto, la funcin growUp() define `this`
    // como el objeto global, que es diferente del `this`
    // definido por el constructor Person().
    this.age++;
  }, 1000);
}

var p = new Person();

En ECMAScript 3/5, este problema se solucion asignando el valor en this a una variable que se podra cerrar.

function Person() {
  var self = this; // Algunos eligen `that` en lugar de` self`.
  // Elige uno y se congruente.
  self.age = 0;

  setInterval(function growUp() {
    // La retrollamada se refiere a la variable `self` de la cual
    // el valor es el objeto esperado.
    self.age++;
  }, 1000);
}

Alternativamente, podras crear una funcin vinculada para que el valor this adecuado se pasara a la funcin growUp().

Una funcin flecha no tiene su propio this se utiliza el valor de this del contexto de ejecucin adjunto. Por lo tanto, en el siguiente cdigo, this dentro de la funcin que se pasa a setInterval tiene el mismo valor que this en la funcin adjunta:

function Person() {
  this.age = 0;

  setInterval(() => {
    this.age++; // |this| propiamente se refiere al objeto person
  }, 1000);
}

var p = new Person();

Funciones predefinidas

JavaScript tiene integradas varias funciones de nivel superior:

eval()

El mtodo eval() evala el cdigo JavaScript representado como una cadena.

uneval()

El mtodo uneval() crea una representacin de cadena del cdigo fuente de un Object.

isFinite()

La funcin global isFinite() determina si el valor pasado es un nmero finito. Si es necesario, el parmetro, primero se convierte en un nmero.

isNaN()

La funcin isNaN() determina si un valor es NaN o no. Nota: La coercin dentro de la funcin isNaN tiene interesantes reglas; tambin puedes querer usar Number.isNaN(), como se define en ECMAScript 2015, o puedes usar typeof para determinar si el valor no es un nmero (NaN).

parseFloat()

La funcin parseFloat() procesa un argumento de cadena y devuelve un nmero de punto flotante.

parseInt()

La funcin parseInt() procesa un argumento de cadena y devuelve un nmero entero de la base especificada (la base en los sistemas numricos matemticos).

decodeURI()

La funcin decodeURI() decodifica un identificador uniforme de recursos (URI) creado previamente por encodeURI o por una rutina similar.

decodeURIComponent()

El mtodo decodeURIComponent() decodifica un componente Identificador uniforme de recursos (URI) creado previamente por encodeURIComponent o por un rutina similar.

encodeURI()

El mtodo encodeURI() codifica un identificador uniforme de recursos (URI) reemplazando cada instancia de ciertos caracteres por una, dos, tres o cuatro secuencias de escape que representan la codificacin UTF-8 del caracter (solo habr cuatro secuencias de escape para caracteres compuestos por dos caracteres "sustitutos").

encodeURIComponent()

El mtodo encodeURIComponent() codifica un componente Identificador uniforme de recursos (URI) reemplazando cada instancia de ciertos caracteres por una, dos, tres o cuatro secuencias de escape que representan la codificacin UTF-8 del caracter (solo habr cuatro secuencias de escape para caracteres compuestos por dos caracteres "sustitutos").

escape()

El mtodo obsoleto escape() calcula una nueva cadena en la que ciertos caracteres han sido reemplazados por una secuencia de escape hexadecimal. En su lugar usa encodeURI o encodeURIComponent.

unescape()

El mtodo obsoleto unescape() calcula una nueva cadena en la que las secuencias de escape hexadecimales se reemplazan con el caracter que representan. Las secuencias de escape se pueden introducir por medio de una funcin como escape. Debido a que unescape() est en desuso, usa decodeURI() o decodeURIComponent en su lugar.

• Anterior
• Siguiente