• Précédent
• Suivant

Les fonctions font partie des briques fondamentales de JavaScript. Une fonction est une procédure JavaScript, un ensemble d'instructions effectuant une tâche ou calculant une valeur. Afin d'utiliser une fonction, il est nécessaire de l'avoir auparavant définie au sein de la portée dans laquelle on souhaite l'appeler.

On pourra également lirele chapitre de la référence JavaScript sur les fonctions pour étudier plus en détails ce concept

Définir des fonctions

Les déclarations de fonctions

Unedéfinition de fonction (aussi appeléedéclaration de fonction ouinstruction de fonction) est construite avec le mot-cléfunction, suivi par :

• Le nom de la fonction.
• Une liste d'arguments à passer à la fonction, entre parenthèses et séparés par des virgules.
• Les instructions JavaScript définissant la fonction, entre accolades,{ }.

Le code suivant, par exemple, définit une fonction intituléecarré :

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

La fonctioncarré prend un seul argument, appelénombre. La fonction est composée d'une seule instruction qui renvoie l'argument de la fonction (nombre) multiplié par lui-même. L'instructionreturn spécifie la valeur qui est renvoyée par la fonction.

return nombre * nombre;

Les paramètres primitifs (comme les nombres) sont passés à la fonctionpar valeur. La valeur est passée à la fonction mais si cette dernière change la valeur du paramètre, 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 objetArray ou un objet défini par l'utilisateur), et que la fonction change les propriétés de cet objet, ces changements seront visibles en dehors de la fonction. Par exemple :

function maFonction(monObjet) {  monObjet.fabricant = "Toyota";}var mavoiture = { fabricant: "Honda", modèle: "Accord", année: 1998 };var x, y;x = mavoiture.fabricant; // x aura la valeur "Honda"maFonction(mavoiture);y = mavoiture.fabricant; // y aura la valeur "Toyota"// (la propriété fabricant a été modifiée par la fonction)

function maFonction(monObjet) {  monObjet = { fabricant: "Ford", modèle: "Focus", année: 2006 };}var mavoiture = { fabricant: "Honda", modèle: "Accord", année: 1998 };var x, y;x = mavoiture.fabricant; // x reçoit la valeur "Honda"maFonction(mavoiture);y = mavoiture.fabricant; // y reçoit la valeur "Honda"

Dans le premier exemple, l'objetmavoiture était passé à la fonctionmaFonction 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, possédant le même 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 déclaration de fonction utilisée ci-dessus est une instruction. On peut également créer une fonction grâce à uneexpression de fonction. De telles fonctions peuvent êtreanonymes (ne pas avoir de nom correspondant). La fonctioncarré aurait pu être définie de la façon suivante :

var carré = function (nombre) {  return nombre * nombre;};var x = carré(4); //x reçoit la valeur 16

Cependant, un nom peut être utilisé dans une expression de fonction, ce afin de l'utiliser dans la fonction (récursivité) ou afin de l'identifier dans les appels tracés par un éventuel débogueur :

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 fonctionmap est définie et appelée avec une fonction anonyme comme premier argument :

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

Le code suivant applique la fonctioncube sur chacun des éléments du tableau :

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

Le résultat de la dernière instruction est le tableau [0, 1, 8, 125, 1000].

En JavaScript, une fonction peut être définie selon une condition. Le fragment de code qui suit définit une fonction seulement sinum vaut 0 :

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

Une autre façon de définir des fonctions est d'utiliser le constructeur de l'objetFunction afin de créer des fonctions à partir d'une chaîne lors de l'exécution, de la même façon queeval().

Uneméthode est une fonction étant une propriété d'un objet. Vous trouverez plus de détails sur ces éléments dans le chapitre suivant du guide :Utiliser les objets.

Appeler des fonctions

La seule définition d'une fonction ne permet pas d'exécuter la fonction. Cela permet de lui donner un nom et de définir ce qui doit être fait lorsque la fonction est appelée.Appeler la fonction permet d'effectuer les actions des instructions avec les paramètres indiqués. Par exemple, si on définit la fonctioncarré, on peut l'appeler de la façon suivante :

carré(5);

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

Les fonctions doivent appartenir à la portée dans laquelle elles sont appelées. En revanche, la déclaration d'une fonction peut être faite après l'appel :

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

La portée d'une fonction est la fonction dans laquelle elle est déclarée ou le programme entier si elle est déclarée au niveau le plus haut.

