Funcions

Les funcions són uns dels blocs de construcció elementals en JavaScript. Una funció és un procediment de JavaScript—un conjunt de sentències que performa una tasca o calcula un valor. Per tal de fer servir una funció, primer s'ha de defnir en alguna part de l'ámbit en que es vol cridar.

Una definició de funció (també anomenada declaració de funció) consta de la paraula clau function, seguit per:

• El nom de la funció.
• Una llista de paràmetres de la funció, continguts entre parèntesis i separats per comes.
• Les sentències de JavaScript que defineixen la funció, contingudes entre claus, { }.

Per exemple, el codi següent defineix una funció simple anomenada square:

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

La funció square té un paràmetre, anomenat number. Aquesta funció consisteix d'una sentència que retorna l'argument de la funció ( number) multiplicat per ell mateix. La sentència return especifica el valor retornat per la funció.

return number * number;

Els paràmetres primitius (com ara un nombre) són passat a les funcions  per valor; el valor és passat a la funció, però si la funció canvia el valor del paràmetre, aquest canvia sense reflectir-se globalment o en la funció de crida.

Si es pasa un objecte (p.ex. un valor no primitiu, com ara un Array o un objecte definit per l'usuari) com a paràmetre i la funció canvia les propietats de l'objecte, aquest canvi és visible fora de la funció, com es mostra en l'exemple següent:

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

var mycar = {make: "Honda", model: "Accord", year: 1998},
    x,
    y;

x = mycar.make;     // x gets the value "Honda"

myFunc(mycar);
y = mycar.make;     // y gets the value "Toyota"
                    // (the make property was changed by the function)

function myFunc(theObject) {
  theObject = {make: "Ford", model: "Focus", year: 2006};
}

var mycar = {make: "Honda", model: "Accord", year: 1998},
    x,
    y;

x = mycar.make;     // x gets the value "Honda"

myFunc(mycar);
y = mycar.make;     // y still gets the value "Honda" 

Mentre que la declaració de la funció d'adalt és sintàcticament una sentència, les funcions també poden ser creades per l' expressió d'una funció. Aquesta funció pot ser anònima; no té cap nom. Per exemple, la funció square podria ésser definida com:

var square = function(number) {return number * number};
var x = square(4) //x gets the value 16

Tanmateix, un nom es pot proporcionar amb una expressió d'una funció i es pot utilitzar dins la funció per referir-se a si mateix, o en un depurador per identificar la funció en la traça de la pila.

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

console.log(factorial(3));

Les expressions d'una funció són convenients quan es passa una funció com a argument d'una altra funció. El següent exemple mostra la definició d'una funció de mapa, i la posterior crida amb una funció anònima com a primer paràmetre.

function map(f,a) {
  var result = [], // Create a new Array
      i;
  for (i = 0; i != a.length; i++)
    result[i] = f(a[i]);
  return result;
}

El codi següent:

map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]);

retorna [0, 1, 8, 125, 1000].

En JavaScript, una funció pot ser definida basant-se en una condició. Per exemple, la següent definició de la funció defineix myFunc només si num és igual 0:

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

A més de definir les funcions com ho fem aquí, podeu utilitzar el constructor de funció per crear funcions d'una cadena en temps d'execució, igual que eval().

Un mètode és una funció que es propietat d'un objecte. Podeu llegir més sobre mètodes i funcions a Treballar amb objectes.

Definir una funció no l'executa. Definir una funció simplement anomena la funció i especifica que fer quan es crida la funció. Cridar la funció en realitat realitza les accions especificades amb els paràmetres indicats. Per exemple, si es defineix la funció square, aquesta es cridaria de la següent manera:

square(5);

La sentència anterior crida la funció amb un argument de 5. La funció executa executes les seves sentències i retorna el valor 25.

Les funcions han de ser en un àmbit quan son cridades, però la declaració de la funció pot estar abans de la crida, com és en aquest exemple:

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

L'àmbit de la funció es troba en la funció en la qual s'ha declarat, o en el programa complet si s'ha declarat  is the function in which it is declared, or the entire program if it is declared a nivell global.

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

