Les fondations des opérateurs sont essentielles pour effectuer des opérations mathématiques, des comparaisons logiques, une manipulation de données et un contrôle de flux dans un programme. Apprenons-les en utilisant javascript ?

Principaux types d'opérateurs JavaScript:

1.

Opérateurs arithmétiques

sont utilisés pour effectuer des opérations mathématiques entre les nombres. Ces opérateurs incluent:

• ajout () : Ajouter deux valeurs.
Soustraction (-)
• : soustraire la deuxième valeur du premier. Multiplication (*)
: multiplie deux valeurs.
• Division (/) : divise la première valeur par la seconde.
• Module (%) : renvoie le reste de la division entre deux valeurs.
exponence (`
• `) **: soulève la première valeur à la puissance du second. Exemple:
• Soit a = 10; Soit b = 3; console.log (a b); // Ajout: 13 console.log (a - b); // soustraction: 7 console.log (a * b); // Multiplication: 30 console.log (a / b); // Division: 3 333 console.log (un% b); // Module: 1 (reste de la division de 10 par 3) console.log (a ** b); // Exponence: 1000 (10 relevés à 3) 2.
Opérateurs d'attribution

Les opérateurs d'attribution sont utilisés pour attribuer des valeurs aux variables. L'opérateur le plus courant est "=", mais il existe des combinaisons avec des opérateurs arithmétiques qui facilitent le code.

let a = 10;
let b = 3;

console.log(a   b);  // Adição: 13
console.log(a - b);  // Subtração: 7
console.log(a * b);  // Multiplicação: 30
console.log(a / b);  // Divisão: 3.333
console.log(a % b);  // Módulo: 1 (resto da divisão de 10 por 3)
console.log(a ** b); // Exponenciação: 1000 (10 elevado a 3)

Attribution (=) : attribue une valeur à la variable.

Attribution avec addition (=)

: résume et attribue le résultat à la variable.

ATTRIGHT AVEC LA SUSTRATION (- =)
• : soustraire et attribue le résultat à la variable. Attribution avec multiplation (* =)
: multiplie et attribue le résultat à la variable.
• Attribut avec division (/ =) : divise et attribue le résultat à la variable.
• Exemple: Soit x = 5; x = 3; // x = x 3 -> 8 x - = 2; // x = x - 2 -> 6 x * = 4; // x = x * 4 -> 24 x / = 2; // x = x / 2 -> 12 console.log (x); // Résultat final: 12
• 3. Opérateurs de comparaison
• Ces opérateurs comparent deux valeurs et renvoient une valeur boolean (
true

ou

false

). Ils sont largement utilisés dans les structures de contrôle, telles que

let x = 5;
x  = 3;  // x = x   3 -> 8
x -= 2;  // x = x - 2 -> 6
x *= 4;  // x = x * 4 -> 24
x /= 2;  // x = x / 2 -> 12

console.log(x);  // Resultado final: 12

, et

tandis que .

Equalité (==) : Vérifiez si les valeurs sont les mêmes, sans vérifier le type. identité (===) : Vérifiez si les valeurs et les types sont exactement les mêmes. différent (! =) : Vérifiez si les valeurs sont différentes. Différence stricte (! ==) : Vérifiez si les valeurs et les types sont différents.

