Passionnés d'informatique depuis 1990

Le javascript 3

Par le 30 juin 2004 dans nihil | 0 comments

|  Présentation | Données | Opérateurs Instructions |

 

Les Opérateurs de comparaison

Ces opérateurs renvoient une valeur true ou false. Les opérandes peuvent être des nombres ou des chaînes. Les nombres sont comparés numériquement, les chaînes alphabétiquement.

a == b
a égale b ?
a != b
a différent de b ?
a === b
a strictement égal à b ? (opérandes
égaux et du même type)
a !== b
a non strictement égal à b ? (vrai
si valeur ou type différents)
a > b
a supérieur à b ?
a >= b
a supérieur ou égal à b ?
a < b
a inférieur à b ?
a <= b
a inférieur ou égal à b ?

 

Les Opérateurs arithmétiques

Les quatre opérateurs fonctionnent de manière classique :

+ addition,

- soustraction,

* multiplication

/ division (toujours à virgule flottante, jamais entière)

Les autres opérateurs sont :

% modulo, deux arguments, reste de la division entière

++ incrément, un argument, préfixe ou postfixe

– décrément, un argument, préfixe ou postfixe

- opposé, un argument, préfixe

 

Les Opérateurs bit à bit

Les opérateurs bit à bit considèrent leurs opérandes comme des mots de 32 bits, mais retournent des valeurs numériques standard :

& ET logique, bit à bit

| OU logique, bit à bit

^ OU exclusif, bit à bit

~ complément bit à bit

<< décalage à gauche (on rentre des zéros à droite)

>> décalage à droite (bit de signe conservé)

>>> décalage à droite (on rentre des zéros à gauche)

Exemple : 3 << 2 donne 12

Les Opérateurs logiques

Les opérateurs logiques portent sur des variables booléennes. Toutefois leur évaluation est inhabituelle :

a && b
ET logique, ( a == false ) ? a : b
a || b
OU logique, (a == true ) ? a : b
! a
NON logique, ( a == true) ? false : true

N.B. == s’interprète de fait comme “peut être converti en”. Par conséquent, si les opérateurs && et || sont appliqués à des variables booléennes, ils retournent un booléen conforme au résultat attendu. S’ils sont appliqués à des variables non booléennes le résultat est non booléen :

par exemple : 1 && “Hello” vaut “Hello”

 

Les Opérateurs logiques

L’évaluation des expressions logiques est interrompue dès que la valeur du résultat est connu. Dans l’expression ci-dessous, la fonction essai( ) n’est pas appelée :

art = false;

x = art && essai();

De même, dans la situation suivante la fonction la_vie ( ) n’est pas appelée :

la_bourse = true;

y = la_bourse || la_vie();

Ce comportement est garanti. Il fait partie des spécifications du langage.

caractères spéciaux :

\b backspace \’ apostrophe
simple
\f form feed \” apostrophe double
\n new line \040 code octal (ici espace)
\r carriage return \0×20 code hexadecimal (ici space)
\t tab

 

Les Autres opérateurs

S’il est utilisé dans un contexte où l’un au moins des opérandes est une chaîne, + est interprété comme étant l’opérateur de concaténation :

“Pi vaut : ” + 3.141592 + ” (ou à
peu près)”
est une chaîne.

? est le seul opérateur JavaScript à admettre
trois arguments :

condition ? val1 : val2

vaut val1 si condition est vraie (true), val2 sinon.

L’opérateur , (virgule) évalue ses deux opérandes et retourne le second (principalement utilisé avec l’instruction de boucle for).

i=1, j=2

for(i=1, j=2; i++, j++; i<10)

 

L’opérateur typeof

L’opérateur typeof renvoie le type de la variable ou de l’expression à laquelle il s’applique :

var pi = 3.141592;

var str = “Coucou”;

var now = Date();

var check = “typeof pi : ” + typeof(pi) + “\n”

+ “typeof str : ” + typeof(str) + “\n”

+ “typeof now : ” + typeof(now) + “\n”

+ “typeof foo : ” + typeof(foo) + “\n”;

Le type d’un objet non défini est undefined

 

Les Opérateurs d’affectation

Un opérateur d’affectation affecte la valeur de l’opérande situé à sa droite (généralement une expression) à l’opérande situé à sa gauche (généralement une variable). L’opérateur d’affectation le plus simple est ‘=’ :

x = y affecte la valeur de y à la variable x.

Les autres opérateurs d’affectation sont en fait des raccourcis pour quelques opérations standards :

 

x += y
x = x + y
x >>= y
x = x >> y
x -= y
x = x – y
x >>>= y
x = x >>> y
x *= y
x = x * y
x &= y
x = x & y
x /= y
x = x / y
x |= y
x = x | y
x %= y
x = x % y
x ^= y
x = x ^ y
x <<= y
x = x << y

 

La Précédence des opérateurs

La précédence des opérateurs donne l’ordre de priorité dans lequel ils sont évalués. Cet ordre permet d’écrire des expressions comme :

x = a + b * c - d == 23 ? 1 : ++j, ++i;

et d’obtenir le résultat escompté, qui est :

(x = (((a+(b*c)-d== 23) ? 1 : ++j)),++i;

Un conseil : il est plus sûr, plus rapide et plus efficace de spécifier l’ordre de priorité des opérations à effectuer à l’aide de parenthèses bien placées (même si celles-ci sont éventuellement inutiles) que de consulter la documentation relative à la précédence des opérateurs et d’accoucher d’une séquence de code illisible et non maintenable …