🎂 Houdini 150   🚚 FREE FEDEX SHIPPING from 397 USD   🌎 WORLDWIDE SHIPPING for 25 USD

Opérateurs

Principes de base

Les opérateurs sont des caractères spéciaux ou des symboles utilisés pour effectuer des opérations sur des valeurs ou des variables. Ces opérateurs peuvent être utilisés pour des opérations arithmétiques, logiques et de comparaison. Discutons des opérateurs supportés par MagiScript et de leur utilisation.

Veuillez noter que certains opérateurs ne sont pas compatibles avec les chaînes de caractères et peuvent entraîner un redémarrage du système. +, === et !== travaillent avec des chaînes de caractères.

Opérateurs arithmétiques

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques de base sur des valeurs ou des variables.

Ajout (+)

L'opérateur d'addition est représenté par le symbole + et est utilisé pour additionner deux ou plusieurs valeurs ou variables.

let a = 10;
let b = 20;
let c = a + b;
console.log(c); // Output: 30

Incrément (++)

L'opérateur d'incrémentation est représenté par le symbole ++ et est utilisé pour augmenter la valeur d'une variable de 1.

let a = 10;
a++;
console.log(a); // Output: 11

Soustraction (-)

L'opérateur de soustraction est représenté par le symbole - et est utilisé pour soustraire une valeur d'une autre.

let a = 10;
let b = 20;
let c = b - a;
console.log(c); // Output: 10

Diminution (--)

L'opérateur de décrémentation est représenté par le symbole -- et est utilisé pour diminuer la valeur d'une variable de 1.

let a = 10;
a--;
console.log(a); // Output: 9

Division (/)

L'opérateur de division est représenté par le symbole / et est utilisé pour diviser une valeur par une autre.

let a = 20;
let b = 5;
let c = a / b;
console.log(c); // Output: 4

Modulo (%)

L'opérateur modulo est représenté par le symbole % et est utilisé pour trouver le reste d'une opération de division.

let a = 20;
let b = 3;
let c = a % b;
console.log(c); // Output: 2

Multiplication (*)

L'opérateur de multiplication est représenté par le symbole * et est utilisé pour multiplier deux ou plusieurs valeurs ou variables ensemble.

let a = 5;
let b = 2;
let c = a * b;
console.log(c); // Output: 10

Exponentiation (**)

L'opérateur d'exponentiation est représenté par le symbole ** et est utilisé pour élever une valeur à une puissance.

let a = 2;
let b = 3;
let c = a ** b;
console.log(c); // Output: 8

Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés pour comparer deux valeurs ou variables et renvoient une valeur booléenne (vrai ou faux).

Égalité stricte (===)

L'opérateur d'égalité stricte est représenté par le symbole === et est utilisé pour vérifier si deux valeurs sont égales à la fois en termes de type et de valeur.

let a = 5;
let b = "5";
console.log(a === b); // Output: false

Inégalité stricte (!==)

L'opérateur d'inégalité stricte est représenté par l'opérateur !== et est utilisé pour vérifier si deux valeurs ne sont pas égales à la fois en termes de type et de valeur.

let a = 5;
let b = "5";
console.log(a !== b); // Output: true

Plus grand que (>)

L'opérateur plus grand que est représenté par le symbole > et permet de vérifier si une valeur est supérieure à une autre.

let a = 5;
let b = 2;
console.log(a > b); // Output: true

Less Than (<)

L'opérateur "moins que" est représenté par le symbole < et est utilisé pour vérifier si une valeur est inférieure à une autre.

let a = 5;
let b = 2;
console.log(a < b); // Output: false

Supérieur ou égal à (>=)

L'opérateur supérieur ou égal à est représenté par le symbole >= et permet de vérifier si une valeur est supérieure ou égale à une autre.

let a = 5;
let b = 5;
console.log(a >= b); // Output: true

Less Than or Equal To (<=)

