JavaScript
Opérateurs Unaires

Syntaxe

• expression nulle; // évalue l'expression et rejette la valeur de retour
• + expression // Tentative de convertir une expression en nombre
• supprimer object.property; // Supprimer la propriété de l'objet
• supprimer l'objet ["propriété"]; // Supprimer la propriété de l'objet
• type d'opérande; // Retourne le type d'opérande
• ~ expression; // N'exécute PAS d'opération sur chaque bit d'expression
• !expression; // Effectue la négation logique sur l'expression
• -expression; // Expression de l'expression après la tentative de conversion en nombre

L'opérateur unaire plus (+)

Le plus unaire + précède son opérande et évalue son opérande. Il tente de convertir l'opérande en un nombre, si ce n'est déjà fait.

Syntaxe:

+expression

Résultats:

• un Number

La description

L'opérateur unaire plus ( + ) est la méthode la plus rapide (et préférée) pour convertir quelque chose en nombre.

Il peut convertir:

• représentations de chaînes d'entiers (décimaux ou hexadécimaux) et de flottants.
• booléens: true , false .
• null

Les valeurs qui ne peuvent pas être converties seront évaluées à NaN .

Exemples:

+42           // 42
+"42"         // 42
+true         // 1
+false        // 0
+null         // 0
+undefined    // NaN
+NaN          // NaN
+"foo"        // NaN
+{}           // NaN
+function(){} // NaN

Notez que la tentative de conversion d'un tableau peut entraîner des valeurs de retour inattendues.
En arrière-plan, les tableaux sont d'abord convertis en leurs représentations sous forme de chaîne:

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

L'opérateur tente alors de convertir ces chaînes en nombres:

+[]           // 0   ( === +'' )
+[1]          // 1   ( === +'1' )
+[1, 2]       // NaN ( === +'1,2' )

L'opérateur de suppression

L'opérateur delete supprime une propriété d'un objet.

Syntaxe:

delete object.property

delete object['property']

Résultats:

Si la suppression est réussie ou si la propriété n’existait pas:

• true

Si la propriété à supprimer est une propriété non configurable propre (ne peut pas être supprimée):

• false en mode non strict.
• Lance une erreur en mode strict

La description

L'opérateur de delete ne libère pas directement la mémoire. Il peut indirectement libérer de la mémoire si l'opération signifie que toutes les références à la propriété ont disparu.

delete œuvres sur les propriétés d'un objet. Si une propriété portant le même nom existe sur la chaîne prototype de l'objet, la propriété sera héritée du prototype.
delete ne fonctionne pas sur les variables ou les noms de fonctions.

Exemples:

// Deleting a property
foo = 1;              // a global variable is a property of `window`: `window.foo`
delete foo;           // true
console.log(foo);     // Uncaught ReferenceError: foo is not defined

// Deleting a variable
var foo = 1;
delete foo;           // false
console.log(foo);     // 1 (Not deleted)

// Deleting a function
function foo(){ };
delete foo;           // false
console.log(foo);     // function foo(){ } (Not deleted)

// Deleting a property
var foo = { bar: "42" };
delete foo.bar;       // true
console.log(foo);     // Object { } (Deleted bar)

// Deleting a property that does not exist
var foo = { };
delete foo.bar;       // true
console.log(foo);     // Object { } (No errors, nothing deleted)

// Deleting a non-configurable property of a predefined object
delete Math.PI;       // false  ()
console.log(Math.PI); // 3.141592653589793 (Not deleted)

L'opérateur typeof

L'opérateur typeof renvoie le type de données de l'opérande non évalué en tant que chaîne.

Syntaxe:

typeof operand

Résultats:

Voici les valeurs de retour possibles de typeof :

Le comportement inhabituel de document.all avec l'opérateur typeof provient de son utilisation antérieure pour détecter les navigateurs existants. Pour plus d'informations, voir Pourquoi document.all est-il défini, mais typeof document.all renvoie "undefined"?

Exemples:

// returns 'number'
typeof 3.14;
typeof Infinity;
typeof NaN;               // "Not-a-Number" is a "number"

// returns 'string'
typeof "";
typeof "bla";
typeof (typeof 1);        // typeof always returns a string

// returns 'boolean'
typeof true;
typeof false;

// returns 'undefined'
typeof undefined;
typeof declaredButUndefinedVariable;
typeof undeclaredVariable;
typeof void 0;
typeof document.all       // see above

// returns 'function'
typeof function(){};
typeof class C {};
typeof Math.sin;

// returns 'object'
typeof { /*<...>*/ };
typeof null;
typeof /regex/;           // This is also considered an object
typeof [1, 2, 4];         // use Array.isArray or Object.prototype.toString.call.
typeof new Date();
typeof new RegExp();
typeof new Boolean(true); // Don't use!
typeof new Number(1);     // Don't use!
typeof new String("abc"); // Don't use!

