Fonctions

Dfinir des fonctions

Les dclarations de fonctions

Une dfinition de fonction (aussi appele dclaration de fonction ou instruction de fonction) est construite avec le mot-cl function, suivi par :

• Le nom de la fonction.
• Une liste d'arguments passer la fonction, entre parenthses et spars par des virgules.
• Les instructions JavaScript dfinissant la fonction, entre accolades, { }.

Le code suivant, par exemple, dfinit une fonction intitule carr :

function carr(nombre) {
  return nombre * nombre;
}

La fonction carr prend un seul argument, appel nombre. La fonction est compose d'une seule instruction qui renvoie l'argument de la fonction (nombre) multipli par lui-mme. L'instruction return spcifie la valeur qui est renvoye par la fonction.

return nombre * nombre;

Les paramtres primitifs (comme les nombres) sont passs la fonction par valeur. La valeur est passe la fonction mais si cette dernire change la valeur du paramtre, cela n'aura pas d'impact au niveau global ou au niveau de ce qui a appel la fonction.

Si l'argument pass la fonction est un objet (une valeur non-primitive, comme un objet Array ou un objet dfini par l'utilisateur), et que la fonction change les proprits de cet objet, ces changements seront visibles en dehors de la fonction. Par exemple :

function maFonction(monObjet) {
  monObjet.fabricant = "Toyota";
}

var mavoiture = { fabricant: "Honda", modle: "Accord", anne: 1998 };
var x, y;

x = mavoiture.fabricant; // x aura la valeur "Honda"

maFonction(mavoiture);
y = mavoiture.fabricant; // y aura la valeur "Toyota"
// (la proprit fabricant a t modifie par la fonction)

function maFonction(monObjet) {
  monObjet = { fabricant: "Ford", modle: "Focus", anne: 2006 };
}

var mavoiture = { fabricant: "Honda", modle: "Accord", anne: 1998 };
var x, y;

x = mavoiture.fabricant; // x reoit la valeur "Honda"

maFonction(mavoiture);
y = mavoiture.fabricant; // y reoit la valeur "Honda"

Dans le premier exemple, l'objet mavoiture tait pass la fonction maFonction qui le modifiait. Dans le second exemple, la fonction n'a pas modifi l'objet qui avait t pass en argument, elle a cr une nouvelle variable locale, possdant le mme nom que l'objet global pass en argument : il n'y a donc pas de modifications sur cet objet global.

Les expressions de fonction

Syntaxiquement, la dclaration de fonction utilise ci-dessus est une instruction. On peut galement crer une fonction grce une expression de fonction. De telles fonctions peuvent tre anonymes (ne pas avoir de nom correspondant). La fonction carr aurait pu tre dfinie de la faon suivante :

var carr = function (nombre) {
  return nombre * nombre;
};
var x = carr(4); //x reoit la valeur 16

Cependant, un nom peut tre utilis dans une expression de fonction, ce afin de l'utiliser dans la fonction (rcursivit) ou afin de l'identifier dans les appels tracs par un ventuel dbogueur :

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

console.log(factorielle(3));

Les expressions de fonction sont pratiques lorsqu'il s'agit de passer une fonction comme argument d'une autre fonction. Dans l'exemple qui suit, la fonction map est dfinie et appele avec une fonction anonyme comme premier argument :

function map(f, a) {
  var resultat = []; // Crer un nouveau tableau Array
  for (var i = 0; i != a.length; i++) resultat[i] = f(a[i]);
  return resultat;
}

Le code suivant applique la fonction cube sur chacun des lments du tableau :

var cube = function (x) {
  return x * x * x;
}; // Une expression de fonction
map(cube, [0, 1, 2, 5, 10]);

Le rsultat de la dernire instruction est le tableau [0, 1, 8, 125, 1000].

En JavaScript, une fonction peut tre dfinie selon une condition. Le fragment de code qui suit dfinit une fonction seulement si num vaut 0 :

var maFonction;
if (num === 0) {
  maFonction = function (monObjet) {
    monObjet.fabricant = "Toyota";
  };
}

Une autre faon de dfinir des fonctions est d'utiliser le constructeur de l'objet Function afin de crer des fonctions partir d'une chane lors de l'excution, de la mme faon que eval().

Une mthode est une fonction tant une proprit d'un objet. Vous trouverez plus de dtails sur ces lments dans le chapitre suivant du guide : Utiliser les objets.

Appeler des fonctions

