Dart-Operatoren
Operatoren sind Symbole, die in Programmen Berechnungen, Vergleiche und logische Entscheidungen ausführen.
Dieses Kapitel führt systematisch in verschiedene Operatoren in Dart ein, darunter arithmetische, relationale, logische, Zuweisungs- und Bedingungsoperatoren sowie Typprüfung.
Arithmetische Operatoren
Arithmetische Operatoren werden verwendet, um grundlegende mathematische Operationen auszuführen.
Beispiel
int a = 10;
int b = 3;
print('a = $a, b = $b');
print('Addition a + b = ${a + b}'); // 13
print('Subtraktion a - b = ${a - b}'); // 7
print('Multiplikation a * b = ${a * b}'); // 30
print('Division a / b = ${a / b}'); // 3.333... (Ergebnis ist double)
print('Ganzzahlige Division a ~/ b = ${a ~/ b}'); // 3 (ganzzahliger Teil, Nachkommastellen werden verworfen)
print('Modulo a % b = ${a % b}'); // 1 (Modulo-Operation)
print('Negation -a = ${-a}'); // -10 (unäres Minus)
}
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
Hinweis: Der /-Operator gibt immer einen double-Typ zurück, auch wenn beide Operanden int sind und ohne Rest teilbar sind. Wenn Sie nur ein ganzzahliges Ergebnis benötigen, verwenden Sie den ~/ Ganzzahldivisionsoperator.
Inkrement- und Dekrement-Operatoren
Wie die meisten Sprachen der C-Familie unterstützt Dart ++ (Inkrement) und -- (Dekrement).
Beispiel
int count = 0;
// Präfix ++: zuerst inkrementieren, dann verwenden
print('Präfix ++: ${++count}'); // 1
// Postfix ++: zuerst verwenden, dann inkrementieren
print('Postfix ++: ${count++}'); // 1 (count ist an dieser Stelle immer noch 1)
print('Jetzt count = $count'); // 2
// Dasselbe für Dekrement
print('Präfix --: ${--count}'); // 1
print('Postfix --: ${count--}'); // 1
print('Jetzt count = $count'); // 0
}
前置 ++: 1 后置 ++: 1 现在 count = 2 前置 --: 1 后置 --: 1 现在 count = 0
Präfix- und Postfix-Inkrement/Dekrement haben dieselbe Wirkung, wenn sie allein verwendet werden, verhalten sich jedoch innerhalb von Ausdrücken unterschiedlich. Anfängern wird empfohlen, sie in Ausdrücken möglichst zu vermeiden; sie in eine separate Zeile zu schreiben, ist klarer.
Relationale Operatoren
Relationale Operatoren werden verwendet, um zwei Werte zu vergleichen, und das Ergebnis ist ein bool-Wert.
| Operatoren | Bedeutung | Beispiel | Ergebnis |
|---|---|---|---|
| == | equals | 5 == 5 | wahr |
| != | Nicht gleich | 5 != 3 | wahr |
| > | größer als | 5 > 3 | wahr |
| < | kleiner als | 5 < 3 | false |
| >= | größer als oder gleich | 5 >= 5 | wahr |
| <= | kleiner als oder gleich | 3 <= 5 | wahr |
Beispiel
int exampleScore = 95;
int passLine = 60;
print(Punktzahl: $exampleScore, Bestehensgrenze: $passLine);
print(Bestanden? ${exampleScore >= passLine});
print(Volle Punktzahl? ${exampleScore == 100});
// Zeichenketten können auch verglichen werden
String a = 'apple';
String b = 'banana';
print("'$a' == '$b'? ${a == b}");
// == prüft, ob Werte gleich sind
String c = 'EXAMPLE';
String d = 'EXAMPLE';
print("'$c' == '$d'? ${c == d}"); // true (gleicher Inhalt)
}
分数: 95, 及格线: 60 及格了吗? true 满分了吗? false 'apple' == 'banana'? false 'EXAMPLE' == 'EXAMPLE'? true
In Dart vergleicht ==, ob die Werte zweier Objekte gleich sind, nicht ihre Referenzadressen. Das unterscheidet sich von Java – in Dart muss man nicht die equals()-Methode verwenden, um Strings zu vergleichen.
Logische Operatoren
Logische Operatoren werden verwendet, um mehrere bool-Ausdrücke zu kombinieren, meist für Bedingungsprüfungen.
| Operatoren | Bedeutung | Beschreibung |
|---|---|---|
| && | Logisches AND | Gibt nur true zurück, wenn beide Seiten true sind. |
| || | Logisches OR | Gibt true zurück, wenn mindestens eine Seite true ist. |
| ! | Logisches NICHT | Negation: true wird zu false, false wird zu true |
Beispiel
bool isLoggedIn = true;
bool isAdmin = false;
// && AND: beide sind true
print(Eingeloggt und ist Admin: ${isLoggedIn && isAdmin}); // false
// || OR: mindestens eine Seite ist true
print(Angemeldet oder ist Admin: ${isLoggedIn || isAdmin}); // true
// ! NOT: Negation
print(Nicht angemeldet: ${!isLoggedIn}); // false
// Kurzschlussauswertung: Wenn die linke Seite das Ergebnis bereits bestimmt, wird die rechte Seite nicht ausgeführt
int age = 20;
// age > 18 ist bereits true, aber die rechte Seite muss ebenfalls geprüft werden
print(Volljährig und hat Berechtigung: ${age >= 18 && isAdmin});
// age < 18 ist bereits false, also wird die rechte Seite von && direkt übersprungen
print('Minderjährig und hat Berechtigung: ${age < 18 && isAdmin}');
}
登录且是管理员: false 登录或是管理员: true 未登录: false 成年且有权限: false 未成年且有权限: false
Dart verwendetKurzschlussauswertungBei && wird die rechte Seite nicht ausgewertet, wenn die linke Seite false ist; bei || wird die rechte Seite nicht ausgewertet, wenn die linke Seite true ist.
Diese Funktion kann verwendet werden, um Null-Pointer-Probleme zu vermeiden.
Beispiel
Praktische Anwendungen der Kurzschlussauswertung:
String? username;
// Sicherheitsprüfung: username ist nicht null und length ist größer als 3
// Wenn username null ist, wird die rechte Seite von && nicht ausgeführt, wodurch ein Nullzeigerfehler vermieden wird
if (username != null && username.length > 3) {
print('Gültiger Benutzername');
} else {
print('Benutzername ungültig oder zu kurz');
}
}
Username is invalid or too short.
Zuweisungsoperatoren
Du bist bereits mit dem grundlegenden Zuweisungsoperator = vertraut.
Dart bietet außerdem zusammengesetzte Zuweisungsoperatoren, um häufige "Berechnen und dann Zuweisen"-Operationen zu vereinfachen.
| Operatoren | Äquivalente Syntax | Beispiel (wenn 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 |
Beispiel
int score = 0;
// 10 Punkte für jede richtige Antwort hinzufügen
score += 10;
print('Richtige Antwort für Frage 1: $score');
score += 10;
print('Richtige Antwort für Frage 2: $score');
// Falsche Antwort zieht 5 Punkte ab
score -= 5;
print('1 Frage falsch beantwortet: $score');
// Punktzahl verdoppeln
score *= 2;
print('Belohnung verdoppelt: $score');
print('BEISPIEL Endpunktzahl: $score');
}
答对第1题: 10 答对第2题: 20 答错1题: 15 奖励翻倍: 30 EXAMPLE 最终得分: 30
Bedingte Operatoren: ?? und ??=
Diese beiden Operatoren sind speziell für die Behandlung von Nullwerten konzipiert und ein wichtiger Teil von Darts Nullsicherheitssystem.
?? Null-Koaleszenz-Operator
Wenn der linke Ausdruck nicht null ist, gib seinen Wert zurück; andernfalls gib den rechten Wert zurück.
??= Null-bewusster Zuweisungsoperator
Wenn die Variable derzeit null ist, weise ihr den Wert auf der rechten Seite zu; andernfalls lasse sie unverändert.
Beispiel
// ?? Null-Koaleszenz
String? nickname;
String displayName = nickname ?? 'EXAMPLE user';
print(displayName); // EXAMPLE user
nickname = 'Little R';
displayName = nickname ?? 'EXAMPLE user';
print(displayName); // Little R
// Verkettete ?? funktioniert auch
String? a;
String? b;
String result = a ?? b ?? 'Default value';
print(result); // Default value
// ??= Null-Coalescing-Zuweisung
int? count;
count ??= 0; // count ist null, 0 zuweisen
print(count); // 0
count ??= 100; // count ist bereits 0 (nicht null), keine Zuweisung
print(count); // 0 (unverändert)
}
EXAMPLE 用户 小R 默认值 0 0
Ternärer Bedingungsoperator ? :
Dies ist Darts einziger Drei-Operanden-Operator, eine kompakte Version von if-else.
Beispiel
int score = 75;
// Syntax: Bedingung ? Wert wenn wahr : Wert wenn falsch
String result = score >= 60 ? 'Pass' : 'Fail';
print('BEISPIEL Prüfungsergebnis: $result');
// Kann verschachtelt werden (aber es wird nicht empfohlen, zwei Ebenen zu überschreiten; die Lesbarkeit verschlechtert sich)
String grade = score >= 90 ? 'Ausgezeichnet' : score >= 60 ? 'Bestanden' : 'Nicht bestanden';
print('Bewertung: $grade');
}
EXAMPLE 考试结果: 及格 评级: 及格
Typüberprüfungsoperatoren: is und as
is wird verwendet, um zu prüfen, ob ein Objekt zu einem Typ gehört, as wird für die Typumwandlung verwendet.
Beispiel
// is: Typüberprüfung
var name = 'EXAMPLE';
print('Ist name ein String? ${name is String}'); // true
print('Ist name ein int? ${name is int}'); // false
// is!: kein bestimmter Typ
print('Ist name kein int? ${name is! int}'); // true
// as: Typumwandlung
Object obj = 'Hallo, Dart!';
// Object-Typ in String umwandeln, um String-Methoden zu verwenden
String str = obj as String;
print(str.toUpperCase());
// Sichere Typüberprüfung + Konvertierung
Object maybeString = 42;
if (maybeString is String) {
// In einem Zweig, in dem die is-Prüfung wahr ist, wird die Variable automatisch in diesen Typ „hochgestuft“
print(maybeString.length); // Keine as-Konvertierung nötig
} else {
print('Kein String, Wert ist: $maybeString');
}
}
name 是 String 吗? true name 是 int 吗? false name 不是 int 吗? true HELLO, DART! 不是字符串，值是: 42
Bevorzuge die Verwendung von is zur Typprüfung. In einem Bedingungszweig, in dem is zu true ausgewertet wird, stuft Dart die Variable automatisch in den Zieltyp hoch (Type Promotion), sodass as nicht zum Casting verwendet werden muss. Verwende as nur, wenn du dir über den Typ sicher bist, der Compiler ihn aber nicht ableiten kann.
Überblick über die Operatorrangfolge
Wenn ein Ausdruck mehrere Operatoren enthält, wertet Dart sie gemäß ihrer Rangfolge von der höchsten zur niedrigsten aus.
Wenn du dir bei der Rangfolge unsicher bist, ist die sicherste Vorgehensweise,Klammern zu verwenden, um die Berechnungsreihenfolge zu verdeutlichen。
| Rangfolge | Operatoren | Beschreibung |
|---|---|---|
| Höchste | () [] . ?. | Klammern, Indizes, Memberzugriff |
| ! ~ - ++ -- | Unäre Operatoren | |
| * / % ~/ | Multiplikation, Division und Rest | |
| + - | Additiv | |
| < <= > >= | Relationaler Vergleich | |
| == != | Gleichheitsprüfung | |
| && | Logisches AND | |
| || | Logisches OR | |
| ?? | Null-Koaleszenz | |
| ? : | Ternärer Bedingungsoperator | |
| = += -= *= usw. | Zuweisung (niedrigste Priorität) |
Beispiel
// Verlass dich nicht auf die Priorität – verwende Klammern, um deine Absicht deutlich zu machen.
int result = ((10 + 5) * 2) - (8 ~/ 3);
print('Berechnungsergebnis: $result'); // 28
// Ohne Klammern kann das Ergebnis völlig anders sein.
// 10 + 5 * 2 - 8 ~/ 3 ergibt 18 (Multiplikation und Division vor Addition und Subtraktion)
int result2 = 10 + 5 * 2 - 8 ~/ 3;
print('Ohne Klammern: $result2'); // 18
}
计算结果: 28 不加括号: 18Weitere Erweiterungen