Opérateurs Dart
Les opérateurs sont des symboles qui effectuent des calculs, des comparaisons et des jugements logiques dans les programmes.
Ce chapitre présente systématiquement les différents opérateurs en Dart, notamment les opérateurs arithmétiques, relationnels, logiques, d'affectation, conditionnels et de vérification de type.
Opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques de base.
Exemple
int a = 10;
int b = 3;
print('a = $a, b = $b');
print('Addition a + b = ${a + b}'); // 13
print('Soustraction a - b = ${a - b}'); // 7
print('Multiplication a * b = ${a * b}'); // 30
print('Division a / b = ${a / b}'); // 3.333... (le résultat est un double)
print('Division entière a ~/ b = ${a ~/ b}'); // 3 (partie entière, décimale supprimée)
print('Modulo a % b = ${a % b}'); // 1 (opération modulo)
print('Négation -a = ${-a}'); // -10 (moins unaire)
}
a = 10, b = 3 加法 a + b = 13 减法 a - b = 7 乘法 a * b = 30 除法 a / b = 3.3333333333333335 整除 a ~/ b = 3 取余 a % b = 1 取反 -a = -10
Remarque : L'opérateur / renvoie toujours un type double, même lorsque les deux opérandes sont de type int et sont divisibles exactement. Si vous n'avez besoin que d'un résultat entier, utilisez l'opérateur de division entière ~/.
Opérateurs d'incrémentation et de décrémentation
Comme la plupart des langages de la famille C, Dart prend en charge ++ (incrémentation) et -- (décrémentation).
Exemple
int count = 0;
// Préfixe ++ : incrémenter d'abord, puis utiliser
print('Préfixe ++ : ${++count}'); // 1
// Postfixe ++ : utiliser d'abord, puis incrémenter
print('Postfixe ++ : ${count++}'); // 1 (count est encore 1 à ce stade)
print('Maintenant count = $count'); // 2
// Idem pour la décrémentation
print('Préfixe -- : ${--count}'); // 1
print('Postfixe -- : ${count--}'); // 1
print('Maintenant count = $count'); // 0
}
前置 ++: 1 后置 ++: 1 现在 count = 2 前置 --: 1 后置 --: 1 现在 count = 0
L'incrémentation et la décrémentation préfixes et postfixes ont le même effet lorsqu'elles sont utilisées seules, mais se comportent différemment dans les expressions. Il est conseillé aux débutants de les éviter autant que possible dans les expressions ; les écrire sur une ligne séparée est plus clair.
Opérateurs relationnels
Les opérateurs relationnels sont utilisés pour comparer deux valeurs, et le résultat est une valeur bool.
| Opérateurs | Signification | Exemple | Résultat |
|---|---|---|---|
| == | equals | 5 == 5 | vrai |
| != | Différent de | 5 != 3 | vrai |
| > | supérieur à | 5 > 3 | vrai |
| < | inférieur à | 5 < 3 | false |
| >= | supérieur ou égal à | 5 >= 5 | vrai |
| <= | inférieur ou égal à | 3 <= 5 | vrai |
Exemple
int exampleScore = 95;
int passLine = 60;
print(Score : $exampleScore, Seuil de réussite : $passLine);
print(Réussi ? ${exampleScore >= passLine});
print(Score parfait ? ${exampleScore == 100});
// Les chaînes peuvent aussi être comparées
String a = 'pomme';
String b = 'banane';
print("'$a' == '$b'? ${a == b}");
// == vérifie si les valeurs sont égales
String c = 'EXAMPLE';
String d = 'EXAMPLE';
print("'$c' == '$d'? ${c == d}"); // true (même contenu)
}
分数: 95, 及格线: 60 及格了吗? true 满分了吗? false 'apple' == 'banana'? false 'EXAMPLE' == 'EXAMPLE'? true
En Dart, == compare si les valeurs de deux objets sont égales, et non leurs adresses de référence. Cela diffère de Java—en Dart, vous n'avez pas besoin d'utiliser la méthode equals() pour comparer des chaînes.
Opérateurs logiques
Les opérateurs logiques servent à combiner plusieurs expressions booléennes, généralement pour des évaluations conditionnelles.
| Opérateurs | Signification | Description |
|---|---|---|
| && | ET logique | Renvoie true uniquement si les deux côtés sont true. |
| || | OU logique | Renvoie true si l'un des deux côtés est true. |
| ! | NON logique | Négation : true devient false, false devient true |
Exemple
bool isLoggedIn = true;
bool isAdmin = false;
// && ET : les deux sont true
print(Connecté et administrateur : ${isLoggedIn && isAdmin}); // false
// || OU : au moins l'un est true
print(Connecté ou administrateur : ${isLoggedIn || isAdmin}); // true
// ! NOT : négation
print(Non connecté : ${!isLoggedIn}); // false
// Évaluation en court-circuit : si le côté gauche détermine déjà le résultat, le côté droit ne s'exécutera pas
int age = 20;
// age > 18 est déjà vrai, mais le côté droit doit aussi être vérifié
print(Adulte et a la permission : ${age >= 18 && isAdmin});
// age < 18 est déjà faux, donc le côté droit de && est ignoré directement
print('Mineur et a la permission : ${age < 18 && isAdmin}');
}
登录且是管理员: false 登录或是管理员: true 未登录: false 成年且有权限: false 未成年且有权限: false
Dart utilisel'évaluation en court-circuitPour &&, si le côté gauche est faux, le côté droit n'est pas évalué ; pour ||, si le côté gauche est vrai, le côté droit n'est pas évalué.
Cette fonctionnalité peut être utilisée pour éviter les problèmes de pointeur null.
Exemple
Applications pratiques de l'évaluation en court-circuit :
String? username;
// Vérification de sécurité : username n'est pas null et la longueur est supérieure à 3
// Si username est null, le côté droit de && ne s'exécutera pas, évitant ainsi une erreur de pointeur null
if (username != null && username.length > 3) {
print('Nom d'utilisateur valide');
} else {
print('Nom d'utilisateur invalide ou trop court');
}
}
Username is invalid or too short.
Opérateurs d'affectation
Vous connaissez déjà l'opérateur d'affectation de base =.
Dart fournit également des opérateurs d'affectation composés pour simplifier les opérations courantes de "calculer puis affecter".
| Opérateurs | Syntaxe équivalente | Exemple (lorsque a=10) |
|---|---|---|
| += | a = a + b | a += 3 → 13 |
| -= | a = a - b | a -= 3 → 7 |
| *= | a = a * b | a *= 3 → 30 |
| /= | a = a / b | a /= 2 → 5.0 |
| ~/= | a = a ~/ b | a ~/= 3 → 3 |
| %= | a = a % b | a %= 3 → 1 |
Exemple
int score = 0;
// Ajouter 10 points pour chaque bonne réponse
score += 10;
print('Bonne réponse à la question 1 : $score');
score += 10;
print('Bonne réponse à la question 2 : $score');
// Une mauvaise réponse retire 5 points
score -= 5;
print('Réponse incorrecte à 1 question : $score');
// Doubler le score
score *= 2;
print('Récompense doublée : $score');
print('EXEMPLE score final : $score');
}
答对第1题: 10 答对第2题: 20 答错1题: 15 奖励翻倍: 30 EXAMPLE 最终得分: 30
Opérateurs conditionnels : ?? et ??=
Ces deux opérateurs sont spécialement conçus pour gérer les valeurs null et font partie intégrante du système de null safety de Dart.
?? opérateur de coalescence null
Si l'expression de gauche n'est pas null, retourne sa valeur ; sinon, retourne la valeur de droite.
??= opérateur d'affectation sensible à null
Si la variable est actuellement null, affectez-lui la valeur de droite ; sinon, laissez-la inchangée.
Exemple
// ?? coalescence null
String? nickname;
String displayName = nickname ?? 'EXAMPLE user';
print(displayName); // EXAMPLE user
nickname = 'Little R';
displayName = nickname ?? 'EXAMPLE user';
print(displayName); // Little R
// Le chaînage de ?? fonctionne aussi
String? a;
String? b;
String result = a ?? b ?? 'Default value';
print(result); // Default value
// ??= affectation de coalescence null
int? count;
count ??= 0; // count est null, assigner 0
print(count); // 0
count ??= 100; // count est déjà 0 (non nul), aucune affectation
print(count); // 0 (inchangé)
}
EXAMPLE 用户 小R 默认值 0 0
Opérateur conditionnel ternaire ? :
C'est le seul opérateur à trois opérandes de Dart, une version concise de if-else.
Exemple
int score = 75;
// Syntaxe : condition ? valeur si vrai : valeur si faux
String result = score >= 60 ? 'Pass' : 'Fail';
print('EXEMPLE résultat d'examen : $result');
// Peut être imbriqué (mais il n'est pas recommandé de dépasser deux niveaux ; la lisibilité se dégradera)
String grade = score >= 90 ? 'Excellent' : score >= 60 ? 'Réussi' : 'Échoué';
print('Note : $grade');
}
EXAMPLE 考试结果: 及格 评级: 及格
Opérateurs de vérification de type : is et as
is est utilisé pour vérifier si un objet appartient à un type, as est utilisé pour le transtypage.
Exemple
// is : vérification de type
var name = 'EXAMPLE';
print('name est-il de type String ? ${name is String}'); // true
print('name est-il de type int ? ${name is int}'); // false
// is! : n’est pas un type
print('name n’est-il pas de type int ? ${name is! int}'); // true
// as : conversion de type
Object obj = 'Bonjour, Dart !';
// Convertir le type Object en String pour utiliser les méthodes de String
String str = obj as String;
print(str.toUpperCase());
// Vérification de type sécurisée + conversion
Object maybeString = 42;
if (maybeString is String) {
// Dans une branche où la vérification is est vraie, la variable est automatiquement « promue » vers ce type
print(maybeString.length); // Aucune conversion avec as nécessaire
} else {
print('Pas une chaîne, la valeur est : $maybeString');
}
}
name 是 String 吗? true name 是 int 吗? false name 不是 int 吗? true HELLO, DART! 不是字符串，值是: 42
Préférez utiliser is pour la vérification de type. Dans une branche conditionnelle où is est évalué à true, Dart promeut automatiquement la variable vers le type cible (Type Promotion), donc il n’est pas nécessaire d’utiliser as pour la conversion de type. N’utilisez as que lorsque vous êtes certain du type mais que le compilateur ne peut pas l’inférer.
Aperçu de la priorité des opérateurs
Lorsqu’une expression contient plusieurs opérateurs, Dart les évalue par ordre de priorité, du plus élevé au plus faible.
Si vous n’êtes pas sûr de la priorité, la pratique la plus sûre est deutiliser des parenthèses pour clarifier l’ordre de calcul。
| Priorité | Opérateurs | Description |
|---|---|---|
| Maximale | () [] . ?. | Parenthèses, indices, accès aux membres |
| ! ~ - ++ -- | Opérateurs unaires | |
| * / % ~/ | Multiplication, division et reste | |
| + - | Additif | |
| < <= > >= | Comparaison relationnelle | |
| == != | Vérification d’égalité | |
| && | ET logique | |
| || | OU logique | |
| ?? | Coalescence nulle | |
| ? : | Conditionnel ternaire | |
| = += -= *= etc. | Affectation (priorité la plus faible) |
Exemple
// Ne vous fiez pas à la priorité—utilisez des parenthèses pour clarifier votre intention.
int result = ((10 + 5) * 2) - (8 ~/ 3);
print('Résultat du calcul : $result'); // 28
// Sans parenthèses, le résultat peut être complètement différent.
// 10 + 5 * 2 - 8 ~/ 3 sera 18 (multiplication et division avant addition et soustraction)
int result2 = 10 + 5 * 2 - 8 ~/ 3;
print('Sans parenthèses : $result2'); // 18
}
计算结果: 28 不加括号: 18autres extensions