La seule dfinition d'une fonction ne permet pas d'excuter la fonction. Cela permet de lui donner un nom et de dfinir ce qui doit tre fait lorsque la fonction est appele. Appeler la fonction permet d'effectuer les actions des instructions avec les paramtres indiqus. Par exemple, si on dfinit la fonction carr, on peut l'appeler de la faon suivante :

carr(5);

Cette instruction appellera la fonction avec un argument valant 5. La fonction excute ses instructions et renvoie la valeur 25.

Les fonctions doivent appartenir la porte dans laquelle elles sont appeles. En revanche, la dclaration d'une fonction peut tre faite aprs l'appel :

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

La porte d'une fonction est la fonction dans laquelle elle est dclare ou le programme entier si elle est dclare au niveau le plus haut.

console.log(carr); // La fonction carr est remonte/hoisted mais vaut undefined
console.log(carr(5)); // TypeError: carr is not a function
var carr = function (n) {
  return n * n;
};

// Et avec let...

console.log(carr2); // ReferenceError: carr2 is not defined
console.log(carr2(5)); // TypeError: carr2 is not a function

let carr2 = function (n) {
  return n * n;
};

Les arguments d'une fonction ne sont pas limits aux chanes de caractres et aux nombres. Il est possible de passer des objets. La fonction show_props (dfinie dans le chapitre sur l'utilisation des objets) est un exemple de fonction utilisant un argument qui est un objet.

Une fonction peut tre rcursive, c'est--dire qu'elle peut s'appeler elle-mme. Voici la fonction qui calcule rcursivement la factorielle d'un nombre :

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

On peut ensuite calculer les factorielles des nombres 1 5 :

var a, b, c, d, e;
a = factorielle(1); // a reoit la valeur 1
b = factorielle(2); // b reoit la valeur 2
c = factorielle(3); // c reoit la valeur 6
d = factorielle(4); // d reoit la valeur 24
e = factorielle(5); // e reoit la valeur 120

Il existe d'autres faons d'appeler des fonctions. Il existe souvent des cas o une fonction doit tre appele dynamiquement, o le nombre d'arguments peut varier, o le contexte de l'appel d'une fonction doit tre cr en fonction d'un objet dtermin lors de l'excution. Les fonctions sont des objets, en tant que tels, elles possdent des mthodes (voir la page sur l'objet Function). L'une d'entre elles, apply() peut tre utilise pour raliser le dernier cas de figure (excution d'une fonction avec un objet dtermin l'excution).

Porte d'une fonction

On ne peut pas accder aux variables dfinies dans une fonction en dehors de cette fonction : ces variables n'existent que dans la porte de la fonction. En revanche, une fonction peut accder aux diffrentes variables et fonctions qui appartiennent la porte dans laquelle elle est dfinie. Une fonction dfinie dans une autre fonction peut galement accder toutes les variables de la fonction parente et toute autre variable accessible depuis la fonction parente .

// Les variables suivantes sont globales
var num1 = 20,
  num2 = 3,
  nom = "Licorne";

// Cette fonction est dfinie dans la porte globale
function multiplier() {
  return num1 * num2;
}

multiplier(); // Renvoie 60

// Un exemple de fonction imbrique
function getScore() {
  var num1 = 2,
    num2 = 3;

  function ajoute() {
    return nom + " a marqu " + (num1 + num2);
  }

  return ajoute();
}

getScore(); // Renvoie "Licorne a marqu 5"

Porte et pile de fonctions

La rcursivit

Une fonction peut faire rfrence elle-mme et s'appeler elle-mme. Il existe trois moyens pour qu'une fonction fasse rfrence elle-mme :

1. Le nom de la fonction
2. arguments.callee
3. Une variable de la porte qui fait rfrence la fonction

Par exemple, avec la dfinition de fonction suivante :

var toto = function truc() {
  // les instructions de la fonction
};

Dans le corps de la fonction, ces trois lments seront quivalents :

1. truc()
2. arguments.callee()
3. toto()

Une fonction qui s'appelle elle-mme est appele une fonction rcursive. Sous certains aspects, une rcursion est semblable une boucle : toutes les deux excutent le mme code plusieurs fois et toutes les deux requirent une condition d'arrt (pour viter une boucle ou une rcursion infinie). Par exemple, ce fragment de code utilisant une boucle :

var x = 0;
while (x < 10) {
  // "x < 10" reprsente la condition d'arrt
  // faire quelque chose
  x++;
}

pourra tre converti en une fonction rcursive de la faon suivante :

