Les opérateurs en Dart

Dart prend en charge tous les opérateurs listés dans le tableau ci-dessous, le tableau est trié par priorité décroissante (du plus élevé au plus faible)

Catégorie	Opérateurs	Associativité
Opérateurs unaires postfixés	expr++ expr-- () [] ?[] . ?. !	Aucune
Opérateurs unaires préfixés	- expr ! expr ~ expr ++ expr -- expr await expr	Aucune
Multiplication et division	* / % ~/	Associatif à gauche
Addition et soustraction	+ -	Associatif à gauche
Décalages binaires	<< >> >>>	Associatif à gauche
ET bit à bit	&	Associatif à gauche
XOR bit à bit	^	Associatif à gauche
OU bit à bit	|	Associatif à gauche
Relationnel et vérification de type	>= > <= < as is is!	Aucune
Égalité	== !=	Aucune
ET logique	&&	Associatif à gauche
OU logique	||	Associatif à gauche
Opérateur de fusion null	??	Associatif à gauche
Opérateur ternaire conditionnel	expr1 ? expr2 : expr3	Associatif à droite
Opérateurs en cascade	.. ?..	Associatif à gauche
Opérateurs d’affectation	= *= /= += -= &= ^= etc.	Associatif à droite
Opérateur spread (voir note)	... ...?	Aucune

En combinant ces opérateurs avec des opérandes, on construit des expressions de calcul

Exemples simples :

a++
a + b
a = b
a == b
c ? a : b
a is T

Voici un exemple fonctionnel complet :

void main() {
  // 1. Expression d'incrémentation postfixée a++
  int a = 10;
  print("1. Incrémentation postfixée a++");
  print("Avant incrémentation a = $a");
  int temp = a++; // On récupère la valeur d'abord, puis on incrémente
  print("temp (valeur récupérée) = $temp");
  print("Après incrémentation a = $a\n");

  // 2. Expression d'addition a + b
  int b = 20;
  int somme = a + b;
  print("2. Addition a + b");
  print("$a + $b = $somme\n");

  // 3. Expression d'affectation a = b
  a = b;
  print("3. Affectation a = b");
  print("Après affectation a = $a\n");

  // 4. Vérification d'égalité a == b
  bool estEgal = a == b;
  print("4. Vérification d'égalité a == b");
  print("Résultat a == b : $estEgal\n");

  // 5. Expression ternaire conditionnelle c ? a : b
  int c = 5;
  String resultat = c > 0 ? "c est un nombre positif" : "c est négatif ou nul";
  print("5. Opérateur ternaire c ? a : b");
  print("Vérification c>0 : $resultat\n");

  // 6. Vérification de type a is T
  dynamic valeurTest = 100;
  print("6. Vérification de type a is T");
  print("valeurTest est int : ${valeurTest is int}");
  print("valeurTest est String : ${valeurTest is String}");
}
Langage du code : Dart (dart)

Copiez le code ci-dessus et exécutez-le avec la commande : dart run

Règles clés de priorité des opérateurs

1. Logique de l’ordre de priorité

Le tableau des opérateurs voit sa priorité diminuer de haut en bas : les opérateurs des lignes supérieures ont une priorité supérieure et s’exécutent en premier.

Exemple : le symbole > signifie « a une priorité supérieure », ce n’est pas une comparaison de valeurs.

Ordre d’exécution : modulo % ＞ égalité == ＞ ET logique &&

Décomposition de l’exécution de l’expression n % i == 0 && d % i == 0 :

1. D’abord calcul de n % i, d % i (% a la plus haute priorité)
2. Puis les deux comparaisons d’égalité ==
3. Enfin l’opérateur ET logique central &&

2 Rôle des parenthèses

Les parenthèses ((n % i == 0) && (d % i == 0)) améliorent uniquement la lisibilité du code, elles ne modifient pas l’ordre d’exécution natif ;

La version sans parenthèses n % i == 0 && d % i == 0 suit la priorité native, les deux fragments ont exactement la même logique et le même résultat ;

Note complémentaire : les parenthèses ne changent l’ordre d’exécution que lorsqu’il faut rompre la priorité par défaut.

void main() {
  int n = 10;
  int d = 20;
  int i = 2;

  // Forme 1 : avec parenthèses, plus lisible
  if ((n % i == 0) && (d % i == 0)) {
    print("Forme 1 : divisible sans reste");
  }

  // Forme 2 : sans parenthèses, utilise la priorité native, résultat identique
  if (n % i == 0 && d % i == 0) {
    print("Forme 2 : divisible sans reste");
  }
}

Résultat de l’exécution :

Forme 1 : divisible sans reste
Forme 2 : divisible sans reste