|
17.4 opérateurs inconnus jusqu'ici |
  copyleftSee You Why? |
| | exercices relatifs aux conditions complexes (17.8) 
Notre but ne sera rien d'autre que de vous initier rapidement à chacun des opérateurs que nous n'avons pas encore rencontrés jusqu'ici, soit pour que vous ne soyez pas désarçonnés au cas où vous en croiseriez un, soit pour vous renvoyez à d'autres séquences ou chapitres qui en feront mieux état.
Pour plus d'informations, nous renvoyons le lecteur aux chapitres relatifs aux objets (chap. 23 et suivants).
Deux opérateurs sont considérés dans ce point de chapitre, le point (.) et les crochets ([]). Nous y découvrirons qu'il existe une hiérarchie entre les objets et que nous pourrons écrire :
window.document.forms["formul2"].champ_text.value
qui se lira :
"la valeur du texte associé au champ de texte nommé « champ_text »
dans le formulaire nommé « formul2 »)
de la page web en cours « document », à savoir ici « jvs_174_oper_inconnus.html »
de la fenêtre active « window »"
Les bons Belges reconnaitront ici le sens du néerlandais "VAN DE"...
La notation point . qui sépare chaque objet indique bien son appartenance à l'objet qui le précède, comme s'il en était un membre ou une propriété propre, voire même une méthode (disons, pour l'instant, une fonction propre)... certains vont jusqu'à parler de classe, mais nous expliquerons plus loin pourquoi cette dénomination nous semble impropre.
Lorsque nous parlerons d'objets particuliers, appelés tableaux, nous utiliserons aussi souvent la notation crochets [],
tantôt pour créer un objet : var pays_ce=[Allemagne,Berlin,81471834,357026,DE],
tantôt pour désigner un de ces éléments par un indice chiffré : document.write(pays_ce[0]);
tantôt encore pour lui attribuer une propriété : pays_ce["capitale"] = "Berlin";
Rendez-vous pour la suite au chapitre 26, relatif aux tableaux.
Pour plus d'informations, nous renvoyons encore le lecteur aux chapitres relatifs aux objets (chap. 23 et suivants).
Nous y verrons que l'opérateur new remplira différentes fonctions :
var obj = new Object; : les parenthèses ne sont pas obligatoires ici, mais elles sont conseilléesvar nu = new Date(); : lesvar rect1 = new oRectangle(3.0, 4.0, 1.5, 2.75); si le constructeur a prévu de définir un oRectangle par les abscisses et ordonnées de deux sommets opposés ouvar oVipap = new oBouquin("Vipère au poing","Hervé Bazin"); si le constructeur a prévu de définir un oBouquin parfunction oBouquin(tit,aut) { // définition d'un constructeur
this.titre = tit;
this.auteur = aut;
}
Un des rôles des parenthèses est d'appeler une fonction pour l'exécuter. Attention, ces parenthèses doivent être collées au nom de la fonction qui les précède, sans espace. Écrire maFonction(arguments) c'est appeler une fonction soit prédéfinie, soit définie par ailleurs ; c'est donc exécuter la liste d'instructions définies dans le corps (nous l'avons appelé la définition de la fonction, voir ici).
L'opérateur () peut aussi avoir d'autres rôles :
resultat = (a + b) * c; qui n'affichera pas la même chose que res2 = a + b * c ;for (x=9;x<87;x++) ou vv.Rappelons ici que l'opérateur (), considéré comme appel de fonction, aura deux opérandes :
* une première obligatoire à placer juste avant les parenthèses : le nom de la fonction, ici maFonction;
* une deuxième facultatif à placer entre les parenthèses : une liste de un ou plusieurs arguments, séparés par des virgules.
Plusieurs tutoriels se contententent d'opposer les opérateurs binaires aux opérateurs unaires ou tertiaires, ne tenant compte que du nombre d'opérande(s). Il s'agit là d'un raccourci un peu enfantin, puisqu'il faut comprendre que l'algèbre binaire opère en base 2 ou binaire, comme nous opérons généralement en base 10 ou décimale.
Commençons par développer cette approche enfantine :
Une approche plus correcte consiste à dire que les opérateurs binaires traitent leurs opérandes comme des séquences de 32 bits (zéros et uns, les deux seuls chiffres du binaire), plutôt que comme des nombres décimaux, hexadécimaux ou octaux.
Par exemple, le nombre décimal 11 (onze) a une représentation binaire de 1011.
Les opérateurs binaires traitent de telles représentations binaires.
Avant de poursuivre, nous voulons informer nos lecteurs que la maitrise des opérateurs binaires ne nous parait pas du tout fondamentale pour la bonne utilisation du JavaScript... elle le serait peut-être un peu plus pour d'autres langages. À bon entendeur...
Nous aborderons ici :
* la numérotation en base deux ou système binaire ;
* les entiers 32 bits signés ;
* les opérateurs binaires bit à bit ;
* les opérateurs binaires sur opérandes.
Rappelons ici l'essentiel du système binaire ou système en base deux (abordé dans notre tutoriel HTML pour déterminer les couleurs).
|
|
|
|
0 |
0001 0010 0011 0100 0101 0110 0111 1000 1001 |
|
11 12 13 14 15 |
1011 1100 1101 1110 1111 |
|
17 18 19 20 21 22 23 24 ... 31 |
1 0001 1 0010 1 0011 1 0100 1 0101 1 0110 1 0111 1 1000 ... 1 1111 |
|
33 ... 47 48 ... 63 |
10 0001 ... 10 1111 11 0000 ... 11 1111 |
|
... 79 80 ... 127 |
... 100 1111 101 0000 ... 111 1111 |
|
... 159 160 ... 255 |
... 1001 1111 1010 0000 ... 1111 1111 |
|
... 511 |
... 1 1111 1111 |
|
... 1023 |
... 11 1111 1111 |
|
|
|
| diviser par 2 (sans reste) | reste de la division par 2 | puissance de 2 |
| 142 71 35 17 8 4 2 1 |
0 1 1 1 0 0 0 1 |
1 2 4 8 16 32 64 128 |
| Valeur décimale | Valeur binaire | Valeur binaire en 8 bits |
|
1 2 3 4 5 6 7 8 9 ... 254 255 |
1 10 (2 et 0) 11 (2 et 1) 100 (4, 0 et 0) 101 (4, 0 et 1) 110 (4, 2 et 0) 111 (4, 2 et 1) 1000 (8, 0, 0 et 0) 1001 (8, 0, 0 et 1) ... 11111110 (128, 64, 32, 16, 8, 4 et 2) 11111111 (128, 64, 32, 16, 8, 4 , 2 et 1) |
0000 0001 0000 0010 0000 0011 0000 0100 0000 0101 0000 0110 0000 0111 0000 1000 0000 1001 ... 11111110 11111111 |
En informatique on utilise l’octet qui équivaut à 8 bits : de 00000000 à 11111111, soit 256 combinaisons de bits ;
en JS, le système binaire utilisé travaille sur 32 bits ou 4 octets, soit 232 ou 4 294 967 296 combinaisons possibles.
Comme les multiples binaires sont des puissances de deux,
· un kilo-octet (Ko) = 1024 octets (et non 1000),
· un méga-octet (Mo) = 1024 Ko, (ou 1 048 576 octets et non 1 million),
· un giga-octet (Go) = 1024 Mo (ou 1 073 741 824 octets et non 1 milliard),
· un tera-octet (To) = 1024 Go (ou 1 099 511 627 776 octets et non 1000 milliards).
Pour la suite retenons que d142 (142 en décimal) s'écrit 10001110 sur 8 bits ou 0000000010001110 sur 16 bits... nous ne présenterons pas la version 32 bits pour le simple plaisir d'avoir des zéros en plus.
Le lecteur un peu attentif aura réagi en mettant en évidence que la description du système binaire faite ci-dessus ne peut générer que des nombres entiers positifs d'une valeur maximale de 4 294 967 296... et quid des entiers négatifs alors ? et quid des valeurs décimales (avec virgules) ? Notre but n'est pas ici de développer toutes les tentatives qui ont été faites pour l'encodage des nombres, mais nous voudrions bien survoler quelques difficultés rencontrées avant de poursuivre notre algèbre, notre logique et nos opérateurs binaires.
Une solution rapidement envisagée était de consacrer un bit pour le signe et de stocker la valeur sur les 31 bits restants. Cette solution fut vite abandonnée, car elle ne permettait pas d'additionner correctement et rapidement des valeurs de signe contraire.
Les informaticiens ont préféré utiliser ce qu'on appelle le complément à 1 ou appliquer l'opérateur binaire NON (~) qui consiste à inverser l'ensemble des bits de l'opérande, auquel on ajoute un pour avoir le complément à deux qui sera le négatif du nombre de départ :
| valeur décimale | valeur binaire sur 16 bits |
| 142 | 0000000010001110 |
| complément à un : ~142 | 1111111101110001 |
| complément à deux : -142 | 1111111101110010 |
Observons :
Ces quelques explications vont vous permettre de partager vos connaissances en informatique en société... vous pourrez dire "Les opérandes de tous les opérateurs binaires sont convertis en entiers 32-bits signés en ordre big-endian et en format de complément à deux" et d'expliquer si on vous le demande ;o)
Nous distinguerons les opérations bit à bit avant d'aborder les opérateurs qui agissent sur un ou plusieurs octets.
|
|
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Dès l'instant où les opérations sur bit sont assimilées, le lecteur n'aura aucune difficulté à comprendre la logique binaire sur opérandes (à 32 bits en JS). En effet, les opérateurs logiques binaires fonctionnent de la manière suivante :
* Les opérandes sont convertis en entiers 32 bits et sont exprimés sous la forme d'une série de bits (zéros et uns).
* Chaque bit du premier opérande est combiné avec le bit correspondant du second opérande :
le premier bit avec le premier bit, le second bit avec le second bit, et ainsi de suite.
* L'opérateur est appliqué à chaque paire de bits, et le résultat est construit bit après bit.
| Opérateur | Utilisation | Description |
|---|---|---|
| ET binaire | a & b |
Renvoie un 1 pour chaque position de bit pour laquelle les bits correspondants des deux opérandes sont des 1. |
| OU inclusif binaire | a | b |
Renvoie un 1 pour chaque position de bit pour laquelle le bit correspondant d'au moins un des deux opérandes est un 1. |
| OU exclusif binaire (XOR) | a ^ b |
Renvoie un 1 pour chaque position de bit pour laquelle le bit correspondant d'un seul des deux opérandes est un 1. |
| NON binaire | ~ a |
Inverse les bits de son opérande. |
| Décalage ŕ gauche | a << b |
Décale a en représentation binaire de b bits vers la gauche, en introduisant des zéros par la droite. |
| Décalage ŕ droite avec propagation du signe | a >> b |
Décale a en représentation binaire de b bits vers la droite, en introduisant le bit de signe ŕ gauche. |
| Décalage ŕ droite non signé avec introduction de zéros | a >>> b |
Décale a en représentation binaire de b bits vers la droite, en rejetant les bits ŕ droite et en introduisant des zéros par la gauche. |
on constatera que 142&9 = 8
| valeur décimale | valeur binaire sur 16 bits |
| 142 | 0000000010001110 |
| 9 | 0000000000001001 |
| 142&9 = 8 | 0000000000001000 |
on constatera que 142|9 = 143
| valeur décimale | valeur binaire sur 16 bits |
| 142 | 0000000010001110 |
| 9 | 0000000000001001 |
| 142|9 = 143 | 0000000010001111 |
on constatera que 142^9 = 135
| valeur décimale | valeur binaire sur 16 bits |
| 142 | 0000000010001110 |
| 9 | 0000000000001001 |
| 142^9 = 135 | 0000000010000111 |
Utiliser le NON binaire avec n'importe quel nombre x positif donne -(x + 1)
| valeur décimale | valeur binaire sur 16 bits |
| 142 | 0000000010001110 |
| complément à un : ~142 = -143 | 1111111101110001 |
Utiliser a>>b revient à diviser par 2b sans tenir compte des décimales, en effet 142/8 = 17,... car 142>> 71>> 35>> 17 (soit d16+d1) :
| valeur décimale | valeur binaire sur 16 bits |
| 142 | 0000000010001110 |
| 142>>3 = 17 | 0000000000010001 |
Utiliser a<<b revient à multiplier par 2b. On constate en effet que 142*4 = 568, car 142<< 284<< 568
| valeur décimale | valeur binaire sur 16 bits |
| 142 | 0000000010001110 |
| 142<<2 = 568 | 0000001000111000 |
Avec un nombre positif, >>> agit comme >>,
| valeur décimale | valeur binaire sur 16 bits |
| 142 | 0000000010001110 |
| 142>>>3 = 17 | 0000000000010001 |
Avec un nombre négatif, non
| valeur décimale | valeur binaire sur 16 bits |
| 142 | 0000000010001110 |
| ~142 = -143 | 1111111101110001 |
| -143>>>3 = 8174 | 0001111111101110 |
L'opérateur virgule ',' est le dernier dans l'ordre de précédence et est malheureusement rarement documenté valablement.
Mozilla nous donne l'explication suivante : "L'opérateur virgule (,) évalue simplement ses deux opérandes et renvoie la valeur de la deuxième. Cet opérateur est employé principalement à l'intérieur des boucles for, pour pouvoir mettre à jour plusieurs variables à chaque itération de la boucle. À titre d'exemple, si a est un tableau à 2 dimensions avec 10 éléments par côté, le code suivant utilise l'opérateur virgule pour incrémenter deux variables à la fois. Ainsi, le code peut afficher les valeurs des éléments présents sur la diagonale du tableau :"[1]
et d'llustrer son propos par :
for (var i = 0, j = 9; i <= 9; i++, j--) {
document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);
}
Microsoft se contente de ce court commentaire : "L'opérateur , entraîne l'exécution des expressions de gauche à droite. L'opérateur , est souvent utilisé dans l'expression d'incrémentation d'une boucle for. [...] L'instruction for autorise l'exécution d'une seule expression à la fin de chaque passage dans la boucle. L'opérateur , permet de traiter plusieurs expressions comme une expression simple. De cette manière, les deux variables peuvent être incrémentées."[2]
Nous invitons le lecteur à parcourir les notes de Angus Croll qui nous ont paru assez complètes, mais un peu floues : http://javascriptweblog.wordpress.com/2011/04/04/the-javascript-comma-operator/ (visitée le 15 septembre 2013).
L'opérateur "typeof" en JavaScript vous permet de sonder le type de données de son opérande, pour savoir si une variable est une chaîne, un numérique, un booléen, un objet ou encore indéfinie si elle a été déclarée mais pas affectée.
L'opérateur "void" est employé quand une instruction est exécutée mais qu'aucune valeur ne doit être renvoyée. Relativement peu connu, l'opérateur "void" permet d'exécuter une expression JavaScript pour ensuite retourner undefined.
Peu utile quand on en est à ses premiers pas en JS.
L'opérateur "delete" peut:
* supprimer un objet,
* supprimer une propriété d'un objet ou
* supprimer un élément d'un tableau présent à un indice donné
* supprimer des variables déclarées implicitement mais pas celles déclarées avec le mot-clé var.
Attention, lorsque vous supprimez un élément d'un tableau, cet élément n'est plus dans le tableau (il devient undefined) mais la longueur du tableau n'est pas affectée...
L'opérateur "in" renvoie true si la propriété spécifiée se trouve dans l'objet spécifié ou si l'indice spécifié se trouve dans le tableau spécifié. Attention, "in" renverra false si vous essayez de trouver une valeur dans le tableau spécifié.
L'opérateur "instanceof" retourne une valeur booléenne (true ou false) indiquant si un objet est une instance d'une classe particulière.
function objTest(obj){
var i, t, s = "";
t = new Array();
t["Date"] = Date;
t["Object"] = Object;
t["Array"] = Array;
for (i in t){
if (obj instanceof t[i]) {
s += obj + " est une instance de " + i + "<br>";
} else {
s += obj + " n est pas reconnue comme instance de " + i + "<br>";
}
}
return(s);
}
var nu = new Date();
document.write(objTest(nu));
// va écrire la date du jour suivi de :
// est une instance de Date
// est une instance de Object
// n est pas reconnue comme instance de Array
L'opérateur 'this' représente l'objet en cours de manipulation dans une méthode, un constructeur d'objet ou une balise HTML. Vous en saurez plus après la lecture des chapitres 23 et suivants, relatifs aux objets.
[1] https://developer.mozilla.org/fr/docs/JavaScript_Guide/Op%C3%A9rateurs/Op%C3%A9rateurs_sp%C3%A9ciaux
[2] http://msdn.microsoft.com/fr-fr/library/9b37css7(v=vs.94).aspx
voir suite >>>
voir suite >>>
| | exercices relatifs aux conditions complexes (17.8)