Opérateurs unaires ECMAScript

一元运算符只有一个参数，即要操作的对象或值。它们是 ECMAScript 中最简单的运算符。

delete

delete 运算符删除对以前定义的对象属性或方法的引用。例如：

var o = new Object;
o.name = "David";
alert(o.name); //输出 "David"
delete o.name;
alert(o.name); // Affiche "undefined"

Dans cet exemple, la suppression de la propriété name signifie que la référence à cette propriété est forcée, et elle est définie sur undefined (c'est-à-dire la valeur de la variable non initialisée créée).

L'opérateur delete ne peut pas supprimer les propriétés et méthodes non définies par le développeur. Par exemple, le code suivant déclenche une erreur :

delete o.toString;

Même si toString est un nom de méthode valable, cette ligne de code déclenche une erreur, car la méthode toString() est une méthode ECMAScript primitive, et non définie par le développeur.

void

L'opérateur void renvoie undefined pour toute valeur. Cet opérateur est généralement utilisé pour éviter l'affichage de valeurs qui ne devraient pas être affichées, par exemple, lors de l'appel d'une fonction JavaScript à partir d'un élément HTML <a>. Pour le faire correctement, la fonction ne doit pas renvoyer de valeur valable, sinon le navigateur effacera la page et ne montrera que le résultat de la fonction. Par exemple :

<a href="javascript:window.open('about:blank')">Cliquez ici</a>

Si vous placez cette ligne de code dans une page HTML, en cliquant sur le lien, vous verrez "[object]" affiché à l'écran.TIY

Cela est dû au fait que la méthode window.open() renvoie une référence à la fenêtre ouverte. Ensuite, cet objet sera converti en une chaîne à afficher.

Pour éviter cet effet, vous pouvez appeler la fonction window.open() avec l'opérateur void :

<a href="javascript:void(window.open('about:blank'))">Cliquez ici</a>

Cela rend la fonction window.open() renvoyer undefined, ce qui n'est pas une valeur valable, et ne sera pas affiché dans la fenêtre du navigateur.

Astuce :Rappelez-vous, toutes les fonctions sans valeur de retour retournent réellement undefined.

Opérateurs préfixe/increment/décrement

Les deux opérateurs empruntés directement à C (et Java) sont les opérateurs d'incrémentation et de décrémentation préfixés.

L'opérateur d'incrémentation préfixée, c'est-à-dire l'augmentation de la valeur de 1, sous la forme de deux plus (+) avant la variable (++) :

var iNum = 10;
++iNum;

La deuxième ligne de code augmente iNum à 11, ce qui est équivalent en réalité à :

var iNum = 10;
iNum = iNum + 1;

De même, l'opérateur de décrémentation préfixée diminue la valeur de 1, sous la forme de deux tirets avant la variable (--):

var iNum = 10;
--iNum;

Dans cet exemple, la deuxième ligne de code réduit la valeur de iNum à 9.

Lors de l'utilisation des opérateurs préfixés, notez que les opérations d'augmentation et de diminution ont lieu avant le calcul de l'expression. Considérez l'exemple suivant :

var iNum = 10;
--iNum;
alert(iNum);	// affiche "9"
alert(--iNum);	// affiche "8"
alert(iNum);	// affiche "8"

La deuxième ligne de code effectue une opération de décrémentation sur iNum, la troisième ligne affiche le résultat ("9"). La quatrième ligne effectue à nouveau une opération de décrémentation sur iNum, mais cette fois, l'opération de décrémentation préfixée et l'opération d'output apparaissent dans la même instruction, le résultat affiché est "8". Pour prouver que toutes les opérations de décrémentation ont été réalisées, la cinquième ligne de code affiche à nouveau "8".

Dans l'expression arithmétique, la priorité des opérateurs pré-incrément et pré-décrément est la même, donc ils doivent être calculés dans l'ordre de gauche à droite. Par exemple :

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = --iNum1 + ++iNum2;	// égale à "22"
var iNum4 = iNum1 + iNum2;		// égale à "22"

Dans le code précédent, iNum3 vaut 22, car l'expression à calculer est 1 + 21. La variable iNum4 vaut également 22, c'est aussi 1 + 21.

Opérateurs post-incrément/post-décrément

Il existe également deux opérateurs empruntés directement à C (et Java), à savoir l'opérateur d'incrémentation postérieure et l'opérateur de décrémentation postérieure.

L'opérateur d'incrémentation postérieure ajoute également 1 à la valeur, sous la forme de deux plus (+) après la variable :

var iNum = 10;
iNum++;

Comme prévu, l'opérateur de décrémentation postérieure réduit également la valeur de 1, sous la forme de deux tirets (--) après la variable :

var iNum = 10;
iNum--;

La deuxième ligne de code réduit la valeur de iNum à 9.

Contrairement aux opérateurs préfixés, les opérateurs postfixés effectuent l'incrémentation ou la décrémentation après avoir calculé l'expression qui les contient. Considérez l'exemple suivant :

var iNum = 10;
iNum--;
alert(iNum);	// affiche "9"
alert(iNum--);	// affiche "9"
alert(iNum);	// affiche "8"

Comme dans l'exemple des opérateurs préfixés, la deuxième ligne de code effectue une opération de décrémentation sur iNum, la troisième ligne affiche le résultat ("9"). La quatrième ligne continue d'afficher la valeur de iNum, mais cette fois, l'opérateur de décrémentation est appliqué dans la même instruction. Comme la décrémentation postérieure se produit après l'évaluation de l'expression, cette instruction affiche le nombre "9". Après l'exécution de la cinquième ligne de code, la fonction alerte affiche "8", car une opération de décrémentation postérieure a été exécutée entre l'exécution de la quatrième ligne de code et l'exécution de la cinquième ligne de code.

Dans l'expression arithmétique, la priorité des opérateurs post-incrément et post-décrément est la même, donc ils doivent être calculés dans l'ordre de gauche à droite. Par exemple :

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = iNum1-- + iNum2++;	// égale à "22"
var iNum4 = iNum1 + iNum2;		// égale à "22"

Dans le code précédent, iNum3 vaut 22 car l'expression doit calculer 2 + 20. La variable iNum4 vaut également 22, mais elle calcule 1 + 21, car les opérations d'augmentation et de diminution ont lieu après l'affectation de iNum3.

Addition et soustraction unaires

La plupart des gens sont familiers avec l'addition et la soustraction unaires, leurs utilisations dans ECMAScript sont similaires à celles que vous avez apprises au lycée en mathématiques.

L'addition unaire n'a aucun effet sur les nombres en soi :

var iNum = 20;
iNum = +iNum;
alert(iNum);	//Affiche "20"

Ce code applique l'opérateur d'addition unaire au nombre 20, et le résultat est toujours 20.

Bien que l'opérateur d'addition unaire n'ait aucun effet sur les nombres, il a des effets intéressants sur les chaînes, convertissant les chaînes en nombres.

var sNum = "20";
alert(typeof sNum);	//Affiche "string"
var iNum = +sNum;
alert(typeof iNum);	//Affiche "number"

Ce code convertit la chaîne "20" en un nombre réel. Lorsque l'opérateur d'addition unaire opère sur une chaîne, il calcule la chaîne de la même manière que parseInt(), la principale différence étant que seules les chaînes commençant par "0x" (représentant des nombres hexadécimaux) peuvent être converties en valeurs décimales par les opérateurs unaires. Par conséquent, en convertissant "010", on obtient toujours 10, tandis que "0xB" est converti en 11.

D'autre part, la soustraction unaire consiste à obtenir le négatif d'un nombre (par exemple, convertir 20 en -20) :

var iNum = 20;
iNum = -iNum;
alert(iNum);	//Affiche "-20"

De la même manière que l'opérateur d'addition unaire, l'opérateur de soustraction unaire convertit également les chaînes en nombres approximatifs et calcule le négatif de cette valeur. Par exemple :

var sNum = "20";
alert(typeof sNum);	//Affiche "string"
var iNum = -sNum;
alert(iNum);		//Affiche "-20"
alert(typeof iNum);	//Affiche "number"

Dans le code ci-dessus, l'opérateur de soustraction unaire convertit la chaîne "-20" en -20 (l'opérateur de soustraction unaire traite les valeurs hexadécimales et décimales de la même manière que l'opérateur d'addition unaire, mais il calcule également le négatif de cette valeur).