Els arguments d'una funció no estan limitats a cadenes o nombres. Es pot passar objectes sencers a una funció. La funció show_props (definida a Treballant amb Objectes) és un exemple d'una funció que pren un objecte com a argument.

Una funció pot cridar-se a si mateixa. Per exemple, aquí baix trobem una funció que  is a function that calcula factorials recursivament:

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

D'aquesta manera es podria calcular els factorials de l'ú al cinc de la forma següent:

var a, b, c, d, e;
a = factorial(1); // a gets the value 1
b = factorial(2); // b gets the value 2
c = factorial(3); // c gets the value 6
d = factorial(4); // d gets the value 24
e = factorial(5); // e gets the value 120

Hi ha altres maneres de cridar funcions. Sovint hi ha casos en que s'ha de cridar la funció dinàmicament, o casos en que el nombre d'arguments d'una funció pot variar o en els que el context de la crida a la funció de s'ha d'establir a un objecte específic determinat en temps d'execució. Resulta que les funcions són per elles mateixes, objectes, i aquests objectes, al seu torn, tenen mètodes (vegeu l'objecte funció). Un d'aquests, el mètode apply(), pot ser usat per aconseguir aquest objectiu.

Les variables definides dins d'una funció no són accessibles des de llocs de fora de la funció, ja que la variable es defineix només en l'àmbit de la funció. No obstant això, una funció pot accedir a totes les variables i funcions definides dins de l'àmbit en el qual es defineix. En altres paraules, una funció definida en l'àmbit global pot tenir accés a totes les variables definides en l'àmbit global. Una funció definida dins d'una altra funció pot accedir a totes les variables definides en la funció pare i qualsevol altra variable a la qual la funció pare té accés.

// The following variables are defined in the global scope
var num1 = 20,
    num2 = 3,
    name = "Chamahk";

// This function is defined in the global scope
function multiply() {
  return num1 * num2;
}

multiply(); // Returns 60

// A nested function example
function getScore () {
  var num1 = 2,
      num2 = 3;

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

  return add();
}

getScore(); // Returns "Chamahk scored 5"

Una funció pot referir-se i cridar-se a ella mateixa. Hi ha tres formes per a que una funció es refereixi a ella mateixa:

1. El nom de la funció
2. arguments.callee
3. Una variable continguda en l'àmbit que refereixi a la funció

Per exemple, la definició de funció següent:

var foo = function bar() {
   // statements go here
};

Dins del cos de la funció, els següent són tots equivalents:

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

Una funció que es pot cridar a ella mateixa és una funció recursiva. En certa manera, la recursió és anàleg a un bucle. En ambdós casos el codi s'executa múltiples vegades, i els dos requereixen d'una condició (per evitar el bucle infinit, o més aviat, la infinita recursió en aquest cas). Per exemple, en el següent bucle:

var x = 0;
while (x < 10) { // "x < 10" is the loop condition
   // do stuff
   x++;
}

Es pot converitr en una funció recursiva i una crida a una funció:

function loop(x) {
   if (x >= 10) // "x >= 10" is the exit condition (equivalent to "!(x < 10)")
      return;
   // do stuff
   loop(x + 1); // the recursive call
}
loop(0);

Tanmateix, alguns algorismes no poden ser bucles iteratius simples. Per exemple, obtenir tots els nodes de l'estructura d'arbre (e.x. el DOM) és fa més fàcilment usant la recursió:

function walkTree(node) {
   if (node == null) //
      return;
   // do something with node
   for (var i = 0; i < node.childNodes.length; i++) {
      walkTree(node.childNodes[i]);
   }
}

Comparat amb la funció loop, cada crida recursiva que es crida a si mateixa fa varies crides recursives aquí.

És possible convertir qualsevol algorisme recursiu a un no recursiu, però sovint la llògica és molt més complexa i fer-ho requereix l'ús d'una pila. De fet, la recursió per si mateixa fa servir una pila: la funció stack.

El comportament de l'stack es pot veure en el següent exemple:

function foo(i) {
   if (i < 0)
      return;
   document.writeln('begin:' + i);
   foo(i - 1);
   document.writeln('end:' + i);
}
foo(3);

El qual mostra:

begin:3
begin:2
begin:1
begin:0
end:0
end:1
end:2
end:3

Es pot aniuar una funció dins d'una altra funció. El contingut de la funció aniuada (la de dins) és privada a la funció que la conté (la de fora). També forma un closure.

Un closure és una expressió (normalment una funció) que pot tenir variables lliures juntes amb un àmbit que lliga aquestes variables (que "closes" l'expresió).

Ja que una funció aniuada és un closure, això significa que una funció aniuada pot "heredar" els arguments i variables de la funció que la conté. En altres paraules, la funció de dins conté l'àmbit de la funció de fora.

Resumint:

• Es pot accedir a la funció de dins només des de sentències que es troben dins la funció de fora.

• La funció de dins forma un closure: la funció de dins pot usar els arguments i les variables de la funció de fora, mentre que la funció de fora no pot usar els arguments i les variables de la funció de dins.

El següent exemple mostra funcions aniuades:

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

Atès que la funció interior forma un closure, es pot cridar la funció exterior i especificar els arguments per ambdues funcions, l'exterior i l'interior:

function outside(x) {
   function inside(y) {
      return x + y;
   }
   return inside;
}
fn_inside = outside(3); // Think of it like: give me a function that adds 3 to whatever you give it
result = fn_inside(5); // returns 8

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

Vegeu com és preserva x quan es retorna inside. Un closure ha de preservar els arguments i variables en tots els àmbits de les seves referències. Donat que cada crida proveeix potencialment diferents arguments, es crea una nova closure per cada crida que es fa a l'exterior. La memòria pot ser alliberada només quan no es pot accedir més al retorn d'inside.

Això no és diferent d'emmagatzemar referències en altres objectes, però sovint és menys obvi perque no podem establir les referències directament ni inspeccionar-les. 

Les funcions també poden ser aniuades múltiples, p.ex. Una funció (A) conté una funció (B) que conté una funció (C). Ambudes funcions B i C formen aquí closures, de forma que B pot accedir a A i C pot accedir a B. A més a més, ja que C pot accedir a B, el qual pot accedir a A, C també pot accedir a A. D'aquesta forma, els closures poden contenir múltiples àmbits; contenen recursivament l'àmbit de les funcionsthey recursively contain the scope of the functions containing it. Això s'anomena scope chaining. (El perquè s'anomena "chaining" s'explicarà més tard.)

Considereu l'exemple següent:

function A(x) {
   function B(y) {
      function C(z) {
         alert(x + y + z);
      }
      C(3);
   }
   B(2);
}
A(1); // alerts 6 (1 + 2 + 3)

En aquest exemple, C accedeix a y de B  i x d'A. Això és possible perquè:

1. B forma un closure incloïent A, és a dir, B pot accedir als arguments i les variables d'A.
2. C forma un closure que inclou B.
3. Com que el clousure de B inclou A, el closure de C inclou A, C pot accedir tant als arguments i les variables de B com als d'A. En altres paraules, C encadena l'accés als àmbits de B i A en aquest ordre.

El revers, però, no és cert. A no pot accedir a C, perquè A no pot accedir a cap argument o variable de B, de la qual C n'és una variable. D'aquesta forma, C roman privat només a B.

Quan dos arguments o variables de l'àmbit del closure tenen el mateix nom, hi ha un conflicte de nom. Els àmbits més interns tenen prioritat, de forma que l'àmbit més intern té la màxima prioritat, mentre que l'àmbit més exterior no en tét. Això és l cadena d'àmbit. El primer de la cadena és l'àmbit més intern, i l'últim és l'àmbit més extern. Vegeu l'exemple següent:

function outside() {
   var x = 10;
   function inside(x) {
      return x;
   }
   return inside;
}
result = outside()(20); // returns 20 instead of 10

El conflicte de nom ocorre en la sentència return x i es troba entreand is between inside's parameter x and outside's variable x. The scope chain here is {inside, outside, global object}. Therefore inside's x takes precedences over outside's x, and 20 (inside's x) is returned instead of 10 (outside's x).

Els closures son unes de les característiques més poderoses de JavaScript. JavaScript permet l'aniuament de funcions i concedeix a la funció interior accès total a totes les variables i funcions definides dins de la funció exterior (i totes les altres variables i funcions que la funció exterior té accés). Tanmateix, la funció exterior no té accés a les variables i funcions definides dins la funció interior. Això proveeix seguretat a les variables de la funció interior. A més, ja que la funció interior té accés a l'àmbit de la funcio exterior, les variables i funcions definides en la funció de fora viuran més que la mateixa funció de fora, si la funció interior se les arregla per sobreviure a partir de la vida de la funció exterior. Un closure es crea quan la funció interior és d'alguna manera accessible per qualsevol àmbit fora de la funció exterior.

var pet = function(name) {          // The outer function defines a variable called "name"
      var getName = function() {
        return name;                // The inner function has access to the "name" variable of the outer function
      }

      return getName;               // Return the inner function, thereby exposing it to outer scopes
    },
    myPet = pet("Vivie");

myPet();                            // Returns "Vivie"

Pot ser molt més complex que el codi d'adalt. Un objecte que conté mètodes per manipular les variables interior d'una funció exterior poder ser retornades.

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 els codis d'adalt, la variable name de la funció exterior és accesible des de les funcions interiors, i no hi ha cap altra forma d'accedir a les variables interiors apart the fer-ho a través de les funcions interiors. Les variables interiors de la funció interior es comporten com a magatzems segurs per a les funcions interiors. Aquestes emmagatzemen de forma "persistent", però segures, les dades amb que les funcions interiors han de treballar. Les funcions no tenen ni tant sols ser assignades a una variable, tampoc han de tenir un nom.

var getCode = (function(){
  var secureCode = "0]Eal(eh&2";    // A code we do not want outsiders to be able to modify...

  return function () {
    return secureCode;
  };
})();

getCode();    // Returns the secureCode

Hi ha, tanmateix, un nombre de trampes o obstacles que vigilar quan es fa servir closures. Si una closure defineix una variable amb el mateix nom que el nom de la variable que es troba en l'àmbit exterior, no hi ha cap manera de referir-se una altra vegada a la variable de l'àmbit exterior.

var createPet = function(name) {  // Outer function defines a variable called "name"
  return {
    setName: function(name) {    // Enclosed function also defines a variable called "name"
      name = name;               // ??? How do we access the "name" defined by the outer function ???
    }
  }
}

La variable màgica this és força delicada en closures. S'ha de saber fer servir acuradament, ja que al que this es refereix depen completament del lloc on la funció es cridada, i no d'on és definida.

Els arguments d'una funció és mantenen en un objecte semblant a un array. Dins una funció,  és pot accedir als arguments passats a la funció de la següent forma:

arguments[i]

On i és el nombre ordinal de l'argument, que comença amb zero. Així, el primer argument passat a una funció seria arguments[0]. El nombre total d'arguments és indicat per arguments.length.

Fent servir l'objecte arguments, es pot cridar una funció amb més arguments dels que formament està declarat a acceptar. Això sovint és útil si no es sap amb anticipació quants arguments seràn passats a la funció. Es pot fer servir arguments.length per determinar el nombre d'arguments que se li passen a la funció, i després accedir a cada arguments fent ús de l'objecte arguments.

Per exemple, sospeseu una funció que concatena diverses cadenes. L'únic argument formal per la funció és una cadena que especifica els caràcters que separen els ítems per concatenar. La funció és defineix com:

function myConcat(separator) {
   var result = "", // initialize list
       i;
   // iterate through arguments
   for (i = 1; i < arguments.length; i++) {
      result += arguments[i] + separator;
   }
   return result;
}

Es pot passar qualsevol nombre d'arguments a aquesta funció, i concatena cada argument dins d'una "llista" de cadenes:

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

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

// returns "sage. basil. oregano. pepper. parsley. "
myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");

Vegeu l'objecte Function en la referència de JavaScript per més informació.

En JavaScript, els controladors d'events DOM són funcions (a diferència dels objectes que contenen un mètode handleEvent en altres enllaços de llenguatge DOM). Les funcions passen un objecte d'event com el primer i únic paràmetre. Com qualsevol altre paràmetre, si l'objecte event no s'ha de fer servir, es pot ometre de la llista de paràmetres formals.

Alguns probables objectius d'un document HTML inclouen: window (l'objecte Window, incloent frames), document (l'objecte HTMLDocument), i elements (Element objects). En el HTML DOM, els objectius d'events tenen propietats de controladors d'events. Aquestes propietats seràn nomes d'events amb minúscules amb el prefix "on", p.ex. onfocus. Una altra forma de fer, més robusta, d'afegir detectors d'events és ser proveït pel nivell 2 d'events DOM.

Nota: Events formen part del DOM, no de JavaScript. (JavaScript només proveeix un enllaç al DOM.)

El següent exemple assigna una funció al controlador d'events "focus" d'una finestra.

window.onfocus = function() {
   document.body.style.backgroundColor = 'white';
};

Si una funció és assignada a una variable, es pot assignar la variable a un controlador d'event. El codi següent assigna una funció a la variable setBGColor.

var setBGColor = new Function("document.body.style.backgroundColor = 'white';");

Es pot fer servir aquesta variable per assignar una funció a un controlador d'event de diverses formes. Aquí mostrem dues formes de fer-ho:

1. scripting amb propietats d'event DOM HTML

   document.form1.colorButton.onclick = setBGColor;
   

2. Atribut event HTML

   <input name="colorButton" type="button"
      value="Change background color"
      onclick="setBGColor();"/>
   

   Un controlador d'events establert d'aquesta manera, és de fet, una funció,  named after the attribute, wrapped around the specified code. Això explica perquè els parèntesis en "setBGColor()" són necessaris aquí (en lloc de només "setBGColor"). És equivalent a:

   document.form1.colorButton.onclick = function onclick(event) {
      setBGColor();
   };
   

   Vegeu com l'objecte event object es passa a aquesta funció com a paràmetre event. Això permet al codi específic utilitzar l'objecte Event:

   <input ...
       onclick="alert(event.target.tagName);"/>
   

Com qualsevol altra propietat que fa referència a una funció, el controlador d'event pot comportat-se com un mètode, i this faria referència a l'element que conté el controlador d'event. En l'exemple següent, la funció que fa referència onfocus es crida amb this que equival a window.

window.onfocus();

Un error comú de principiants de Javascript és snnexar parèntesis i/o paràmetres al final de la variable p.ex. cridar un controlador d'event quan es fa l'assignació. Afeguir aquests parèntesis assignarà el valor returned from calling the event handler, que sovint és undefined (si la funció no retorna res), rather than the event handler itself:

document.form1.button1.onclick = setBGColor();

Per passar paràmetres a un controlador d'event, el controlador ha d'estar embolcallat dins d'una altra funció com la següent:

document.form1.button1.onclick = function() {
   setBGColor('some value');
};

JavaScript té diverses funcions predefinides que poden emprar-se des de qualsevol àmbit:

• eval
• isFinite
• isNaN
• parseInt and parseFloat
• Number and String
• encodeURI, decodeURI, encodeURIComponent, and decodeURIComponent (all available with Javascript 1.5 and later).

Les seccions següents introdueixen aquestes funcions. Vegeu el JavaScript Reference per informació detallada de totes aquestes funcions.

La funció evalavalua una cadena del codi de JavaScript sense fer referència a cap objecte en particular. La sintaxi de eval és:

eval(expr);

on expr és una cadena per ser avaluada.

Si la cadena representa una expressió, eval evalua l'expressió. Si l'argument representa una sentència o més de JavaScript, eval performa aquestes sentències. L'àmbit del codi d'eval és idèntic a l'àmbit del codi de crida. No s'ha de cridar eval per avaluar una expressió aritmèica; JavaScript aritmètiques automàticament.

La funció isFinite avalua un argument per determinar si és un nombre finit. La sintaxi d' isFinite és:

isFinite(number);

on number és el nombre que s'ha d'avaluar.

Si l'argument és NaN (no un nombre), infinit positiu o infinit negatiu, aquest mètode retorna false, sinó retornarà true.

El codi següent comprova si ClientInput per determinar si és un nombre finit.

if(isFinite(ClientInput)){
   /* take specific steps */
}

La funció isNaN avalua un argument que determina si és "NaN." La sintaxi d'isNaN és:

isNaN(testValue);

On testValue és el valor que es vol avaluar.

Les funcions parseFloat i parseInt retornen "NaN" quan avaluen un valor que no és un nombre. isNaN retorna true si passa "NaN," i false sinó ho fa.

El codi següent avalua floatValue que determina si és un nombre i després crida un procediment de la manera adequada:

var floatValue = parseFloat(toFloat);

if (isNaN(floatValue)) {
   notFloat();
} else {
   isFloat();
}

Les dos funcions "parse", parseInt i parseFloat, retornen un valor numèric quan es dóna com a argument una cadena.

La sintaxi de parseFloat és:

parseFloat(str);

On parseFloat parses el seu argument,la cadena str, and attempts to return a floating-point number. If it encounters a character other than a sign (+ or -), a numeral (0-9), a decimal point, or an exponent, then it returns the value up to that point and ignores that character and all succeeding characters. If the first character cannot be converted to a number, it returns "NaN" (not a number).

La sintaxi de parseInt és:

parseInt(str [, radix]);

parseInt interpreta el seu primer argument, la cadena de caràcters str, i intenta retornar un nombre sencer de la base especificada pel paràmetre opcional radix. Per exemple, si radix és 10 això indica que es demana una conversió al sistema decimal (base 10), si és 8 octal, si és 16 hexadecimal, etcètera. Per a bases majors que 10 es fan anar lletres de l'alfabet per a indicar els numerals majors que 9. Per exemple, per a nombres hexadecimals (base 16), s'empren les lletres de la A fins la F.

Si parseInt troba un caràcter que no és un numeral de la base especificada, aquest és ignorat així com la resta de caràcters que el segueixen i retorna el valor sencer interpretat fins aquest punt. Si el primer caràcter no es pot convertir a un nombre de la base especificada es retorna "NaN". La funció parseInt trunca la cadena de caràcters a valors sencers.

Les funcions Number i String permeten convertir un objecte a un nombre o a una cadena. La sintaxi d'aquestes funcions és:

var objRef;
objRef = Number(objRef);
objRef = String(objRef);

On objRef és una referència a l'objecte. Number fa servir el valorOf() method of the object; String uses the toString() method of the object.

L'exemple següent converteix l'objecte Date a una cadena de caràcters fàcilment interpretrable per humans.

var D = new Date(430054663215),
    x;
x = String(D); // x equals "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983"

L'exemple següent converteix l'objecte String a l'objecte Number.

var str = "12",
    num;
num = Number(str);

Es pot comprovar utilitzant el mètode del DOM write() i l'operador de JavaScript typeof.

var str = "12",
    num;
document.write(typeof str);
document.write("<br/>");
num = Number(str);
document.write(typeof num);

Les funcions escape i unescape no funcionen correctamenr per a caràcter que no siguin ASCII i han quedat obsoletes. En la versió de JavaScript 1.5 i posteriors, es fa servir encodeURI, decodeURI, encodeURIComponent, i decodeURIComponent.

Les funcions escape i unescape permeten codificar i descodificar cadenes. La funció escape retorna function returns the hexadecimal encoding of an argument in the ISO Latin character set. The unescape function returns the ASCII string for the specified hexadecimal encoding value.

La sintaxi d'aquestes funcions és:

escape(string);
unescape(string);

Aquestes funcions s'usen principalment amb JavaScript que s'executa al servidor per codificar i descodificar parells de clau/valor en URLs.