Opérateurs

Opérateurs

> Tutoriel LeekScript

Nous allons maintenant parler des opérateurs, qui vont vite devenir indispensables, croyez moi.

Et pour cela, nous allons faire un peu de maths. Pas de panique !! Restez ici ! Rassurez vous, vous n'aurez besoin que des opérations basiques : Addition, Soustraction, Multiplication, Division et le Modulo. Bien que vous ne connaissez peut-être pas ce dernier si vous êtes débutant, il n'est pas très compliqué.

Nous verrons aussi des opérateurs permettant d'attribuer une valeur à une variable autrement qu'avec un simple "="

Opérateurs de calcul

Votre poireau est très fort en calcul mental. Echauffons le un peu avec des calculs simples.

Addition

Le symbole qui permet de réaliser des additions en LeekScript est le "+".

Pour l'utiliser, écrivez une addition, comme vous l'avez sûrement déjà fait. (Enfin on espère)

Souvenez vous que l'on affecte une valeur a une variable comme ceci :

var unEntier = 6 debug(unEntier); // Affiche : 6

Pour réaliser une addition, il suffit simplement de placer votre expression mathématique à la place de cette valeur.

var addition = 3 + 5; debug(addition) // Affiche : 8

Et voila ! Votre poireau a fait sa première addition et vous donne le résultat. Vous pouvez aussi envoyer directement le calcul en paramètre à la fonction debug.

debug(3+5); // Affiche : 8

Soustraction

Le symbole pour la soustraction est sans surprise, le "-"

var soustraction = 7 - 4; debug(soustraction); //Affiche : 3

Multiplication

Pour cette opération, n'essayez pas d'utiliser la lettre "x" pour faire un "fois". En informatique on utilise le symbole "\*" pour la multiplication

var multiplication = 3 * 5; debug(multiplication); // Affiche : 15

Division

Quant à la division, on utilise le symbole "/"

var division = 20 / 4; debug(division);

Modulo

Un petit rappel à propos du modulo. Nos amis matheux ont ce qu'ils appellent la "Division Euclidienne".

La division classique de 7 par 2 donne 3.5. La division Euclidienne décompose le résultat en un "Quotient" et un "Reste". Ainsi, on a 7 = 2 * 3 + 1. Le résultat est un quotient valant 3 et un reste de 1.

Et c'est ce reste qui nous intéresse ici. Le modulo est l'opération qui nous donne le reste de la division euclidienne. Son symbole est le "%"

Par exemple 30%7 donnera 2 puisque 30 = 7 * 4 + 2

var modulo = 42 % 9; debug(modulo) // Affiche : 6

Division entière, ou euclidienne

Cette division renvoie le quotient de la division euclidienne entre deux nombres. Son symbole est le "\\".

A l'inverse du modulo qui prend en compte les nombres à virgule, la division entière retire leur partie décimale. Donc 5.9 \ 2.1 est transformé en 5 \ 2. Le résultat est 2.

var quotient = 30 \ 7; debug(quotient) // Affiche : 4

Priorité des opérations

Tout comme en mathématiques, il y a une priorité des opérations.

Ainsi les opérations de multiplication (\), de division (/) et le modulo (%) sont prioritaires sur l'addition (+) et la soustraction (-). Pour des opérateurs ayant la même priorité (\, / et %, ou + et -), la priorité se fera de gauche à droite dans l'expression.

Si vous devez modifier la priorité dans un calcul, vous devrez utiliser des parenthèses. Par exemple

debug(2 + 3 * 4); // Affiche : 14 debug((2 + 3) * 4); // Affiche : 20

debug(12 / 2 * 3); // Affiche : 18 debug(12 / (2 * 3)); // Affiche : 2

Opérateur d'attribution

Vous connaissez déjà le "=" qui permet d'affecter une valeur à une variable :

var maVariable = 8; debug(maVariable); // Affiche : 8

Sachez que cet opérateur a des grands frères. Preneons le cas où vous souhaiteriez ajouter une valeur à une variable. Notre variable vaut 8, nous voudrions lui ajouter 3. Nous pouvons faire comme ceci :