// returns 'symbol'
typeof Symbol();
typeof Symbol.iterator;

L'opérateur de vide

L'opérateur void évalue l'expression donnée, puis renvoie undefined .

Syntaxe:

void expression

Résultats:

• undefined

La description

L'opérateur void est souvent utilisé pour obtenir la valeur primitive undefined , en écrivant void 0 ou void(0) . Notez que void est un opérateur, pas une fonction, donc () n'est pas requis.

Généralement, le résultat d'une expression void et undefined peut être utilisé indifféremment.
Toutefois, dans les anciennes versions d'ECMAScript, window.undefined quelle valeur pouvait être affectée à window.undefined , et il est toujours possible d'utiliser undefined comme nom pour les variables de paramètres de fonction dans les fonctions, perturbant ainsi les autres codes reposant sur la valeur de undefined .
void donnera toujours la vraie valeur undefined .

void 0 est également couramment utilisé dans la réduction de code comme moyen plus court d'écrire undefined . En outre, il est probablement plus sûr qu'un autre code aurait pu window.undefined .

Exemples:

Retourner undefined :

function foo(){
    return void 0;
}
console.log(foo()); // undefined

Changer la valeur de undefined dans une certaine portée:

(function(undefined){
    var str = 'foo';
    console.log(str === undefined); // true
})('foo');

L'opérateur de négation unaire (-)

La négation unaire ( - ) précède son opérande et la nie après avoir tenté de la convertir en nombre.

Syntaxe:

-expression

Résultats:

• un Number

La description

La négation unaire ( - ) peut convertir les mêmes types / valeurs que l'opérateur unaire plus ( + ).

Les valeurs qui ne peuvent pas être converties seront évaluées à NaN (il n'y a pas de -NaN ).

Exemples:

-42           // -42
-"42"         // -42
-true         // -1
-false        // -0
-null         // -0
-undefined    // NaN
-NaN          // NaN
-"foo"        // NaN
-{}           // NaN
-function(){} // NaN

Notez que la tentative de conversion d'un tableau peut entraîner des valeurs de retour inattendues.
En arrière-plan, les tableaux sont d'abord convertis en leurs représentations sous forme de chaîne:

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

L'opérateur tente alors de convertir ces chaînes en nombres:

-[]           // -0  ( === -'' )
-[1]          // -1  ( === -'1' )
-[1, 2]       // NaN ( === -'1,2' )

L'opérateur NOT bitwise (~)

Le bit not NOT ( ~ ) effectue une opération NOT sur chaque bit d'une valeur.

Syntaxe:

~expression

Résultats:

• un Number

La description

La table de vérité pour l'opération NOT est:

1337  (base 10) = 0000010100111001 (base 2)
~1337 (base 10) = 1111101011000110 (base 2) = -1338 (base 10)

Un nombre par bit sur un nombre résulte en: -(x + 1) .

Exemples:

L'opérateur logique NOT (!)

L'opérateur logique NOT ( ! ) Effectue une négation logique sur une expression.

Syntaxe:

!expression

Résultats:

• un Boolean .

La description

L'opérateur logique NOT ( ! ) Effectue une négation logique sur une expression.

Les valeurs booléennes sont simplement inversées !true === false et !false === true .
Les valeurs non booléennes sont d'abord converties en valeurs booléennes, puis annulées.

Cela signifie qu'un double NOT logique ( !! ) peut être utilisé pour convertir n'importe quelle valeur en booléen:

!!"FooBar" === true
!!1 === true
!!0 === false

Ce sont tous égaux à !true :

!'true' === !new Boolean('true');
!'false' === !new Boolean('false');
!'FooBar' === !new Boolean('FooBar');
![] === !new Boolean([]);
!{} === !new Boolean({});

Ce sont tous égaux à !false :

!0 === !new Boolean(0);
!'' === !new Boolean('');
!NaN === !new Boolean(NaN);
!null === !new Boolean(null);
!undefined === !new Boolean(undefined);

Exemples:

!true         // false
!-1           // false
!"-1"         // false
!42           // false
!"42"         // false
!"foo"        // false
!"true"       // false
!"false"      // false
!{}           // false
![]           // false
!function(){} // false

!false        // true
!null         // true
!undefined    // true
!NaN          // true
!0            // true
!""           // true

Vue d'ensemble

Les opérateurs unaires sont des opérateurs avec un seul opérande. Les opérateurs unaires sont plus efficaces que les appels de fonctions JavaScript standard. De plus, les opérateurs unaires ne peuvent pas être remplacés et leur fonctionnalité est donc garantie.

Les opérateurs unaires suivants sont disponibles: