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

void main() {
  // 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

void main() {
  // 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

void main() {
  // 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ÄnderbarZuweisungszeitpunktTypische Szenarien
varJaAnyNormale Variablen, deren Werte sich ändern können
finalNicht änderbarLaufzeitAus einer API abgerufene Konfiguration, die aktuelle Zeit.
constNicht änderbarKompilierzeitMathematische 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

void main() {
  // 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

import 'dart:math';  // Mathematik-Bibliothek importieren

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

void main() {
  // 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

void main() {
  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

void main() {
  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

void main() {
  // 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

ManipulatorenBeschreibungBeispiel
??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

void main() {
  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

void main() {
  // 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 &#x2194; 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: true
Weitere Erweiterungen