var maVariable = 8; maVariable = maVariable + 3; debug(maVariable); // Affiche : 11

Cela fonctionne très bien, mais on peut faire encore mieux. Il est possible de fusionner les opérateurs de calcul au signe "=". Ainsi cela donne ces 5 opérateurs très pratiques : "+=", "-=", "\*=", "/=", et "%="

L'exemple précédent devient :

var maVariable = 8; maVariable +=3; // Equivalent à maVariable = maVariable + 3; debug(maVariable); // Affiche : 11

Le résultat est identique, mais c'est un peu moins redondant.

var maVariable = 9; maVariable += 3; // 12 maVariable -= 2; // 10 maVariable *= 4; // 40 maVariable /= 2; // 20 maVariable %= 6; // 2 debug(maVariable); // Affiche : 2

Opérateurs d'incrémentation

Voila deux petits opérateurs très utiles. L'opérateur d'incrémentation "++", et l'opérateur de décrémentation "--".

Incrémenter une variable signifie que l'on augmente sa valeur de 1.

var maVariable = 3; maVariable++; // Equivalent à maVariable = maVariable + 1; debug(maVariable); // Affiche : 4

Et Décrémenter une variable signifie que l'on diminue sa valeur de 1

var maVariable = 3; maVariable--; // Equivalent à maVariable = maVariable - 1; debug(maVariable); // Affiche : 2

Opérateurs logiques

Les opérateurs logiques permettent de renvoyer une valeur logique à partir d'autres valeurs logiques :

Voir aussi : https://leekwars.com/encyclopedia/Conditions#Op%C3%A9rateurs_logiques

Opérateurs binaires

Les opérateurs binaires sont des opérateurs moins connus que les opérateurs mathématiques classiques (tels que +,-,/, ...) mais qui sont utilisés par les éleveurs seniors pour construire des fonction ou des IA peu gourmandes en opérations.

Prérequis

La compréhension de l'utilisation de ces opérateurs nécessite d'être familier avec la notation binaire (ou notation en base 2) des nombres. Si c'est un sujet que vous ne connaissez pas, internet regorge d'explication, tutoriels et ressources documentaires qui vous permettront de rapidement comprendre de quoi il s'agit.

Si l'égalité 9 = 1001 vous laisse circonspect, c'est qu'il vaut mieux s'intéresser d'abord à la notation binaire avant d'aller plus loin.

Notation

Dans la suite de ce chapitre, nous allons régulièrement basculer entre nombres écrits n binaire et d'autres écrtis en base 10. Pour simplifier la compréhension et éviter les confusions, nous adopterons la notation suivante :

Ainsi nous avons donc par exemple les propositions suivante qui sont toutes vraies :

5d === 101b // Si on passe tout en notation décimale, on a bien 5d === 5d 10d > 101b // En notation décimale, cela donne 10d > 5d 11d !== 11b // Toujours en notation décimale, 11d !== 3d

Utilisation des opérateurs binaires

Les opérateurs binaires sont des opérateurs mathématiques ( +, -, /, ...) comme les autres. Ils s'appliquent à 2 opérandes numériques, et retournent un résultat lui aussi numérique. Comme les opérateurs mathématiques classiques, ils sont positionnés entre les deux opérandes.

On peut utiliser ces opérateurs dans le cadre d'expressions (cf. chapitre suivant), pour des affectations de variables, ... bref ! Tout comme les opérateurs mathématiques classiques.

Par exemple :

debug(3 + 4); // Affichera 7 dans le débuggeur debug(3 & 4); // Affichera 0 dans le débuggeur (le détail du calcul sera présenté plus bas)

Détail de chacun des opérateurs

Les opérateurs binaires fonctionnent "bit à bit", c'est à dire qu'ils vont se baser sur la notation binaire des nombres qu'on leur passe en entrée, et effectuer une opération sur chacun des couples de bits de deux opérandes. Néanmoins, avant de détailler ce fonctionnement, nous allons d'abord nous intéresser au comportement de chacun de ces opérateurs sur un unique bit.