function boucle(x) {
  if (x >= 10) {
    // "x >= 10" reprsente la condition d'arrt (quivalent  "!(x < 10)")
    return;
  }
  // faire quelque chose
  boucle(x + 1); // l'appel rcursif
}
boucle(0);

Malgr cela, certains algorithmes ne peuvent pas tre convertis en boucles itratives. Ainsi, rcuprer l'ensemble des nuds d'un arbre (le DOM par exemple) se fait plus simplement en utilisant la rcursivit :

function parcourirArbre(noeud) {
  if (noeud === null) {
    return;
  }
  // faire quelque chose avec le noeud
  for (var i = 0; i < noeud.childNodes.length; i++) {
    parcourirArbre(noeud.childNodes[i]);
  }
}

Contrairement l'exemple prcdent avec la fonction boucle, ici, chaque appel rcursif entrane lui-mme plusieurs appels (et non un seul).

Thoriquement, il est possible de convertir tout algorithme rcursif en un algorithme non rcursif (avec des boucles par exemple). Gnralement, la logique obtenue est plus complexe et ncessite l'utilisation d'une pile. La rcursivit utilise galement une pile, la pile de fonction.

Ce type de comportement peut-tre observ avec l'exemple suivant :

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

qui affichera :

dbut : 3
dbut : 2
dbut : 1
dbut : 0
fin : 0
fin : 1
fin : 2
fin : 3

Fonctions imbriques et fermetures

