Je sais que depuis l'école, nous connaissons les opérateurs, car ils sont aussi simples que de se souvenir de l'addition (+), de la soustraction (-), de la division (/) et de la multiplication (*). Cependant, le Aujourd'hui, vous découvrirez les opérateurs utilisés par le langage de programmation JavaScript. Commençons!
Pour ce chapitre d'aujourd'hui, nous nous concentrerons sur la connaissance des opérateurs que nous ne connaissions pas dans notre vie scolaire.
opérateur d'assignation
Notez qu'une affectation = est également un opérateur. Il est répertorié dans le tableau de priorité avec la très faible priorité de 3.
Ainsi, lorsque nous attribuons une variable, comme x = 2 * 2 + 1, les calculs sont effectués en premier, puis = est évalué, stockant le résultat dans x.
soit x = 2 * 2 + 1 ; alerte(x); // 5
Il est possible d'enchaîner les tâches :
soit a, b, c; un = b = c = 2 + 2 ; alerte ); // 4 alerte( b ); // 4 alerte( c ); // 4
Les tâches enchaînées sont évaluées de droite à gauche. D'abord l'expression la plus à droite 2 + 2 est évaluée puis assignée aux variables les plus à gauche : c, b et a. Au final, toutes les variables partagent une seule valeur.
Module %
Le reste de l'opérateur (ou modulo%), a une apparence qui peut vous tromper, puisqu'il n'a rien à voir avec les pourcentages.
Le résultat de a % b est le reste de la division entière de a par b.
Par exemple:
alerte( 5 % 2 ); // 1 est le reste de 5 divisé par 2 alert( 8 % 3 ); // 2 est le reste de 8 divisé par 3 alert( 6 % 3 ); // 0 est le reste de 6 divisé par 3
exponentiation **
L'opérateur d'exponentiation ** est un ajout récent au langage JS.
Pour un entier naturel b, le résultat a ** b est multiplié par lui-même b fois.
Par exemple:
alerte( 2 ** 2 ); // 4 (2 * 2) alerte ( 2 ** 3 ); // 8 (2 * 2 * 2) alerte ( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)
L'opérateur fonctionne également pour les nombres non entiers de a et b, par exemple :
alerte( 4 ** (1/2) ); // 2 (La puissance de 1/2 est la même que celle d'une racine carrée, c'est le calcul.) alert( 8 ** (1/3) ); // 2 (la puissance de 1/3 équivaut à une racine cubique)
Augmentation Diminution
Augmenter ou diminuer un nombre de un est l'une des opérations numériques les plus courantes.
Il existe donc des opérateurs spéciaux pour cela :
Increment ++ augmente une variable de 1 :
laisser compteur = 2 ; compteur++ ; // fonctionne de la même manière que compteur = compteur + 1, mais plus court alert( compteur ); // 3
La diminution — diminue une variable de 1 :
laisser compteur = 2 ; comptoir--; // fonctionne de la même manière que compteur = compteur - 1, mais plus court alert( compteur ); // 1
Important:
L'incrément/décrément ne peut être appliqué qu'à une variable. Une tentative de l'utiliser sur une valeur comme 5++ échouera.
Les opérateurs ++ et — peuvent être placés avant ou après la variable.
Lorsque l'opérateur suit la variable, il s'agit d'une « forme suffixe » : compteur++.
La "forme de préfixe" est lorsque l'opérateur est devant la variable : ++counter.
Les deux registres font la même chose : augmenter le compteur de 1.
Y a-t-il une différence ? Oui, mais nous ne pouvons le voir que si nous utilisons la valeur de retour de ++/–.
Clarifions. Comme nous le savons, tous les opérateurs renvoient une valeur. L'incrément/décrément ne fait pas exception ici. La forme de préfixe renvoie la nouvelle valeur, tandis que la forme de suffixe renvoie l'ancienne valeur (avant l'incrément/décrément).
Pour voir la différence, voici l'exemple :
laisser compteur = 1 ; soit a = ++compteur ; // (*) alerte); // 2
Ici sur la ligne, (*) le préfixe d'appel ++counter incrémente le compteur et renvoie la nouvelle valeur qui est 2. Ainsi, les alertes indiquent 2.
Nous allons maintenant utiliser la forme postfixée :
laisser compteur = 1 ; soit a = compteur++ ; // (*) change ++counter en counter++ alert(a); // 1 [/ph] Le long des lignes de (*), la forme postfixée counter++ incrémente également counter, mais renvoie l'ancienne valeur (avant l'incrémentation). Ainsi, les alertes affichent 1. Pour résumer : si le résultat d'incrémentation/décrémentation n'est pas utilisé, le formulaire à utiliser ne fait aucune différence : [php]let counter = 0 ; compteur++ ; ++ compteur ; alert( compteur ); // 2, les lignes ci-dessus ont fait la même chose
Si nous souhaitons incrémenter la valeur et utiliser le résultat de l'opérateur à ce stade, nous avons besoin de la forme de préfixe :
laisser compteur = 0 ; alert(++compteur); // 1
Si nous souhaitons incrémenter, mais utiliser l'ancienne valeur, nous avons besoin de la forme postfixée :
laisser compteur = 0 ; alert( compteur++ ); // 0
Opérateurs au niveau du bit
Les opérateurs au niveau du bit traitent les arguments comme des entiers 32 bits et fonctionnent au niveau de leur représentation binaire.
Ces opérateurs ne sont pas spécifiques à JavaScript. Ils sont pris en charge dans la plupart des langages de programmation.
La liste des opérateurs :
ET ( &)
OU ( |)
OU exclusif ( ^)
PAS (~)
MAJ GAUCHE ( <<)
SHIFT DROITE ( >>)
DÉCALER ZÉRO À DROITE ( >>>)
Ces opérateurs sont très rarement utilisés. Pour les comprendre, nous devons nous plonger dans la représentation des nombres de bas niveau, et il ne serait pas optimal de le faire maintenant. D'autant plus que nous n'en aurons pas besoin de sitôt. Si vous êtes curieux, vous pouvez rechercher vous-même les opérateurs au niveau du bit. Il serait plus pratique de le faire lorsqu'un réel besoin se fait sentir.
Manger
L'opérateur virgule est l'un des opérateurs les plus rares et les plus insolites. Il est parfois utilisé pour écrire du code plus court, nous devons donc le connaître pour comprendre ce qui se passe.
L'opérateur virgule nous permet d'évaluer plusieurs expressions, en les divisant par une virgule ,. Chacun d'eux est évalué, mais seul le résultat du dernier est renvoyé.
Par exemple:
soit a = (1 + 2, 3 + 4); alerte ); // 7 (le résultat de 3 + 4)
Ici, la première expression 1 + 2 est évaluée et son résultat est ignoré, puis 3 + 4 est évalué et renvoyé comme résultat.
La virgule a une priorité très faible.
Notez que l'opérateur virgule a une priorité très faible, inférieure à =, donc les parenthèses sont importantes dans l'exemple ci-dessus.
Sans eux : d'abord a = 1 + 2, 3 + 4 évalue +, en ajoutant les nombres a = 3, 7, puis l'opérateur d'affectation = attribue à = 3, puis le nombre après la virgule 7 n'est pas du tout traité, il est donc ignoré.
Pourquoi avons-nous besoin d'un opérateur qui écarte tout sauf la dernière partie ?
Parfois, les gens l'utilisent dans des versions plus complexes pour mettre plusieurs actions sur une seule ligne.
Par exemple:
// trois opérations sur une ligne pour (a = 1, b = 3, c = a * b; a < 10; a++) { ... }
De telles astuces sont utilisées dans de nombreux frameworks JavaScript, c'est pourquoi nous les mentionnons. Mais ils n'améliorent généralement pas la lisibilité du code, nous devons donc bien réfléchir avant d'écrire comme ça.