L'opérateur inférieur ou égal est représenté par le symbole <= et est utilisé pour vérifier si une valeur est inférieure ou égale à une autre.

let a = 5;
let b = 5;
console.log(a <= b); // Output: true

Opérateurs binaires

Les opérateurs bitwise sont utilisés pour effectuer des opérations sur des valeurs binaires.

ET binaire (&)

L'opérateur ET binaire est représenté par le symbole & et permet d'effectuer une opération logique ET sur les bits de deux valeurs.

let a = 3;     // 0011 in binary
let b = 6;     // 0110 in binary
let c = a & b; // 0010 in binary
console.log(c); // Output: 2

OU binaire (|)

L'opérateur OR binaire est représenté par le symbole | et est utilisé pour effectuer une opération logique OU sur les bits de deux valeurs.

let a = 3;     // 0011 in binary
let b = 6;     // 0110 in binary
let c = a | b; // 0111 in binary
console.log(c); // Output: 7

XOR par bit (^)

L'opérateur XOR bit à bit est représenté par le symbole ^ et est utilisé pour effectuer une opération logique XOR sur les bits de deux valeurs.

let a = 3;     // 0011 in binary
let b = 6;     // 0110 in binary
let c = a ^ b; // 0101 in binary
console.log(c); // Output: 5

Bitwise NOT (~)

L'opérateur NOT bit à bit est représenté par le symbole ~ et est utilisé pour inverser les bits d'une valeur.

let a = 3;  // 0011 in binary
let b = ~a; // 1100 in binary
console.log(b); // Output: -4

Décalage vers la droite dans le sens des bits (>>)

L'opérateur de décalage de bits vers la droite est représenté par le symbole >> et est utilisé pour décaler les bits d'une valeur vers la droite.

let a = 8;      // 1000 in binary
let b = a >> 1; // 0100 in binary
console.log(b); // Output: 4

Décalage vers la droite non signé par bit (>>>)

L'opérateur de décalage vers la droite des bits non signés est représenté par le symbole >>> et est utilisé pour décaler les bits d'une valeur vers la droite, mais il remplit toujours les bits les plus à gauche avec 0.

let a = -8;      // 11111111111111111111111111111000 in binary
let b = a >>> 1; // 01111111111111111111111111111100 in binary
console.log(b); // Output: 2147483644

Bitwise Left Shift (<<)

L'opérateur de décalage de bits vers la gauche est représenté par le symbole << et est utilisé pour décaler les bits d'une valeur vers la gauche.

let a = 4;      // 000100 in binary
let b = a << 2; // 010000 in binary
console.log(b); // Output: 16

Autres opérateurs

Logique NOT ( !)

L'opérateur logique NOT est représenté par le symbole ! et est utilisé pour inverser une valeur booléenne. Si la valeur est vraie, il renvoie faux. Si la valeur est fausse, il renvoie vrai.

let a = true;
let b = !a;
console.log(b); // Output: false

Opérateur conditionnel (ternaire) (? :)

L'opérateur conditionnel est représenté par le symbole ?: et est utilisé pour créer une courte instruction if-else. Si la condition est vraie, la première expression est renvoyée. Si la condition est fausse, la deuxième expression est renvoyée.

let a = 5;
let b = 2;
let c = a > b ? "a is greater than b" : "a is less than or equal to b";
console.log(c); // Output: "a is greater than b"

typeof Opérateur

L'opérateur typeof est utilisé pour déterminer le type d'une valeur ou d'une variable.

let a = 5;
let b = "Hello, world!";
let c = true;

console.log(typeof a); // Output: "number"
console.log(typeof b); // Output: "string"
console.log(typeof c); // Output: "boolean"

Conclusion

Les opérateurs sont une partie essentielle de tout langage de programmation, et MagiScript supporte une large gamme d'opérateurs pour effectuer diverses opérations. Il est essentiel de comprendre l'utilisation des opérateurs les plus courants pour écrire un code MagiScript efficace et performant.

croix