Dart-Variablen und Datentypen
Variablen sind die grundlegenden Einheiten zum Speichern von Daten in einem Programm, und Datentypen bestimmen, welche Werte eine Variable speichern kann.
Dieses Kapitel führt in Variablendeklarationsmethoden, grundlegende Datentypen und den wichtigen Null-Safety-Mechanismus in Dart ein.
Methoden zur Variablendeklaration: var, final, const
Dart bietet drei Schlüsselwörter zum Deklarieren von Variablen, die jeweils für unterschiedliche Szenarien geeignet sind.
Ihre Unterschiede zu verstehen ist der erste Schritt, um Dart gut zu lernen.
var — Variablen mit Typinferenz
Bei mit var deklarierten Variablen wird der Typ automatisch aus dem Initialwert abgeleitet, und sobald der Typ festgelegt ist, kann er nicht mehr geändert werden.
Beispiel
// Typinferenz: Der Typ von name wird als String inferiert
var name = 'EXAMPLE';
// Typinferenz: Der Typ von age wird als int inferiert
var age = 10;
print('$name ist bereits $age Jahre alt');
// Der folgende Code verursacht einen Fehler — sobald der Typ festgelegt ist, kann man keinen Wert eines anderen Typs zuweisen
// name = 123; // Fehler: int kann nicht String zugewiesen werden
}
EXAMPLE 已经 10 年了
var ist nicht "untypisiert" oder "dynamisch"; sein Typ wird im Moment der Zuweisung festgelegt. Das ist völlig anders als var in JavaScript.
final — Laufzeitkonstante
Variablen, die mit final deklariert werden, können nur einmal zugewiesen werden, aber der Zeitpunkt der Zuweisung kann bis zur Laufzeit verzögert werden.
Beispiel
// final-Variable: Nach der Zuweisung kann sie nicht mehr geändert werden
final currentTime = DateTime.now();
print('Current time: $currentTime');
// Verzögerte Zuweisung ist ebenfalls erlaubt
final String greeting;
greeting = 'Hello, EXAMPLE!'; // Erste Zuweisung OK
// greeting = 'Hello again'; // Fehler: final-Variable kann nicht neu zugewiesen werden
print(greeting);
}
当前时间: 2026-06-12 10:30:00.000 Hello, EXAMPLE!
const — Konstanten zur Kompilierzeit
const ist strenger als final: Der Wert muss zur Kompilierzeit bestimmbar sein.
Beispiel
// const muss zur Kompilierzeit bestimmt werden
const siteName = 'EXAMPLE';
const maxUsers = 100;
print('Website: $siteName, maximale Benutzer: $maxUsers');
// Das Folgende verursacht einen Fehler: DateTime.now() ist ein Wert, der nur zur Laufzeit bestimmt werden kann
// const currentTime = DateTime.now(); // Fehler!
}
站点: EXAMPLE, 最大用户数: 100
Vergleichszusammenfassung der drei
| Schlüsselwörter | Änderbar | Zuweisungszeitpunkt | Typische Szenarien |
|---|---|---|---|
| var | Ja | Any | Normale Variablen, deren Werte sich ändern können |
| final | Nicht änderbar | Laufzeit | Aus einer API abgerufene Konfiguration, die aktuelle Zeit. |
| const | Nicht änderbar | Kompilierzeit | Mathematische Konstanten, feste Konfigurationen, Farbwerte |
Ein praktischer Vorschlag: Verwende standardmäßig final. Wenn du feststellst, dass du es ändern musst, ändere es zu var. Diese Gewohnheit macht Code sicherer und reduziert Fehler, die durch versehentliche Änderungen verursacht werden.
Numerische Typen: int und double
Die numerischen Typen von Dart werden in zwei Arten unterteilt: int (Ganzzahl) und double (Gleitkommazahl).
Ihre gemeinsame Oberklasse ist num.
Beispiel
// int: Ganzzahl, Bereich ist -2^63 bis 2^63-1
int viewCount = 10000;
int negativeNumber = -42;
// double: Gleitkommazahl mit doppelter Genauigkeit
double price = 9.99;
double pi = 3.1415926;
// num kann sowohl int als auch double akzeptieren
num someNumber = 10;
someNumber = 10.5; // Gültig
print(Aufrufe: $viewCount);
print(Preis: ¥$price);
print('Pi: $pi');
}
浏览次数: 10000 Price: ¥9.99 圆周率: 3.1415926
Gängige Methoden für Zahlen
Beispiel
void main() {
int a = -10;
double b = 3.7;
// Absolutwert
print(Absolutwert von a: ${a.abs()}); // 10
// Auf die nächste ganze Zahl runden
print(b gerundet: ${b.round()}); // 4
// Abrunden
print(b abgerundet: ${b.floor()}); // 3
// Aufrunden
print(b ceil: ${b.ceil()}); // 4
// String in Zahl umwandeln
int parsed = int.parse('42');
double parsedDouble = double.parse('3.14');
print(Geparstes Ergebnis: $parsed, $parsedDouble);
// Zufallszahl generieren (erfordert import 'dart:math')
var random = Random().nextInt(100);
print(Zufallszahl (0-99): $random);
}
a 的绝对值: 10 b 四舍五入: 4 b 向下取整: 3 b 向上取整: 4 解析结果: 42, 3.14 随机数(0-99): 67
String: String- und Interpolationssyntax.
String wird verwendet, um Text darzustellen. Dart-Strings unterstützen sowohl einfache als auch doppelte Anführungszeichen.
String-Interpolation ist eine der praktischsten Funktionen in Dart.
Beispiel
// Strings können einfache oder doppelte Anführungszeichen verwenden
String singleQuoted = 'Hello';
String doubleQuoted = "World";
// Mehrzeilige Strings: dreifache Anführungszeichen verwenden
String multiLine = '''
Dies ist die erste Zeile
Dies ist die zweite Zeile
Dies ist die dritte Zeile - EXAMPLE
''';
// String-Interpolation: $variableName oder ${expression} verwenden
String site = 'EXAMPLE';
int years = 10;
// $variableName: direkt auf die Variable verweisen
print(Willkommen bei $site);
// ${expression}: komplexe Ausdrücke einbetten
print($site ist seit ${years + 1} Jahren bei uns);
// Escape-Zeichen
print('Zeilenumbruchzeichen: erste Zeile\nzweite Zeile');
print('Tab: Spalte 1\tSpalte 2');
}
欢迎来到 EXAMPLE EXAMPLE 已经陪伴我们 11 年了 换行符: 第一行 第二行 制表符: 列1 列2
Gängige Methoden für Strings
Beispiel
String-Text = ' Hello, EXAMPLE! ';
// Führende und nachfolgende Leerzeichen entfernen
print('trim: [${text.trim()}]');
// In Groß- / Kleinschreibung umwandeln
print('Großschreibung: ${text.toUpperCase()}');
print('Kleinschreibung: ${text.toLowerCase()}');
// Ob es einen Teilstring enthält
print('Enthält EXAMPLE? ${text.contains('EXAMPLE')}');
// Ob es mit einer bestimmten Zeichenkette beginnt/endet
print(Beginnt mit einem Leerzeichen? ${text.startsWith(' ')}');
print('Endet mit !? ${text.trim().endsWith('!')}');
// Zeichenkettenersetzung
print(Ersetzen: ${text.replaceAll(EXAMPLE', 'DART')}');
// Zeichenkettenaufteilung
String csv = 'Dart,Flutter,Google';
List<String> items = csv.split(',');
print(Ergebnis der Aufteilung: $items);
// String-Verkettung
print(Verkettung: + 'Hello' + ', ' + 'World');
}
trim: [Hello, EXAMPLE!] 大写: HELLO, EXAMPLE! 小写: hello, example! 包含 EXAMPLE? true 以空格开头? true 以!结尾? true 替换: Hello, DART! 分割结果: [Dart, Flutter, Google] 拼接: Hello, World
Boolescher Wert bool
Der Typ bool hat nur zwei Werte: true und false.
Er wird hauptsächlich für bedingte Prüfungen verwendet, zusammen mit if-Anweisungen.
Beispiel
bool isLoggedIn = true;
bool hasPermission = false;
// Boolescher Ausdruck
bool canAccess = isLoggedIn && hasPermission; // AND: beide sind true
bool isGuest = !isLoggedIn; // NOT: negieren
print(Kann zugreifen: $canAccess);
print(Ist Gast: $isGuest);
// Vergleichsoperationen erzeugen bool-Werte
int age = 20;
bool isAdult = age >= 18;
print(Ist erwachsen: $isAdult);
// Direkt zur Bedingungsauswertung verwendet
if (isAdult) {
print(Willkommen bei EXAMPLE);
}
}
可以访问: false 是访客: false 是否成年: true 欢迎访问 EXAMPLE
Dart ist eine stark typisierte Sprache, und Bedingungsauswertungen akzeptieren nur den Typ bool. Das ist anders als in JavaScript – in Dart führen Schreibweisen wie if(0) oder if('') direkt zu einem Fehler.
Null-Sicherheit
Null-Sicherheit ist das wichtigste Merkmal, das in Dart 2.12 eingeführt wurde.
Die Kernidee ist: Standardmäßig dürfen alle Variablen nicht null sein, es sei denn, du deklarierst es explizit.
Nullbare und nicht-nullbare Typen
Das Anhängen von ? an den Typ gibt an, dass die Variable null sein kann.
Beispiel
// Nicht-Null-Typ: null kann nicht zugewiesen werden
String name = 'EXAMPLE';
// name = null; // Fehler! name darf nicht null sein
// Nullable-Typ: darf null sein
String? nickname;
nickname = null; // OK
nickname = 'R'; // Auch OK
print('Spitzname: $nickname');
// int? kann auch null sein
int? score;
print('Punktzahl: $score'); // Gibt null aus
}
昵称: R 分数: null
Operator zur Nullbehandlung
| Manipulatoren | Beschreibung | Beispiel |
|---|---|---|
| ?? | Wenn die linke Seite null ist, verwende den Wert der rechten Seite. | name ?? 'Standardname' |
| ??= | Wenn die Variable null ist, weise den Wert der rechten Seite zu. | name ??= 'default name' |
| ?. | Sicherer Zugriff: den Aufruf überspringen, wenn das Objekt null ist. | user?.name |
| ! | Nicht-Null-Zusicherung (mit Vorsicht verwenden) | name! |
Beispiel
String? username;
// ??-Operator: Wenn username null ist, Standardwert verwenden
String displayName = username ?? 'EXAMPLE Visitor';
print(displayName); // EXAMPLE Visitor
// ??=-Operator: Wenn null, Wert zuweisen
username ??= 'New user';
print(username); // New user
// ?. Sicherer Zugriff: nur aufrufen, wenn nicht null
String? maybeNull;
print(maybeNull?.length); // null (kein Fehler)
maybeNull = 'Hello';
print(maybeNull?.length); // 5
// ! Assertion: Ich bin sicher, dass es nicht null ist (wirft eine Exception, wenn null)
String definitelyNotNull = 'EXAMPLE';
print(definitelyNotNull!.length); // 6
}
EXAMPLE 访客 新用户 null 5 6
Versuchen Sie, den !-Assertion-Operator zu vermeiden. Wenn Sie ! häufig verwenden, deutet dies auf ein mögliches Problem mit Ihrem Typdesign hin. Bevorzugen Sie ??, ??= und ?., um null-Werte sicher zu behandeln.
Typumwandlung
In Dart können Werte unterschiedlicher Typen ineinander umgewandelt werden.
Beispiel
// Zahl → String
int count = 42;
String countStr = count.toString();
print('Number to string: $countStr (type: ${countStr.runtimeType})');
// String → Zahl
String priceStr = '19.99';
double price = double.parse(priceStr);
print('String zu Zahl: ¥$price');
// int ↔ double
int integer = 10;
double decimal = integer.toDouble();
print(int zu double: $decimal);
double pi = 3.14;
int piInt = pi.toInt(); // Nachkommateil abschneiden
print(double zu int (abgeschnitten): $piInt);
// Jeder Wert → string
bool flag = true;
print(bool zu String: ${flag.toString()});
// String → bool (erfordert manuelle Prüfung)
String boolStr = 'true';
bool parsed = boolStr == 'true';
print(String zu bool: $parsed);
}
数字转字符串: 42 (类型: String) 字符串转数字: ¥19.99 int 转 double: 10.0 double 转 int (截断): 3 bool 转字符串: true 字符串转 bool: trueWeitere Erweiterungen