Expressions et oprateurs

Oprateurs d'affectation

Un oprateur d'affectation affecte une valeur son oprande gauche selon la valeur de son oprande droit. L'oprateur d'affectation simple est le signe gal (=), qui affecte la valeur de son oprande droit son oprande gauche. Autrement dit, x = f() est une expression d'affectation qui affecte la valeur de f() x.

Il existe galement des oprateurs d'affectation composites qui sont des raccourcis pour les oprations listes dans le tableau qui suit :

Affectation aux proprits

Si une expression est value en un objet, le ct gauche d'une expression d'affectation pourra tre utilis pour des affectations sur les proprits de cette expression. Par exemple :

const obj = {};

obj.x = 3;
console.log(obj.x); // Affiche 3.
console.log(obj); // Affiche { x: 3 }.

const key = "y";
obj[key] = 5;
console.log(obj[key]); // Affiche 5.
console.log(obj); // Affiche { x: 3, y: 5 }.

Pour plus d'informations sur les objets, voir Utiliser les objets.

Si une expression n'est pas value en un objet, les affectations aux proprits de cette expression ne fonctionneront pas :

const val = 0;
val.x = 3;

console.log(val.x); // Affiche undefined.
console.log(val); // Affiche 0.

En mode strict, le fragment de code qui prcde dclenchera une exception, car on ne peut pas affecter de proprits des valeurs primitives.

C'est une erreur que d'affecter des valeurs des proprits non-modifiables ou des proprits d'une expression sans proprit (null ou undefined).

Dcomposition

Pour les affectations plus complexes, l'affectation par dcomposition permet de construire une expression JavaScript pour extraire des donnes de tableaux ou d'objets avec une syntaxe qui reflte les littraux utiliss pour la construction de tableaux ou d'objets.

const toto = ["un", "deux", "trois"];

// sans dcomposition
const un = toto[0];
const deux = toto[1];
const trois = toto[2];

// avec dcomposition
const [un, deux, trois] = toto;

valuation et imbrication