Remarque importante : les opérateurs binaires ont des noms (et parfois même des notations en leekscript) très similaires aux opérateurs logiques (and, or, ...). Il faut garder en tête que :

Attention donc à ne pas confondre l'opérateur binaire ET/AND, noté "&", et l'opérateur logique ET/AND, noté " && " ou tout simplement "and" dans un script.

L'opérateur ET/AND : & Cet opérateur, noté & en leekscript, appliqué à un couple de bits évaluera un résultat à 1 si chacun des deux bits en entrée vaut 1. Il évaluera à 0 dans tous les cas contraires. Si on le présente sous forme d'une table de vérité cela donne :

a | b | | a & b --|---|----|------ 0 | 0 | -> | 0 0 | 1 | -> | 0 1 | 0 | -> | 0 1 | 1 | -> | 1

L'opérateur OU/OR : | L'opérateur OU/OR noté "|" (AltGr + 6) en leekscript, évaluera à 1 si au moins un des deux bits en entrée vaut 1, et à 0 si les deux bits en entrée valent 0.

Sous forme d'une table de vérité : a | b | | a \| b --|---|----|------ 0 | 0 | -> | 0 0 | 1 | -> | 1 1 | 0 | -> | 1 1 | 1 | -> | 1

L'opérateur OU EXCLUSIF/XOR : ^ L'opérateur OU EXCLUSIF/XOR noté "^" en leekscript évaluera à 1 si exactement un des deux bits en entrée vaut 1, et à 0 dans le cas contraire.

Table de vérité : a | b | | a ^ b --|---|----|------ 0 | 0 | -> | 0 0 | 1 | -> | 1 1 | 0 | -> | 1 1 | 1 | -> | 0

L'opérateur NOT : ~ L'opérateur NOT noté "~" en leekscript inversera chaque 0 et 1 dans votre nombre binaire.

Table de vérité : a | | ~a --|----|------ 0 | -> | 1 1 | -> | 0

Attention cependant : en Leekscript, les variables entières sont stokées sur 32 bits. Appliquer un NOT sur le nombre 10d (1010 en binaire) ne vous donnera pas 5d (0101b), mais -11, c'est a dire 1111111111111111 1111111111110101 en binaire.

Détail du fonctionnement des opérateurs binaires

"Ok super ! On a la description d'un truc complètement redondant avec les opérateurs logiques !"

Pas tout à fait. Nous avons vu le comportement de ces opérateurs lorsqu'on leur passe un couple de bits en entrée. Néanmoins, comme cela a été dit plus haut, ces opérateurs s'appliquent à des nombres.

Mais comme leur nom peut le laisser supposer, ces opérateurs vont travailler dans le monde merveilleux de la notation binaire.

Tout simplement, ils vont parcourir l'écriture binaire des deux nombres en entrée, calculer un nombre au format binaire, puis présenter en sortie le résultat sous forme d'un nombre.

Un exemple valant mieux qu'un long discours, voilà comment va s'évaluer l'expression "10 & 9" :

| | Notation décimale | | Notation binaire ---------------------------|-------------------|----|------------------ Opérande 1 | 10d | -> | 1010b Opérande 2 | 9d | -> | 1001b Application de l'opérateur | | | 1000b Conversion décimale | 8d | | 1000b

Si on détaille ce qui a été fait pour passer de 1010b & 1001b à 1000b, on a tout simplement appliqué l'opérateur "&" à chacun des digits des deux nombres :

Nombre | Digit 1 | Digit 2 | Digit 3 | Digit 4 ------------|---------|---------|---------|-------- 10d / 1010b | 1 | 0 | 1 | 0 9d / 1001b | 1 | 0 | 0 | 1 Résultat | 1 | 0 | 0 | 0

Ainsi, on aura donc le comportement suivant :

debug(10 & 9); // Affichera 8 dans le débuggueur.

Si jamais les deux nombres n'ont pas le même nombre de digits dans leur format binaire, le plus petit des deux sera complété par des zéros "non significatifs" avant le premier 1.