Il est possible d'imbriquer une fonction dans une autre fonction. La porte de la fonction fille (celle qui est imbrique) n'est pas contenue dans la porte de la fonction parente. En revanche, la fonction fille bnficie bien des informations de la fonction parente grce sa porte. On a ce qu'on appelle une fermeture (closure en anglais). Une fermeture est une expression (gnralement une fonction) qui accde des variables libres ainsi qu' un environnement qui lie ces variables (ce qui ferme l'expression).

Une fonction imbrique tant une fermeture, cela signifie qu'une fonction imbrique peut en quelque sorte hriter des arguments et des variables de la fonction parente.

En rsum :

• La fonction imbrique ne peut tre utilise qu' partir des instructions de la fonction parente.

• La fonction imbrique forme une fermeture : elle peut utiliser les arguments et les variables de la fonction parente. En revanche, la fonction parente ne peut pas utiliser les arguments et les variables de la fonction fille.

L'exemple qui suit illustre l'imbrication de fonctions :

function ajouteCarrs(a, b) {
  function carr(x) {
    return x * x;
  }
  return carr(a) + carr(b);
}
a = ajouteCarrs(2, 3); // renvoie 13
b = ajouteCarrs(3, 4); // renvoie 25
c = ajouteCarrs(4, 5); // renvoie 41

La fonction interne tant une fermeture, on peut appeler la fonction parente afin de dfinir les arguments pour la fonction englobante et ceux de la fonction fille :

function parente(x) {
  function fille(y) {
    return x + y;
  }
  return fille;
}
fn_fille = parente(3); // Fournit une fonction qui ajoute 3  ce qu'on lui donnera
rsultat = fn_fille(5); // renvoie 8

rsultat1 = parente(3)(5); // renvoie 8

Prservation des variables

Dans l'exemple prcdent, x a t prserv lorsque la fonction fille a t renvoye. Une fermeture conserve les arguments et les variables de chaque porte qu'elle rfrence. Chaque appel la fonction parente pouvant fournir un contexte diffrents selon les arguments, cela entranera la cration d'une nouvelle fermeture. La mmoire associe ne pourra tre libre que lorsque la fonction fille ne sera plus accessible.

Ce mode de fonctionnement n'est pas diffrent de celui des rfrences vers les objets. Cependant, il est souvent plus compliqu dtecter car les rfrences ne sont pas dfinies explicitement dans le code et car il n'est pas possible de les inspecter.

Imbriquer plusieurs fonctions

Il est possible d'imbriquer des fonctions sur plus de deux niveaux, par exemple, on peut avoir une fonction A qui contient une fonction B qui contient une fonction C. Les fonctions B et C sont des fermetures et B peut accder la porte de A, C peut accder la porte de B. Ainsi, C accde la porte de B qui lui accde la porte de A, C accde donc la porte de A (transitivit). Les fermetures peuvent donc contenir plusieurs portes, c'est ce qu'on appelle le chanage de portes.

Par exemple :

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

Dans cet exemple C accde au y de B et au x de A. Ceci est rendu possible car :

1. B est une fermeture qui contient A, autrement dit B peut accder aux arguments et aux variables de A.
2. C est une fermeture qui contient B.
3. La fermeture de B contient A donc la fermeture de C contient A, C peut ainsi accder aux arguments et aux variables de B et A. On dit que C chane les portes de B et de A (dans cet ordre).

La rciproque n'est pas vraie. A ne peut pas accder C, car A ne peut pas accder aux arguments ou aux variables de B, or C est une variable de B. De cette faon, C reste prive en dehors de B.

Conflits de nommage

Lorsque deux arguments ou variables des portes d'une fermeture ont le mme nom, il y a un conflit de noms. Dans ces cas, ce sera la porte la plus imbrique qui prendra la priorit sur le nom, la porte la plus externe aura la priorit la plus faible pour les noms de variables. Du point de vue de la chane des portes, la premire porte sur la chane est la porte la plus imbrique et la dernire est la porte situe le plus l'extrieur :

function externe() {
  var x = 10;
  function interne(x) {
    return x;
  }
  return interne;
}
rsultat = externe()(20); // renvoie 20 et pas 10

Le conflit se produit l'instruction return x entre le paramtre x de la fonction interne et la variable x de la fonction externe. La chane de porte est ici {interne, externe, objet global}. Ainsi, le paramtre x de interne a la priorit sur la variable x de la fonction externe, le rsultat obtenu est donc 20 et non 10.

Fermetures (closures)

Les fermetures sont l'une des fonctionnalits les plus intressantes de JavaScript. Comme on l'a vu prcdemment, JavaScript permet d'imbriquer des fonctions et la fonction interne aura accs aux variables et paramtres de la fonction parente. l'inverse, la fonction parente ne pourra pas accder aux variables lies la fonction interne. Cela fournit une certaine scurit pour les variables de la fonction interne. De plus, si la fonction interne peut exister plus longtemps que la fonction parente, les variables et fonctions de la fonction parente pourront exister au travers de la fonction interne. On cre une fermeture lorsque la fonction interne est disponible en dehors de la fonction parente.

var animal = function (nom) {
  // La fonction externe utilise un paramtre "nom"
  var getNom = function () {
    return nom; // La fonction interne accde  la variable "nom" de la fonction externe
  };
  return getNom; // Renvoie la fonction interne pour la rendre disponible en dehors de la porte de la fonction parente
};

monAnimal = animal("Licorne");

monAnimal(); // Renvoie "Licorne"

Bien entendu, dans la pratique, les cas peuvent tre plus complexes. On peut renvoyer un objet qui contient des mthodes manipulant les variables internes de la fonction parente.

var crerAnimal = function (nom) {
  var sexe;

  return {
    setNom: function (nouveauNom) {
      nom = nouveauNom;
    },

    getNom: function () {
      return nom;
    },

    getSexe: function () {
      return sexe;
    },

    setSexe: function (nouveauSexe) {
      if (
        typeof nouveauSexe == "string" &&
        (nouveauSexe.toLowerCase() == "mle" ||
          nouveauSexe.toLowerCase() == "femelle")
      ) {
        sexe = nouveauSexe;
      }
    },
  };
};

var animal = crerAnimal("Licorne");
animal.getNom(); // Licorne

animal.setNom("Bobby");
animal.setSexe("mle");
animal.getSexe(); // mle
animal.getNom(); // Bobby

Dans le code prcdent, la variable nom est de la fonction externe est accessible depuis les fonctions internes. Il est impossible d'accder aux variables internes en dehors des fonctions internes. Les variables internes agissent comme des coffres-forts pour les fonctions internes. Elles permettent d'avoir un accs persistent et encapsul aux donnes internes. Pour les fonctions, il n'est pas ncessaire de les affecter une variable ou mme de les nommer.

var getCode = (function () {
  var codeAPI = "0]Eal(eh&2"; // Un code qu'on ne souhaite pas diffuser ni modifier

  return function () {
    return codeAPI;
  };
})();

getCode(); // Renvoie la valeur du code

Il y a malgr tout quelques piges auxquels il faut faire attention lorsqu'on utilise les fermetures. Si une fonction imbrique dfinit une variable avec le mme nom que le nom d'une variable de la porte externe, il n'y aura plus aucun moyen d'accder la variable.

var crerAnimal = function (nom) {
  // La fonction externe dfinit une variable appele "nom"
  return {
    setNom: function (nom) {
      // La fonction imbrique dfinit une variable appele "nom"
      nom = nom; // ??? comment accder  la variable "nom" dfinie par la fonction externe
    },
  };
};

L'oprateur this doit tre trait avec prcaution dans les fermetures. Attention, this fait rfrence au contexte o la fonction est appele et non l'endroit o il est dfini.

Utiliser l'objet arguments

Les arguments d'une fonction sont maintenus dans un objet semblable un tableau. Dans une fonction, il est possible d'utiliser les arguments passs la fonction de la faon suivante :

arguments[i];

o i reprsente l'index ordinal de l'argument (le premier argument ayant un indice 0). On accde donc au premier argument avec arguments[0]. Le nombre total d'arguments est fourni grce arguments.length.

En utilisant l'objet arguments, il est possible de recenser les arguments supplmentaires fournis la fonction si jamais il y a plus d'arguments fournis que requis. Cet objet est souvent utile si on ne connat pas le nombre d'arguments passs la fonction. La proprit arguments.length permet de dterminer le nombre d'arguments rellement passs la fonction. On peut donc ensuite accder aux diffrents arguments en parcourant l'objet arguments.

Par exemple, on peut construire une fonction qui concatne plusieurs chanes. Le seul argument formellement dfini sera la chane utilise pour concatner les diffrentes chanes. On peut dfinir la fonction de la faon suivante :

function monConcat(sparateur) {
  var result = ""; // on initialise la liste
  var i;
  // on parcourt les arguments
  for (i = 1; i < arguments.length; i++) {
    result += arguments[i] + sparateur;
  }
  return result;
}

On peut passer autant d'arguments que ncessaire cette fonction. Ils seront tous concatns dans une chane finale. Ainsi, on aura :

// renverra "rouge, orange, bleu, "
monConcat(", ", "red", "orange", "blue");

// renverra "lphant; girafe; lion; singe; "
monConcat("; ", "lphant", "girafe", "lion", "singe");

// renverra "sauge. basilic. origan. poivre. chalotte. "
monConcat(". ", "sauge", "basilic", "origan", "poivre", "chalotte");

Voir la page sur l'objet Function dans la rfrence JavaScript pour plus d'informations.

Paramtres des fonctions

partir d'ECMAScript 2015, deux sortes de paramtres sont introduites : les paramtres par dfaut et les paramtres du reste.

Les paramtres par dfaut

En JavaScript, par dfaut, les paramtres des fonctions vaudront undefined. Il peut toutefois tre utile de dfinir une valeur par dfaut diffrente. Les paramtres par dfaut permettent de rpondre ce besoin.

Avant ECMAScript 2015, la stratgie pour manipuler des valeurs par dfaut adaptes tait de tester si la valeur du paramtre tait indfinie puis de lui affecter la valeur souhaite si c'tait le cas. Par exemple, dans le code qui suit, on ne fournit pas de valeur pour b dans l'appel, la valeur sera undefined lors de l'valuation de a*b et l'appel multiplier aurait renvoy NaN. Pour viter a, la deuxime ligne dfinit une valeur par dfaut au cas o b n'est pas renseign :

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

  return a * b;
}

