Principes fondamentaux de l'opérateur

Les fondamentaux des opérateurs en programmation sont essentiels pour effectuer des opérations mathématiques, des comparaisons logiques, la manipulation de données et le contrôle de flux au sein d'un programme. Apprenons-les en utilisant JavaScript ?

Principaux types d'opérateurs en JavaScript :

1. Opérateurs arithmétiques

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

• Addition ( ) : ajoute deux valeurs.
• Soustraction (-) : Soustrait la deuxième valeur de la première.
• Multiplication (*) : Multiplie deux valeurs.
• Division (/) : Divise la première valeur par la seconde.
• Module (%) : Renvoie le reste de la division entre deux valeurs.
• Exponentiation (``)** : augmente la première valeur à la puissance de la seconde.

Exemple:

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)

2. Opérateurs d'affectation

Les opérateurs d'affectation 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.

• Affectation (=) : Attribue une valeur à la variable.
• Affectation avec ajout ( =) : Ajoute et affecte le résultat à la variable.
• Affectation avec soustraction (-=) : Soustrait et affecte le résultat à la variable.
• Affectation avec multiplication (*=) : Multiplie et affecte le résultat à la variable.
• Affectation avec division (/=) : Divise et affecte le résultat à la variable.

Exemple:

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

3. Opérateurs de comparaison

Ces opérateurs comparent deux valeurs et renvoient une valeur booléenne (true ou false). Ils sont largement utilisés dans les structures de contrôle, telles que if et while.

• Égalité (==) : Vérifie si les valeurs sont égales, sans vérifier le type.
• Identité (===) : Vérifie si les valeurs et les types sont exactement les mêmes.
• Différent (!=) : Vérifie si les valeurs sont différentes.
• Différence stricte (!==) : Vérifie si les valeurs et les types sont différents.
• Supérieur à (>) : Vérifie si la valeur à gauche est supérieure.
• Inférieur à (<) : Vérifie si la valeur à gauche est plus petite.
• Supérieur ou égal (>=) : Vérifie si la valeur à gauche est supérieure ou égale.
• Inférieur ou égal (<=) : Vérifie si la valeur à gauche est inférieure ou égale.

Exemple:

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)

4. Opérateurs logiques

Les opérateurs logiques sont utilisés pour combiner des expressions booléennes (vrai ou faux) et sont essentiels au contrôle de flux.

• AND ( && ) : renvoie vrai si les deux expressions sont vraies.
• OR ( || ) : renvoie vrai si au moins une des expressions est vraie.
• NOT ( ! ) : Inverse la valeur booléenne d'une expression.

Exemple:

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





  
  
  5. Opérateurs unaires


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



Incrément ( ) : ajoute 1 à la valeur de la variable.

Décrémenter (--) : Soustraire 1 de la valeur de la variable.



  
  
  Exemple:




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 <= 10);     // true




Il est important de rappeler que l'ordre de ces opérateurs influence le comportement de la variable. Il existe deux façons de les utiliser :



Préfixé x ou --x : Utilisez la valeur actuelle de la variable dans l'expression, puis incrémentez-la/décrémentez-la.

Posfixed x ou x-- : Incrémente/décrémente la valeur avant de l'utiliser dans l'expression (comme illustré précédemment).


Découvrez-en plus en cliquant ici


  
  
  6. Opérateurs ternaires


L'opérateur ternaire est une forme simplifiée de if pour attribuer des valeurs en fonction d'une condition. Votre structure est-elle une condition ? value_if_true : value_if_false.


  
  
  Exemple:




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 sur les opérateurs ternaires ici


  
  
  7. Opérateur de chaîne de concaténation ( )


L'opérateur d'addition ( ) peut également être utilisé pour concaténer des chaînes (joindre des textes).

  
  
  Exemple:




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)





  
  
  8. Opérateurs au niveau du bit (au niveau du bit)


Ces opérateurs effectuent des opérations au niveau des bits (0 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 ce type d'opérateurs.


ET Petit à petit (&)
OU Petit à petit (|)
XOR petit à petit (^)
PAS petit à petit (~)
Décalage vers la gauche (<<)
Décalage vers la droite (>>)

Exemple:

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

Comprendre le fonctionnement des opérateurs est fondamental pour créer des programmes qui effectuent des calculs, des comparaisons et contrôlent efficacement le flux de code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!