Par exemple, l'expression 14 ^ 3 donnera lieu au calcul suivant : | | Notation décimale | | Notation binaire ---------------------------|-------------------|----|------------------ Opérande 1 | 14d | -> | 1110b Opérande 2 | 3d | -> | 0011b Application de l'opérateur | | | 1101b Conversion décimale | 13d | | 1101b

Ainsi, on aura donc :

debug(14 ^ 3); // Affichera 13 dans le débuggueur.

Bit shifting

Les opérateur de bit shifting servent a décaler les bits d'un nombre par une certaine quantitée. Ils sont représentés par les symbôles >> et **> va décaler tous les bits du nombre vers la droite et insérer un 0 a gauche si le nombre est positif, ou un 1 si il est négatif. Cela équivaut a diviser le nombre par 2.

Exemples avec >> (nombres sur 5bits) Opération | Représentation Binaire | Résultat | Représentation Binaire ----------|-------------------------|----------|---------------------- 10d >> 1 | 01010b >> 1 | 5d | 00101b 10d >> 2 | 01010b >> 2 | 2d | 00010b 10d >> 3 | 01010b >> 3 | 1d | 00001b -5d >> 3 | 11011b >> 3 | -1d | 11111b

Exemples avec >>> (nombres sur 5bits) Opération | Représentation Binaire | Résultat | Représentation Binaire ----------|-------------------------|----------|---------------------- 10d >>> 3 | 01010b >>> 3 | 1d | 00001b -5d >>> 3 | 11011b >>> 3 | 3d | 00011b

**Exemples avec >= 1;||3|00011b| maVariable >>= 1||6|00110b|

Utilité de ces opérateurs

Le gros avantage de ces opérateurs binaires, est qu'ils coûtent très peu en terme d'opérations. Ils rendent donc possible l'écriture de fonctions complexes pour un coût qui reste modéré, ou bien de limiter le coût d'une fonction dont on souhaite abuser en l'intégrant au fin fond de multiples boucles impliquées.

Vous avez maintenant les bases pour utiliser ces nouveaux opérateurs. Avec un peu d'imagination, il est tout à faire possible de voir à quoi ils pourraient servir...

Les Expressions

Qu’est-ce donc qu’une expression ? Si je vous dit “8x - 5”, c’est une “expression mathématique”. Eh bien, en programmation, c’est un peu pareil.

Ce que nous avons écrit dans ce chapitre, ce sont des expressions. Quand vous écrivez :

Vous assignez le résultat de l'expression "8 * 9 + 4 * 2" à la variable "maVariable". L'ordinateur comprend cette expression et détermine que son résultat est 80. Il assigne ensuite la valeur 80 à la variable.

Retenez bien ce nom, nous en reparlons.

Mais une expression, ce n'est pas seulement une suite de nombre et de symboles. Vos expressions peuvent aussi contenir d'autres variables !

Vous pouvez très bien écrire :

De même, soyez bien conscient que lorsque vous assignez une valeur à une variable, si celle-ci contenait déjà une valeur, elle est supprimée. Par exemple :

Ayez bien ces notions en tête lorsque vous lisez du code.

Exercices

Les exercices sont une part très importante du tuto, ainsi je vous conseille de les réaliser sans exception, c'est en forgeant que l'on deviens forgeron après tout. Il est très probable que le chapitre vous ait paru simple, mais le moindre détail en programmation est important. Voici donc le premier exo :

Exercice SWAP

On commence soft, vous devrez inverser la valeur de deux variables, à vous de jouer :) Si cela est encore trop simple, avez vous essayé sans utiliser une troisième variable ?

Conclusion

Nous avons presque fait le tour des opérateurs. Il reste encore les opérateurs de comparaison à découvrir. Nous en parlerons dans un prochain chapitre, car ils sont intimement liés aux conditions.

Vous savez désormais faire des calculs en LeekScript. Peut-être que cela vous semble encore peu utile pour le moment, mais vous comprendrez toute l’importance de savoir réaliser des calculs dans les prochains chapitres.

Ceux-ci parleront des Conditions et des Boucles, deux notions extrêmement importantes en programmation.