multiplier(5); // 5

Si on peut utiliser les paramtres par dfaut, il n'est plus ncessaire de faire l'opration l'intrieur du corps de la fonction, il suffit de dclarer que la valeur par dfaut pour b est 1 dans la signature de la fonction :

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

multiplier(5); // 5

Pour plus de dtails, voir la page sur les paramtres par dfaut dans la rfrence.

Les paramtres du reste

La syntaxe des paramtres du reste permet de reprsenter un nombre indfini d'arguments contenus dans un tableau. Dans l'exemple suivant, on utilise les paramtres du reste pour collecter les arguments partir du deuxime et jusqu'au dernier. Ces arguments sont multiplis par le premier. Dans cet exemple, on utilise une fonction flche, concept qui est prsent et illustr dans la section qui suit.

function multiplier(facteur, ...lesArgs) {
  return lesArgs.map((x) => facteur * x);
}

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

Fonctions flches

Une expression de fonction flche permet d'utiliser une syntaxe plus concise que les expressions de fonctions classiques. Une telle fonction ne possde alors pas de valeur propre pour this, arguments, super ou new.target. Les fonctions flches sont ncessairement anonymes.

Les fonctions flches ont t introduites pour deux raisons principales : une syntaxe plus courte et l'absence de this rattach la fonction. Voir aussi ce billet sur tech.mozfr.org sur les fonctions flches.

Concision de la syntaxe

Dans certaines constructions fonctionnelles, on peut apprcier une syntaxe courte. Par exemple, si on compare les deux dernires lignes de ce fragment de code :