console.log(carré); // La fonction carré est remontée/hoisted mais vaut undefinedconsole.log(carré(5)); // TypeError: carré is not a functionvar carré = function (n) {  return n * n;};// Et avec let...console.log(carré2); // ReferenceError: carré2 is not definedconsole.log(carré2(5)); // TypeError: carré2 is not a functionlet carré2 = function (n) {  return n * n;};

Les arguments d'une fonction ne sont pas limités aux chaînes de caractères et aux nombres. Il est possible de passer des objets. La fonctionshow_props (définie dans le chapitre surl'utilisation des objets) est un exemple de fonction utilisant un argument qui est un objet.

Une fonction peut être récursive, c'est-à-dire qu'elle peut s'appeler elle-même. Voici la fonction qui calcule récursivement 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 reçoit la valeur 1b = factorielle(2); // b reçoit la valeur 2c = factorielle(3); // c reçoit la valeur 6d = factorielle(4); // d reçoit la valeur 24e = factorielle(5); // e reçoit la valeur 120

Il existe d'autres façons d'appeler des fonctions. Il existe souvent des cas où une fonction doit être appelée 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 déterminé lors de l'exécution. Les fonctions sont des objets, en tant que tels, elles possèdent des méthodes (voir la page sur l'objetFunction). L'une d'entre elles,apply() peut être utilisée pour réaliser le dernier cas de figure (exécution d'une fonction avec un objet déterminé à l'exécution).

Portée d'une fonction

On ne peut pas accéder aux variables définies dans une fonction en dehors de cette fonction : ces variables n'existent que dans la portée de la fonction. En revanche, une fonction peut accéder aux différentes variables et fonctions qui appartiennent à la portée dans laquelle elle est définie. Une fonction définie dans une autre fonction peut également accéder à toutes les variables de la fonction « parente » et à toute autre variable accessible depuis la fonction « parente ».

// Les variables suivantes sont globalesvar num1 = 20,  num2 = 3,  nom = "Licorne";// Cette fonction est définie dans la portée globalefunction multiplier() {  return num1 * num2;}multiplier(); // Renvoie 60// Un exemple de fonction imbriquéefunction getScore() {  var num1 = 2,    num2 = 3;  function ajoute() {    return nom + " a marqué " + (num1 + num2);  }  return ajoute();}getScore(); // Renvoie "Licorne a marqué 5"

Portée et pile de fonctions

La récursivité

Une fonction peut faire référence à elle-même et s'appeler elle-même. Il existe trois moyens pour qu'une fonction fasse référence à elle-même :

1. Le nom de la fonction
2. arguments.callee
3. Une variable de la portée qui fait référence à la fonction

Par exemple, avec la définition de fonction suivante :

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

Dans le corps de la fonction, ces trois éléments seront équivalents :

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

Une fonction qui s'appelle elle-même est appelée une fonctionrécursive. Sous certains aspects, une récursion est semblable à une boucle : toutes les deux exécutent le même code plusieurs fois et toutes les deux requièrent une condition d'arrêt (pour éviter une boucle ou une récursion infinie). Par exemple, ce fragment de code utilisant une boucle :