En gnral, les affectations sont utilises pour une dclaration de variable (c'est--dire avec les instructions const, let, ou var) ou comme instructions indpendantes.

// Dclare une variable x et l'initialise avec le rsultat de f().
// Le rsultat de l'expression d'affectation "x = f()" est cart.
let x = f();

x = g(); // Raffecte le rsultat de g()  la variable x.

Toutefois, l'instar des autres expressions, les expressions d'affectation comme x = f() ont comme rsultat une valeur. Bien que cette valeur ne soit gnralement pas utilise, elle peut tre utilise dans une autre expression.

L'enchanement d'affectations ou l'imbrication d'affectation dans d'autres expressions peut produire des rsultats tranges. C'est pour cette raison que certains guides stylistiques JavaScript dconseillent l'enchanement ou l'imbrication d'affectations). Toutefois, vous pourrez en voir dans certains codes et il est donc important de comprendre comment ils fonctionnent.

En enchanant ou en imbriquant les expressions d'affectation, le rsultat de chaque expression peut tre affect une autre variable. On peut s'en servir pour journaliser, la placer dans un tableau, un appel de fonction, etc.

let x;
const y = (x = f()); // Une notation quivalente serait : const y = x = f();
console.log(y); // Affiche la valeur de retour de l'affectation x = f().

console.log((x = f())); // Affiche la valeur de retour directement.

// Une expression d'affectation peut tre imbrique  n'importe quel
// endroit o les expressions sont autorises, que ce soit comme
// lment d'un littral de tableau ou comme argument dans un appel
// de fonction
console.log([0, (x = f()), 0]);
console.log(f(0, (x = f()), 0));

Le rsultat de l'valuation correspond l'expression droite du signe = dans la colonne  Signification  du tableau ci-avant. Cela signifie que l'valuation de x = f() aura comme rsultat celui de f(), que l'valuation de x += f() aura comme rsultat la somme x + f(), que celle de x **= f() aura comme rsultat x ** f(), etc.

Pour les affectations logiques, x &&= f(), x ||= f(), et x ??= f(), la valeur de retour est celle de l'opration logique sans affectation, soit x && f(), x || f(), et x ?? f(), respectivement.

Lorsqu'on enchane ces expressions sans parenthses ou oprateur de groupement comme les littraux de tableau, les expressions d'affectation sont groupes de droite gauche (elles sont associatives droite), mais sont values de gauche droite.

On notera que pour les oprateurs d'affectation, l'exception de =, les valeurs rsultantes sont toujours bases sur les valeurs des oprandes avant l'opration.

Par exemple, si on a les fonctions f et g et les variables x et y comme suit :

function f() {
  console.log("F!");
  return 2;
}
function g() {
  console.log("G!");
  return 3;
}
let x, y;

Prenons ces trois exemples :

y = x = f();
y = [f(), (x = g())];
x[f()] = g();

Exemple d'valuation n1

y = x = f() est quivalente y = (x = f()), car l'oprateur d'affectation est associatif droite. Toutefois l'valuation se fait de gauche droite :

1. L'valuation de l'expression d'affectation y = x = f() commence.
   1. L'oprande y gauche de l'affectation est valu comme une rfrence la variable nomme y.
   2. L'valuation de l'expression d'affectation x = f() commence.
      1. L'oprande x gauche de l'affectation est valu comme une rfrence la variable nomme x.
      2. L'appel de fonction f() affiche "F!" dans la console et renvoie la valeur 2.
      3. Ce rsultat de f(), 2, est affect x.
   3. L'valuation de l'expression d'affectation x = f() est maintenant termine. Son rsultat est la nouvelle valeur de x, qui est 2.
   4. Ce rsultat, 2, est son tour affect y.
2. L'valuation de l'expression d'affectation y = x = f() est maintenant termine. Son rsultat est la nouvelle valeur de y, qui est ici 2. La valeur 2 a t affecte x et y, et la console a affich "F!".

Exemple d'valuation n2

y = [ f(), x = g() ] est galement value de gauche droite :

1. L'valuation de l'expression d'affectation y = [ f(), x = g() ] commence.
   1. L'oprande y gauche de l'affectation est valu comme une rfrence la variable nomme y.
   2. L'valuation du littral de tableau [ f(), x = g() ] commence.
      1. L'appel de fonction f() affiche "F!" dans la console et renvoie la valeur 2.
      2. L'valuation de l'expression d'affectation x = g() commence.
         1. L'oprande x gauche de l'affectation est valu comme une rfrence la variable nomme x.
         2. L'appel de fonction g() affiche "G!" dans la console et renvoie la valeur 3.
         3. Ce rsultat de g(), 3, est affect x.
      3. L'valuation de l'expression d'affectation x = g() est maintenant termine. Son rsultat est la nouvelle valeur de x  3. Ce rsultat devient l'lment qui suit dans le littral de tableau (aprs le 2 provenant de f()).
   3. L'valuation du littral de tableau [ f(), x = g() ] est maintenant termine. Son rsultat est un tableau avec deux valeurs : [ 2, 3 ].
   4. Ce tableau, [ 2, 3 ], est affect y.
2. L'valuation de l'expression d'affectation y = [ f(), x = g() ] est maintenant termine. Son rsultat est la nouvelle valeur de y, qui est [ 2, 3 ]. 3 est affect x, [ 2, 3 ] est affect y et la console a affich "F!" puis "G!".

Exemple d'valuation n3

x[f()] = g() est galement value de gauche droite. Dans cet exemple, on part du principe que la valeur de x est dj un objet (pour plus d'informations sur les objets, voir Utiliser les objets).

1. L'valuation de l'expression d'affectation x[f()] = g() commence.
   1. L'valuation de l'accs la proprit x[f()] situ gauche de l'oprateur d'affectation commence.
      1. Le x est valu comme une rfrence la variable nomme x.
      2. Ensuite, l'appel f() affiche "F!" dans la console et renvoie la valeur 2.
   2. L'valuation de x[f()] est maintenant termine et son rsultat est une variable qui rfrence la proprit x[2].
   3. Ensuite, l'appel la fonction g() affiche "G!" dans la console et renvoie la valeur 3.
   4. Ce rsultat, 3, est affect x[2] (cette tape russira uniquement si la valeur de x est un objet)?
2. L'valuation de l'expression d'affectation x[f()] = g() est maintenant termine. Son rsultat est la nouvelle valeur de x[2], qui est 3. 3 a t affect x[2] et la console a affich "F!" puis "G!".

viter les enchanements d'affectation

L'enchanement ou l'imbrication d'affectations dans d'autres expressions peut produire d'tranges rsultats et c'est pour cette raison que les enchanements et imbrications d'affectation sont dconseills).

On vitera en particulier les enchanements d'affectation dans une instruction const, let, ou var qui ne fonctionnent pas dans la plupart des cas. Seule la variable la plus gauche sera alors dclare et les variables intermdiaires dans la chane ne seront pas dclares par l'instruction const/let/var. Ainsi, si on a :

const z = y = x = f();

On pourrait penser que cela permet de dclarer les variables x, y, et z. Cependant, seule la variable z est dclare. y et x sont des rfrences invalides des variables inexistantes (en mode strict) ou, pire, crent des variables globales pour x et y en mode non-strict.

Oprateurs de comparaison

Un oprateur de comparaison compare ses oprandes et renvoie une valeur logique selon que la comparaison est vraie ou non. Les oprandes peuvent tre des nombres, des chanes de caractres, des boolens ou des objets. Les chanes de caractres sont compares selon l'ordre lexicographique standard en utilisant les valeurs Unicode.

Dans la plupart des cas, si les deux oprandes ne sont pas du mme type, le moteur JavaScript tentera de les convertir dans un type appropri pour la comparaison. Cela entrane gnralement une comparaison numrique des oprandes.

Les oprateurs === et !== sont des exceptions cette rgle de conversion : ils ralisent des comparaisons d'galit et d'ingalit strictes. Ces oprateurs n'effectuent pas de conversion des oprandes avant la vrification de l'galit. Le tableau qui suit dcrit les oprateurs de comparaison en utilisant ce fragment de code comme exemple :

const var1 = 3;
const var2 = 4;

Oprateurs arithmtiques

Un oprateur arithmtique combine des oprandes numriques et renvoie une valeur numrique. Les oprateurs arithmtiques standard sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/). Ces oprateurs fonctionnent comme dans la plupart des langages de programmation qui utilisent les nombres flottants (la division par zro donne notamment Infinity). On pourra par exemple avoir :

1 / 2; // 0.5
1 / 2 === 1.0 / 2.0; // true

En plus des oprations arithmtiques standard (+, -, *, /), JavaScript fournit les oprateurs arithmtiques suivants :

Oprateurs binaires

Un oprateur binaire traite les oprandes comme des suites de 32 bits (des zros ou des uns) plutt que comme des nombres dcimaux, hexadcimaux et octaux. Ainsi, le nombre dcimal 9 se reprsente en binaire comme 1001. Les oprateurs binaires effectuent leur opration sur des reprsentations binaires et renvoient des valeurs numriques.

Le tableau qui suit dtaille les oprateurs binaires JavaScript.

Oprateurs binaires logiques

Les oprateurs logiques binaires fonctionnent de la faon suivante :

• Les oprandes sont convertis en entiers sur 32 bits. Pour les nombres dont la valeur binaire dpasse 32 bits, les bits les plus hauts sont abandonns. Ainsi, l'entier suivant sur plus de 32 bits sera converti en entier sur 32 bits :

  Avant : 1110 0110 1111 1010 0000 0000 0000 0110 0000 0000 0001
  Aprs :                1010 0000 0000 0000 0110 0000 0000 0001
  

• Chaque bit du premier oprande est associ au bit correspondant du second oprande : le premier bit avec le premier bit, le second avec le second et ainsi de suite.

• L'oprateur est appliqu sur chaque paire ainsi constitue et le rsultat est construit en binaire.

Par exemple, la reprsentation binaire du nombre dcimal 9 est 1001, et celle du nombre dcimal 15 est 1111. Aussi, quand on utilise les oprateurs binaires sur ces valeurs, on a les rsultats suivants :

On notera que tous les 32 bits sont inverss lors de l'utilisation de l'oprateur NON binaire et que les valeurs avec le bit le plus gauche 1 reprsentent des valeurs ngatives (reprsentation en complment deux). Aussi, l'valuation de ~x fournira la mme valeur que -x - 1.

Oprateurs de dcalage binaire

Les oprateurs de dcalage binaire utilisent deux oprandes : celui de gauche est la quantit sur laquelle effectuer le dcalage et celui de droite indique le nombre de bits dcaler. La direction de l'opration de dcalage dpend de l'oprateur utilis.

Les oprateurs de dcalage convertissent leurs oprandes en entiers sur 32 bits et renvoient un rsultat de type Number ou BigInt selon la rgle suivante : si l'oprande gauche est de type BigInt, la valeur de retour sera de type BigInt et sinon, la valeur de retour sera de type Number.

Les oprateurs de dcalage sont lists dans le tableau suivant.

Oprateurs logiques

Les oprateurs logiques sont gnralement utiliss avec des valeurs boolennes. Lorsque c'est le cas, la valeur de retour est galement boolenne. Plus gnralement, les oprateurs && et || renvoient la valeur d'un des deux oprandes (et peuvent donc renvoyer une valeur qui n'est pas un boolen). Ces oprateurs sont dcrits dans le tableau suivant.

Les expressions quivalentes false sont celles qui sont values avec la valeur null, 0, NaN, la chane vide (""), ou undefined.

Les exemples de code suivant illustrent l'utilisation de l'oprateur ET logique &&.

const a1 = true && true; // t && t renvoie true
const a2 = true && false; // t && f renvoie false
const a3 = false && true; // f && t renvoie false
const a4 = false && 3 === 4; // f && f renvoie false
const a5 = "Chat" && "Chien"; // t && t renvoie Chien
const a6 = false && "Chat"; // f && t renvoie false
const a7 = "Chat" && false; // t && f renvoie false

Les exemples de code suivant illustrent l'utilisation de l'oprateur OU logique ||.

const o1 = true || true; // t || t renvoie true
const o2 = false || true; // f || t renvoie true
const o3 = true || false; // t || f renvoie true
const o4 = false || 3 === 4; // f || f renvoie false
const o5 = "Chat" || "Chien"; // t || t renvoie Chat
const o6 = false || "Chat"; // f || t renvoie Chat
const o7 = "Chat" || false; // t || f renvoie Chat

Les exemples de code suivant illustrent l'utilisation de l'oprateur NON logique !.

const n1 = !true; // !t renvoie false
const n2 = !false; // !f renvoie true
const n3 = !"Chat"; // !t renvoie false

valuation en court-circuit

Les expressions logiques tant values de gauche droite, le moteur d'excution utilise les courts-circuits dans les cas suivants :

• false && nimportequoi sera court-circuite pour tre value en false.
• true || nimportequoi sera court-circuite pour tre value en true.

Les rgles logiques garantissent la vracit de ces valuations. On notera que l'oprande nimportequoi dans les expressions prcdentes n'est pas valu et que tout effet de bord li cette valuation n'aura donc pas lieu.

Pour le deuxime exemple, on pourra utiliser l'oprateur de coalescence des nuls (??) qui fonctionne comme ||, en renvoyant uniquement la deuxime expression lorsque la premire est quivalente null, c'est--dire qu'elle vaut null ou undefined.

L'oprateur de coalescence des nuls est donc une meilleure solution lorsqu'il s'agit de fournir des valeurs par dfaut, notamment lorsque '' ou 0 sont des valeurs valides.

Oprateurs pour les grands entiers

La plupart des oprateurs numriques peuvent tre utiliss avec des valeurs de type BigInt (qui reprsentent des grands entiers).

// Addition de grands entiers
const a = 1n + 2n; // 3n

// Une division entre grands entiers est arrondie  zro
const b = 1n / 2n; // 0n

// Il n'y a pas de troncature avec les oprations binaires
const c = 40000000000000000n >> 2n; // 10000000000000000n

L'oprateur de dcalage droite non-sign (>>>) est une exception : il n'est pas dfini pour les valeurs, car les grands entiers n'ont pas une largeur binaire fixe et n'ont donc pas de bit le plus haut.

const d = 8n >>> 2n; // TypeError: BigInts have no unsigned right shift, use >> instead

Il n'est pas possible d'interchanger des nombres et des grands entiers. On ne peut pas les mlanger dans un mme calcul.

const a = 1n + 2; // TypeError: Cannot mix BigInt and other types

En effet, BigInt n'est pas un sous-ensemble ou un sur-ensemble du type numrique. Les grands entiers ont une plus grande prcision mais ne peuvent pas reprsenter de nombres dcimaux. Toute conversion implicite dans un sens ou l'autre entranerait une perte de prcision. Il faudra utiliser une conversion explicite pour indiquer avec quel type on souhaite effectuer l'opration.

const a = Number(1n) + 2; // 3
const b = 1n + BigInt(2); // 3n

Il est aussi possible de comparer des grands entiers avec des nombres.

const a = 1n > 2; // false
const b = 3 > 2n; // true

Oprateurs pour les chanes de caractres

En complment des oprateurs de comparaison qui peuvent tre utiliss avec les chanes de caractres, on peut galement utiliser l'oprateur de concatnation (+) afin de concatner deux chanes de caractres ensemble et renvoyer le rsultat de cette concatnation.

Ainsi :

console.log("ma " + "chane"); // affichera "ma chane" dans la console.

L'oprateur d'affectation raccourci += peut galement tre utilis pour concatner des chanes.

Par exemple :

let maChaine = "alpha";
maChaine += "bet"; // sera valu en "alphabet" et affectera cette valeur  maChaine.

Oprateur conditionnel (ternaire)

L'oprateur conditionnel est le seul oprateur JavaScript prendre trois oprandes. Il permet de se rsoudre en une valeur ou en une autre selon une condition donne. Sa syntaxe est la suivante :

condition ? val1 : val2;

Si condition est vraie, l'expression sera rsolue avec la valeur de val1. Sinon, elle sera rsolue avec la valeur de val2. L'oprateur conditionnel peut tre utilis tout endroit o un oprateur standard peut tre utilis.

Par exemple :

const statut = age >= 18 ? "adulte" : "mineur";

Cette instruction affecte la valeur "adulte" la variable statut si age est suprieur ou gal 18. Sinon, c'est la valeur "mineur" qui est affecte statut.

Oprateur virgule

L'oprateur virgule (,) value les deux oprandes et renvoie la valeur du dernier oprande. Cet oprateur est gnralement utilis dans les boucles for afin de mettre jour plusieurs variables chaque itration de la boucle. L'utiliser ailleurs est considr comme une mauvaise pratique et on privilgiera plusieurs instructions spares.

Par exemple, si on a a qui est un tableau en deux dimensions avec 10 lments pour chaque ligne. Le code qui suit utilise l'oprateur virgule afin de mettre jour deux variables la fois. Dans cet exemple, on affiche les valeurs des lments situs sur la diagonale du tableau :

const x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
const a = [x, x, x, x, x];

for (let i = 0, j = 9; i <= j; i++, j--) {
  //                              ^
  console.log(`a[${i}][${j}]= ${a[i][j]}`);
}

Oprateurs unaires

Un oprateur unaire fonctionne avec un seul oprande.

delete

L'oprateur delete permet de supprimer une proprit d'un objet. La syntaxe correspondante est :

delete objet.propriete;
delete objet[clePropriete];
delete objet[indice];

O objet est le nom d'un objet, propriete est une proprit existante, clePropriete est une chane de caractres ou un symbole faisant rfrence une proprit existante.

Lorsque l'oprateur delete russit, la proprit est supprime de l'objet et toute tentative d'accs ultrieur renverra undefined. L'oprateur delete renvoie true si l'opration est possible et false sinon.

delete Math.PI; // renvoie false (on ne peut pas supprimer des proprits non-configurables)

const monObj = { h: 4 };
delete monObj.h; // renvoie true (on peut supprimer des proprits personnalises)

Supprimer des lments de tableau

Comme les tableaux sont galement des objets, il est techniquement possible de supprimer des lments avec delete. Il s'agit toutefois de quelque chose considr comme une mauvaise pratique. En effet, lorsqu'on supprime une proprit d'un tableau, la longueur n'est pas modifie et les autres lments ne sont pas rindexs. Pour un comportement analogue, mieux vaudra rcrire la valeur de l'lment avec undefined. Pour manipuler un tableau, on utilisera plutt les mthodes associes comme splice().

typeof

L'oprateur typeof s'utilise de la faon suivante :

typeof operande;

L'oprateur typeof renvoie une chane de caractres qui indique le type de l'oprande non-valu. operande est une chane de caractres, une variable, un mot-cl ou un objet dont on souhaite connatre le type. On peut utiliser des parenthses autour de l'oprande.

Prenons la dfinition des variables suivantes :

const maFonction = new Function("5 + 2");
const forme = "rond";
const taille = 1;
const toto = ["Pomme", "Mangue", "Orange"];
const jour = new Date();

L'oprateur typeof renvoie les rsultats suivants pour ces diffrentes variables :

typeof maFonction; // renvoie "function"
typeof forme; // renvoie "string"
typeof taille; // renvoie "number"
typeof toto; // renvoie "object"
typeof jour; // renvoie "object"
typeof inexistant; // renvoie "undefined"

Pour les mots-cls true et null, l'oprateur typeof renvoie les rsultats suivants :

typeof true; // renvoie "boolean"
typeof null; // renvoie "object"

Pour un nombre ou une chane de caractres, typeof renverra les rsultats suivants :

typeof 62; // renvoie "number"
typeof "Coucou monde"; // renvoie "string"

Pour les valeurs qui sont des proprits, typeof renvoie le type de la valeur contenue dans la proprit :

typeof document.lastModified; // renvoie "string"
typeof window.length; // renvoie "number"
typeof Math.LN2; // renvoie "number"

Pour les mthodes et fonctions, typeof renverra les rsultats suivants :

typeof blur; // renvoie "function"
typeof eval; // renvoie "function"
typeof parseInt; // renvoie "function"
typeof shape.split; // renvoie "function"

Pour les objets natifs, typeof renverra les rsultats suivants :

typeof Date; // renvoie "function"
typeof Function; // renvoie "function"
typeof Math; // renvoie "object"
typeof Option; // renvoie "function"
typeof String; // renvoie "function"

void

L'oprateur void s'utilise d'une des deux faons suivantes :

void (expression)
void expression

L'oprateur void indique une expression valuer sans renvoyer de valeur. expression est une expression JavaScript valuer. Les parenthses autour de l'expression sont optionnelles, mais c'est une bonne pratique que de les utiliser.

Oprateurs relationnels

Un oprateur relationnel compare ses oprandes et renvoie une valeur boolenne selon le rsultat de la comparaison.

in

L'oprateur in renvoie true si la proprit indique par l'oprande gauche est prsente dans l'objet indiqu par l'oprande droit. La syntaxe est la suivante :

nomPropriete in nomObjet;

o nomPropriete est une chane de caractres, une valeur numrique ou un symbole reprsentant une proprit, et nomObjet est le nom de l'objet.

Voici quelques exemples utilisant l'oprateur in.

// Tableaux
const arbres = ["squoia", "laurier", "cdre", "chne", "rable"];
0 in arbres; // renvoie true
3 in arbres; // renvoie true
6 in arbres; // renvoie false
"squoia" in arbres; // renvoie false (il faut indiquer l'indice, pas la
// valeur)
"length" in arbres; // renvoie true (length est une proprit native)

// Objets natifs
"PI" in Math; // renvoie true
const maChaine = new String("corail");
"length" in maChaine; // renvoie true

// Objets personnaliss
const maVoiture = { fabricant: "Honda", modele: "Accord", annee: 1998 };
"fabricant" in maVoiture; // renvoie true
"modele" in maVoiture; // renvoie true

instanceof

L'oprateur instanceof renvoie true si l'objet port par l'oprande gauche est du type indiqu par l'oprande droit. La syntaxe est :

nomObjet instanceof typeObjet;

o nomObjet est le nom de l'objet dont on souhaite vrifier le type et typeObjet est le type en question, comme Date ou Array.

On utilisera instanceof lorsqu'on souhaite confirmer le type d'un objet l'excution. On pourra par exemple grer diffremment une exception selon son type.

Dans l'exemple qui suit, on utilise instanceof pour dterminer si jour est un objet Date. Comme jour est bien un objet de type Date, les instructions conditionnelles sont excutes.

const jour = new Date(1995, 12, 17);
if (jour instanceof Date) {
  // instructions  excuter
}

Expressions de base

Tous les oprateurs manipulent en fin de compte une ou plusieurs expressions de base. Ces expressions de base utilisent les identifiants et les littraux, et quelques autres lments que nous introduisons ci-aprs. Ils sont dcrits plus en dtails dans leur page de rfrence.

this

Le mot-cl this fait rfrence l'objet courant. En gnral, this fait rfrence l'objet appelant d'une mthode. this pourra tre utilis avec la notation utilisant le point ou celle utilisant les crochets :

this["nomPropriete"];
this.nomPropriete;

Prenons une fonction valider() qui valide la proprit value d'un objet en fonction d'un minimum et d'un maximum :

function valider(obj, min, max) {
  if (obj.value < min || obj.value > max) {
    console.log("Valeur invalide !");
  }
}

On peut appeler valider() pour un lment de formulaire sur le gestionnaire d'vnement onChange en utilisant this afin de passer le contrle du formulaire :

<p>Saisissez un nombre entre 18 et 99 :</p>
<input type="text" name="age" size="3"  />

Oprateur de groupement

L'oprateur de groupement, ( ), contrle la prcdence de l'valuation dans une expression. On peut ainsi prioriser certaines oprations par rapport d'autres et passer outre la prcdence par dfaut. Dans l'exemple qui suit, on utilise les parenthses pour que l'addition ait lieu avant la multiplication.

const a = 1;
const b = 2;
const c = 3;

// Prcdence par dfaut
a + b * c; // 7
// Qui est value par dfaut comme
a + (b * c); // 7

// On passe outre cette prcdence pour
// additionner avant de multiplier
(a + b) * c; // 9

// Ce qui est quivalent 
a * c + b * c; // 9

new

L'oprateur new peut tre utilis afin de crer une instance d'un objet (que ce type d'objet soit dfini dans le script ou par l'environnement d'excution). On utilisera new comme suit :

const nomObjet = new TypeObjet(param1, param2, /* , */ paramN);

super

Le mot-cl super est utilis pour appeler des fonctions sur le parent d'un objet. Il est utile lorsqu'on manipule des classes afin d'appeler le constructeur parent par exemple.

super([arguments]); // On appelle le constructeur parent.
super.fonctionSurLeParent([arguments]);

• Prcdent
• Suivant