var a = ["Hydrogen", "Helium", "Lithium", "Beryllium"];

var a2 = a.map(function (s) {
  return s.length;
});
console.log(a2); // affiche [8, 6, 7, 9]
var a3 = a.map((s) => s.length);
console.log(a3); // affiche [8, 6, 7, 9]

Pas de this distinct

Avant les fonctions flches, chaque nouvelle fonction dfinissait sa propre valeur this (un nouvel objet dans le cas d'un constructeur, undefined lors des appels en mode strict, l'objet courant dans le cas d'une mthode, etc.). Cela pouvait poser quelques problmes avec un style de programmation orient objet.

function Personne() {
  // Le constructeur Personne() utilise `this` comme lui-mme.
  this.ge = 0;

  setInterval(function grandir() {
    // En mode non-strict, la fonction grandir() dfinit `this`
    // avec l'objet global, qui est donc diffrent du `this`
    // dfini par le constructeur Person().
    this.ge++;
  }, 1000);
}

var p = new Personne();

Avec ECMAScript 3/5, ce problme fut rsolu en affectant la valeur de this une variable incluse dans la fermeture.

function Personne() {
  var self = this; // Certains utilisent `that`, d'autres `self`.
  // On utilisera l'un des deux et on pas
  // l'autre pour tre cohrent.
  self.ge = 0;

  setInterval(function grandir() {
    // La fonction callback fait rfrence  la variable `self`
    // qui est bien la valeur attendue lie  l'objet.
    self.ge++;
  }, 1000);
}

On aurait aussi pu crer une fonction lie afin que la bonne valeur de this soit passe la fonction grandir().

Les fonctions flches capturent la valeur de this dans le contexte englobant et cela permet de manipuler la valeur pertinente ici :

function Personne() {
  this.ge = 0;

  setInterval(() => {
    this.ge++; // this fait rfrence  l'objet personne
  }, 1000);
}

var p = new Personne();

Fonctions prdfinies

JavaScript possde plusieurs fonctions natives, disponibles au plus haut niveau :

eval()

La fonction eval() permet d'valuer du code JavaScript contenu dans une chane de caractres.

uneval()

La fonction uneval() cre une reprsentation sous la forme d'une chane de caractres pour le code source d'un objet.

isFinite()

La fonction isFinite() dtermine si la valeur passe est un nombre fini. Si ncessaire, le paramtre sera converti en un nombre.

isNaN()

La fonction isNaN() dtermine si une valeur est NaN ou non. Note : On pourra galement utiliser Number.isNaN() dfini avec ECMAScript 6 ou utiliser typeof afin de dterminer si la valeur est Not-A-Number.

parseFloat()

La fonction parseFloat() convertit une chane de caractres en un nombre flottant.

parseInt()

La fonction parseInt() convertit une chane de caractres et renvoie un entier dans la base donne.

decodeURI()

La fonction decodeURI() dcode un Uniform Resource Identifier (URI) cr par encodeURI() ou une mthode similaire.

decodeURIComponent()

La fonction decodeURIComponent() dcode un composant d'un Uniform Resource Identifier (URI) cr par encodeURIComponent ou une mthode similaire.

encodeURI()

La fonction encodeURI() encode un Uniform Resource Identifier (URI) en remplaant chaque exemplaire de certains caractres par un, deux, trois voire quatre squences d'chappement reprsentant l'encodage UTF-8 du caractres (quatre squences seront utilises uniquement lorsque le caractre est compos d'une paire de deux demi-codets).

encodeURIComponent()

La fonction encodeURIComponent() encode un composant d'un Uniform Resource Identifier (URI) en remplaant chaque exemplaire de certains caractres par un, deux, trois voire quatre squences d'chappement reprsentant l'encodage UTF-8 du caractres (quatre squences seront utilises uniquement lorsque le caractre est compos d'une paire de deux demi-codets).

escape()

La fonction dprcie escape() calcule une nouvelle chane de caractres pour laquelle certains caractres ont t remplacs par leur squence d'chappement hexadcimale. Les fonctions encodeURI() ou encodeURIComponent() doivent tre utilises la place.

unescape()

La fonction dprcie unescape() calcule une nouvelle chane de caractres pour laquelle les squences d'chappement hexadcimales sont remplaces par les caractres qu'elles reprsentent. Les squences d'chappement introduites peuvent provenir d'une fonction telle que escape(). unescape est dprcie et doit tre remplace par decodeURI() ou decodeURIComponent().

• Prcdent
• Suivant