var x = 0;while (x < 10) {  // "x < 10" représente la condition d'arrêt  // faire quelque chose  x++;}

pourra être converti en une fonction récursive de la façon suivante :

function boucle(x) {  if (x >= 10) {    // "x >= 10" représente la condition d'arrêt (équivalent à "!(x < 10)")    return;  }  // faire quelque chose  boucle(x + 1); // l'appel récursif}boucle(0);

Malgré cela, certains algorithmes ne peuvent pas être convertis en boucles itératives. Ainsi, récupérer l'ensemble des nœuds d'un arbre (leDOM par exemple) se fait plus simplement en utilisant la récursivité :

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 précédent avec la fonctionboucle, ici, chaque appel récursif entraîne lui-même plusieurs appels (et non un seul).

Théoriquement, il est possible de convertir tout algorithme récursif en un algorithme non récursif (avec des boucles par exemple). Généralement, la logique obtenue est plus complexe et nécessite l'utilisation d'unepile. La récursivité 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("début : " + i);  toto(i - 1);  console.log("fin : " + i);}toto(3);

qui affichera :

début : 3début : 2début : 1début : 0fin : 0fin : 1fin : 2fin : 3

Fonctions imbriquées et fermetures

Il est possible d'imbriquer une fonction dans une autre fonction. La portée de la fonction fille (celle qui est imbriquée) n'est pas contenue dans la portée de la fonction parente. En revanche, la fonction fille bénéficie bien des informations de la fonction parente grâce à sa portée. On a ce qu'on appelle une fermeture (closure en anglais). Une fermeture est une expression (généralement une fonction) qui accède à des variables libres ainsi qu'à un environnement qui lie ces variables (ce qui « ferme » l'expression).

Une fonction imbriquée étant une fermeture, cela signifie qu'une fonction imbriquée peut en quelque sorte hériter des arguments et des variables de la fonction parente.

En résumé :

• La fonction imbriquée ne peut être utilisée qu'à partir des instructions de la fonction parente.

• La fonction imbriquée 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 ajouteCarrés(a, b) {  function carré(x) {    return x * x;  }  return carré(a) + carré(b);}a = ajouteCarrés(2, 3); // renvoie 13b = ajouteCarrés(3, 4); // renvoie 25c = ajouteCarrés(4, 5); // renvoie 41

La fonction interne étant une fermeture, on peut appeler la fonction parente afin de définir 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 donnerarésultat = fn_fille(5); // renvoie 8résultat1 = parente(3)(5); // renvoie 8

Préservation des variables

Dans l'exemple précédent,x a été « préservé » lorsque la fonctionfille a été renvoyée. Une fermeture conserve les arguments et les variables de chaque portée qu'elle référence. Chaque appel à la fonction parente pouvant fournir un contexte différents selon les arguments, cela entraînera la création d'une nouvelle fermeture. La mémoire associée ne pourra être libérée que lorsque la fonctionfille ne sera plus accessible.

Ce mode de fonctionnement n'est pas différent de celui des références vers les objets. Cependant, il est souvent plus compliqué à détecter car les références ne sont pas définies 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 accéder à la portée de A, C peut accéder à la portée de B. Ainsi, C accède à la portée de B qui lui accède à la portée de A, C accède donc à la portée de A (transitivité). Les fermetures peuvent donc contenir plusieurs portées, c'est ce qu'on appelle lechaînage de portées.

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 exempleC accède auy deB et aux deA. Ceci est rendu possible car :

1. B est une fermeture qui contientA, autrement ditB peut accéder aux arguments et aux variables deA.
2. C est une fermeture qui contientB.
3. La fermeture deB contientA donc la fermeture deC contientA,C peut ainsi accéder aux arguments et aux variables deBetA. On dit queCchaîne les portées deB et deA (dans cet ordre).

La réciproque n'est pas vraie.A ne peut pas accéder àC, carA ne peut pas accéder aux arguments ou aux variables deB, orC est une variable deB. De cette façon,C reste privée en dehors deB.

Conflits de nommage

Lorsque deux arguments ou variables des portées d'une fermeture ont le même nom, il y a un conflit de noms. Dans ces cas, ce sera la portée la plus imbriquée qui prendra la priorité sur le nom, la portée la plus « externe » aura la priorité la plus faible pour les noms de variables. Du point de vue de la chaîne des portées, la première portée sur la chaîne est la portée la plus imbriquée et la dernière est la portée située le plus à l'extérieur :

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

Le conflit se produit à l'instructionreturn x entre le paramètre x de la fonctioninterne et la variablex de la fonctionexterne. La chaîne de portée est ici {interne,externe, objet global}. Ainsi, le paramètrex deinterne a la priorité sur la variablex de la fonctionexterne, le résultat obtenu est donc 20 et non 10.

Fermetures (closures)

Les fermetures sont l'une des fonctionnalités les plus intéressantes de JavaScript. Comme on l'a vu précédemment, JavaScript permet d'imbriquer des fonctions et la fonction interne aura accès aux variables et paramètres de la fonction parente. À l'inverse, la fonction parente ne pourra pas accéder aux variables liées à la fonction interne. Cela fournit une certaine sécurité 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 crée une fermeture lorsque la fonction interne est disponible en dehors de la fonction parente.

var animal = function (nom) {  // La fonction externe utilise un paramètre "nom"  var getNom = function () {    return nom; // La fonction interne accède à la variable "nom" de la fonction externe  };  return getNom; // Renvoie la fonction interne pour la rendre disponible en dehors de la portée 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 méthodes manipulant les variables internes de la fonction parente.

var créerAnimal = 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() == "mâle" ||          nouveauSexe.toLowerCase() == "femelle")      ) {        sexe = nouveauSexe;      }    },  };};var animal = créerAnimal("Licorne");animal.getNom(); // Licorneanimal.setNom("Bobby");animal.setSexe("mâle");animal.getSexe(); // mâleanimal.getNom(); // Bobby