supérieur à (>)
• : vérifiez si la valeur gauche est plus élevée. plus petit que (: vérifiez si la valeur gauche est inférieure.
• supérieur ou égal (> =) : Vérifiez si la valeur gauche est plus grande ou égale.
• plus petit ou égal (: Vérifiez si la valeur de gauche est plus petite ou égale.
Exemple:
• Soit num1 = 10; Soit num2 = '10'; console.log (num1 == num2); // vrai (compare uniquement la valeur) console.log (num1 === num2); // false (compare la valeur et le type) console.log (num1! = num2); // faux (les valeurs sont égales) console.log (num1! == num2); // vrai (les types sont différents) console.log (num1> 5); // Vrai console.log (num1
4.
• Opérateurs logiques
Les opérateurs logiques sont utilisés pour combiner des expressions booléennes (vraies ou fausses) et sont essentielles pour le contrôle de flux.
• et (&&)
: Renvoie True si les deux expressions sont vraies.
• ou (||) : Renvoie True si au moins une des expressions est vraie.
• pas (!) : inverse la valeur booléenne d'une expression.
Exemple:

Soit a = true; Soit b = false; console.log (a && b); // faux (et: les deux doivent être vrais) console.log (a || b); // vrai (ou: au moins un doit être vrai) console.log (! A); // faux (non: inverse la valeur de «a»)

let num1 = 10;
let num2 = '10';

console.log(num1 == num2);   // true (só compara o valor)
console.log(num1 === num2);  // false (compara valor e tipo)
console.log(num1 != num2);   // false (valores são iguais)
console.log(num1 !== num2);  // true (tipos são diferentes)
console.log(num1 > 5);       // true
console.log(num1 

 Ces opérateurs fonctionnent avec un seul fonctionnement et peuvent modifier ou renvoyer la valeur d'une variable.



 augmente () 
: ajoute 1 à la valeur de la variable.

décrément (-)
• : soustraire 1 de la valeur de la variable. Exemple:
• Soit Accountant = 5; Comptable; // incréments: comptable = 6 console.log (comptable); // Sortie: 6 comptoir--; // décrément: comptable = 5 console.log (comptable); // Sortie: 5 Il est important de se rappeler que l'ordre de ces opérateurs influence le comportement de la variable. Il existe deux façons de les utiliser:
• préfixe x ou -x:
utilise la valeur actuelle de la variable dans l'expression et fait ensuite l'augmentation / décrémentation.

PosFixed x ou x-:

augmente / décrent la valeur avant de l'utiliser dans l'expression (comme illustré avant).

let a = true;
let b = false;

console.log(a && b);  // false (AND: ambos devem ser verdadeiros)
console.log(a || b);  // true (OR: ao menos um deve ser verdadeiro)
console.log(!a);      // false (NOT: inverte o valor de 'a')

en savoir plus en cliquant ici

6. Opérateurs ternaires

L'opérateur ternaire est une forme simplifiée d'une si à attribuer des valeurs basées sur une condition. Votre structure est-elle une condition? Value_se_verdeiro: valeur_se_falso.

Exemple:
• Agel = 18; Soit Status = (âge> = 18)? «Age supérieur»: «compréhension»; console.log (statut); // Sortie: «Age supérieur»
en savoir plus sur les opérateurs ternaires ici
• 7. Concatenar Strings ()

L'opérateur d'addition () peut également être utilisé pour

concaténer les chaînes

let contador = 5;

contador  ;  // Incrementa: contador = 6
console.log(contador);  // Saída: 6

contador--;  // Decrementa: contador = 5
console.log(contador);  // Saída: 5

Exemple:

Laissez le prénom = "Maria"; Soit SecondName = "Silva"; Let Name Complete = Prénom "Deuxième fonctionnement; Console.log (NameComplete); // Exit: "Maria Silva"

• 8. Opérateurs de bitwise (bits a bits)
• Ces opérateurs effectuent des opérations de niveau de bits (0s et 1), généralement utilisées dans la programmation de bas niveau, telles que les opérations matérielles. Il n'est pas courant d'utiliser ces types d'opérateurs.
et bit un bit (&)

ou bit un bit (|)

xor bit a bit (^)

let idade = 18;
let status = (idade >= 18) ? 'Maior de idade' : 'Menor de idade';

console.log(status);  // Saída: 'Maior de idade'

Déplacement à gauche (

Déplacement droit (>>)

Exemple:

let primeiroNome = "Maria";
let segundoNome = "Silva";

let nomeCompleto = primeiroNome   " "   segundoNome;
console.log(nomeCompleto);  // Saída: "Maria Silva"

Comprendre le fonctionnement des opérateurs est essentiel pour la construction de programmes qui effectuent des calculs, des comparaisons et contrôlent efficacement le flux du code.