Dans le code précédent, la variablenom est de la fonction externe est accessible depuis les fonctions internes. Il est impossible d'accéder 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 accès persistent et encapsulé aux données internes. Pour les fonctions, il n'est pas nécessaire de les affecter à une variable ou même 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 pièges auxquels il faut faire attention lorsqu'on utilise les fermetures. Si une fonction imbriquée définit une variable avec le même nom que le nom d'une variable de la portée externe, il n'y aura plus aucun moyen d'accéder à la variable.

var créerAnimal = function (nom) {  // La fonction externe définit une variable appelée "nom"  return {    setNom: function (nom) {      // La fonction imbriquée définit une variable appelée "nom"      nom = nom; // ??? comment accéder à la variable "nom" définie par la fonction externe    },  };};

L'opérateurthis doit être traité avec précaution dans les fermetures. Attention,this fait référence au contexte où la fonction est appelée et non à l'endroit où il est défini.

Utiliser l'objetarguments

Les arguments d'une fonction sont maintenus dans un objet semblable à un tableau. Dans une fonction, il est possible d'utiliser les arguments passés à la fonction de la façon suivante :

arguments[i];

oùi représente l'index ordinal de l'argument (le premier argument ayant un indice à 0). On accède donc au premier argument avecarguments[0]. Le nombre total d'arguments est fourni grâce àarguments.length.

En utilisant l'objetarguments, il est possible de recenser les arguments supplémentaires fournis à la fonction si jamais il y a plus d'arguments fournis que requis. Cet objet est souvent utile si on ne connaît pas le nombre d'arguments passés à la fonction. La propriétéarguments.length permet de déterminer le nombre d'arguments réellement passés à la fonction. On peut donc ensuite accéder aux différents arguments en parcourant l'objetarguments.

Par exemple, on peut construire une fonction qui concatène plusieurs chaînes. Le seul argument formellement défini sera la chaîne utilisée pour concaténer les différentes chaînes. On peut définir la fonction de la façon suivante :

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

On peut passer autant d'arguments que nécessaire à cette fonction. Ils seront tous concaténés dans une chaîne finale. Ainsi, on aura :

// renverra "rouge, orange, bleu, "monConcat(", ", "red", "orange", "blue");// renverra "éléphant; girafe; lion; singe; "monConcat("; ", "éléphant", "girafe", "lion", "singe");// renverra "sauge. basilic. origan. poivre. échalotte. "monConcat(". ", "sauge", "basilic", "origan", "poivre", "échalotte");

Voir la page sur l'objetFunction dans la référence JavaScript pour plus d'informations.

Paramètres des fonctions

À partir d'ECMAScript 2015, deux sortes de paramètres sont introduites : les paramètres par défaut et les paramètres du reste.

Les paramètres par défaut

En JavaScript, par défaut, les paramètres des fonctions vaudrontundefined. Il peut toutefois être utile de définir une valeur par défaut différente. Les paramètres par défaut permettent de répondre à ce besoin.

Avant ECMAScript 2015, la stratégie pour manipuler des valeurs par défaut adaptées était de tester si la valeur du paramètre était indéfinie puis de lui affecter la valeur souhaitée si c'était le cas. Par exemple, dans le code qui suit, on ne fournit pas de valeur pourb dans l'appel, la valeur seraundefined lors de l'évaluation dea*b et l'appel àmultiplier aurait renvoyéNaN. Pour éviter ça, la deuxième ligne définit une valeur par défaut 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 paramètres par défaut, il n'est plus nécessaire de faire l'opération à l'intérieur du corps de la fonction, il suffit de déclarer que la valeur par défaut pourb est 1 dans la signature de la fonction :

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

Pour plus de détails, voirla page sur les paramètres par défaut dans la référence.

Les paramètres du reste

La syntaxe desparamètres du reste permet de représenter un nombre indéfini d'arguments contenus dans un tableau. Dans l'exemple suivant, on utilise les paramètres du reste pour collecter les arguments à partir du deuxième et jusqu'au dernier. Ces arguments sont multipliés par le premier. Dans cet exemple, on utilise une fonction fléchée, concept qui est présenté 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 fléchées

Une expression de fonction fléchée permet d'utiliser une syntaxe plus concise que les expressions de fonctions classiques. Une telle fonction ne possède alors pas de valeur propre pourthis,arguments,super ounew.target. Les fonctions fléchées sont nécessairement anonymes.

Les fonctions fléchées ont été introduites pour deux raisons principales : une syntaxe plus courte et l'absence dethis rattaché à la fonction. Voir aussice billet sur tech.mozfr.org sur les fonctions fléchées.

Concision de la syntaxe

Dans certaines constructions fonctionnelles, on peut apprécier une syntaxe courte. Par exemple, si on compare les deux dernières 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 dethis distinct

Avant les fonctions fléchées, chaque nouvelle fonction définissait sa propre valeurthis (un nouvel objet dans le cas d'un constructeur,undefined lors des appels enmode strict, l'objet courant dans le cas d'une méthode, etc.). Cela pouvait poser quelques problèmes avec un style de programmation orienté objet.

function Personne() {  // Le constructeur Personne() utilise `this` comme lui-même.  this.âge = 0;  setInterval(function grandir() {    // En mode non-strict, la fonction grandir() définit `this`    // avec l'objet global, qui est donc différent du `this`    // défini par le constructeur Person().    this.âge++;  }, 1000);}var p = new Personne();

Avec ECMAScript 3/5, ce problème fut résolu en affectant la valeur dethis à 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 cohérent.  self.âge = 0;  setInterval(function grandir() {    // La fonction callback fait référence à la variable `self`    // qui est bien la valeur attendue liée à l'objet.    self.âge++;  }, 1000);}

On aurait aussi pu créer une fonction liée afin que la « bonne » valeur dethis soit passée à la fonctiongrandir().

Les fonctions fléchées capturent la valeur dethis dans le contexte englobant et cela permet de manipuler la valeur pertinente ici :

function Personne() {  this.âge = 0;  setInterval(() => {    this.âge++; // this fait référence à l'objet personne  }, 1000);}var p = new Personne();

Fonctions prédéfinies

JavaScript possède plusieurs fonctions natives, disponibles au plus haut niveau :

eval()

La fonctioneval() permet d'évaluer du code JavaScript contenu dans une chaîne de caractères.

uneval()Non standard

La fonctionuneval() crée une représentation sous la forme d'une chaîne de caractères pour le code source d'un objet.

isFinite()

La fonctionisFinite() détermine si la valeur passée est un nombre fini. Si nécessaire, le paramètre sera converti en un nombre.

isNaN()

La fonctionisNaN() détermine si une valeur estNaN ou non. Note : On pourra également utiliserNumber.isNaN() défini avec ECMAScript 6 ou utilisertypeof afin de déterminer si la valeur estNot-A-Number.

parseFloat()

La fonctionparseFloat() convertit une chaîne de caractères en un nombre flottant.

parseInt()

La fonctionparseInt() convertit une chaîne de caractères et renvoie un entier dans la base donnée.

decodeURI()

La fonctiondecodeURI() décode un Uniform Resource Identifier (URI) créé parencodeURI() ou une méthode similaire.

decodeURIComponent()

La fonctiondecodeURIComponent() décode un composant d'un Uniform Resource Identifier (URI) créé parencodeURIComponent ou une méthode similaire.

encodeURI()

La fonctionencodeURI() encode un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par un, deux, trois voire quatre séquences d'échappement représentant l'encodage UTF-8 du caractères (quatre séquences seront utilisées uniquement lorsque le caractère est composé d'une paire de deux demi-codets).

encodeURIComponent()

La fonctionencodeURIComponent() encode un composant d'un Uniform Resource Identifier (URI) en remplaçant chaque exemplaire de certains caractères par un, deux, trois voire quatre séquences d'échappement représentant l'encodage UTF-8 du caractères (quatre séquences seront utilisées uniquement lorsque le caractère est composé d'une paire de deux demi-codets).

escape()Obsolète

La fonction dépréciéeescape() calcule une nouvelle chaîne de caractères pour laquelle certains caractères ont été remplacés par leur séquence d'échappement hexadécimale. Les fonctionsencodeURI() ouencodeURIComponent() doivent être utilisées à la place.

unescape()Obsolète

La fonction dépréciéeunescape() calcule une nouvelle chaîne de caractères pour laquelle les séquences d'échappement hexadécimales sont remplacées par les caractères qu'elles représentent. Les séquences d'échappement introduites peuvent provenir d'une fonction telle queescape().unescape est dépréciée et doit être remplacée pardecodeURI() oudecodeURIComponent().

• Précédent
• Suivant