Dart Spickzettel

Q: Wie funktioniert Null Safety in Dart?

In Dart ist jeder Typ standardmäßig nicht-nullbar - `int count` kann niemals `null` halten. Um null zu erlauben, fügst du ein `?` hinzu (`String? name`), und der Compiler zwingt dich dann, den null-Fall zu behandeln. Helfer machen das kompakt: `?.` für null-bewussten Zugriff, `??` für einen Ausweichwert und `!`, um einen Wert als nicht-null zuzusichern, wenn du sicher bist. Das fängt null-Fehler zur Compilezeit statt zur Laufzeit ab.

Q: Was ist ein Future und wie funktionieren async und await?

Ein `Future` steht für einen Wert, der später verfügbar sein wird, etwa das Ergebnis eines Netzwerkaufrufs. Eine Funktion als `async` zu markieren erlaubt dir die Verwendung von `await`, das die Ausführung pausiert, bis das Future abgeschlossen ist, und dir dann den Wert liefert - so schreibst du asynchronen Code, der sich von oben nach unten wie synchroner Code liest. Umschließe awaits mit `try/catch`, um Fehler zu behandeln.

Zuletzt aktualisiert 27. Mai 2026

Live im Dart-Playground ausprobieren Dart kostenlos lernen

Hello World & Programmaufbau

Jedes Dart-Programm beginnt bei der Top-Level-Funktion main.

Operation	Syntax
Einstiegspunkt	`void main() { ... }`
Eine Zeile ausgeben	`print("Hello, World!");`
String-Interpolation	`print("Hi $name");`
Ausdruck in Interpolation	`print("Sum: ${a + b}");`
Kommentar	`// this is a comment`
Mehrzeiliger Kommentar	`/* ... */`
Eine Bibliothek importieren	`import 'dart:math';`
Eine Datei ausführen	`dart run main.dart`

Variablen & Typen

Dart ist statisch typisiert, kann Typen aber mit var ableiten.

Operation	Syntax
Abgeleitete Variable	`var age = 30;`
Expliziter Typ	`int age = 30;`
Compilezeit-Konstante	`const pi = 3.14;`
Laufzeit-Konstante	`final name = getName();`
Basistypen	`int`, `double`, `String`, `bool`
Dynamischer Typ	`dynamic x = 5;`
Typumwandlung	`int.parse("42")`, `n.toString()`
Typ prüfen	`x is String`, `x as String`

Null Safety

Typen sind standardmäßig nicht-nullbar; füge ? hinzu, um null zu erlauben.

Operation	Syntax
Nicht-nullbar (Standard)	`int count = 0;`
Nullbarer Typ	`String? name;`
Null-bewusster Zugriff	`user?.name`
Null-Coalescing	`name ?? "default"`
Null-Coalescing-Zuweisung	`name ??= "default";`
Nicht-null zusichern	`name!`
Späte Initialisierung	`late String value;`
Null-bewusster Spread	`[...?maybeList]`

Strings

Strings unterstützen einfache, doppelte und dreifache Anführungszeichen.

Operation	Syntax
Länge	`s.length`
Groß-/Kleinschreibung	`s.toUpperCase()`, `s.toLowerCase()`
Interpolation	`"Total: $price"`
Verketten	`"foo" + "bar"`
Enthält	`s.contains("ell")`
Beginnt / endet mit	`s.startsWith("he")`
Aufteilen	`"a,b,c".split(",")`
Ersetzen	`s.replaceAll("a", "b")`
Teilstring	`s.substring(0, 3)`
Trimmen	`s.trim()`

Collections (List, Map, Set)

Drei zentrale Collection-Typen mit Literal-Syntax.

Operation	Syntax
List-Literal	`var nums = [1, 2, 3];`
Zur Liste hinzufügen	`nums.add(4);`
Zugriff / Länge	`nums[0]`, `nums.length`
Map / where	`nums.map((n) => n * 2)`, `nums.where((n) => n > 1)`
Map-Literal	`var ages = {"Ada": 30};`
Map-Zugriff	`ages["Ada"]`
Set-Literal	`var ids = {1, 2, 3};`
Spread-Operator	`var all = [...a, ...b];`
Collection if / for	`[if (show) 1, for (n in xs) n]`

Kontrollfluss

Bedingungen stehen in Klammern; switch unterstützt Patterns.

Operation	Syntax
If / else	`if (x > 0) { ... } else { ... }`
Ternär	`var r = x > 0 ? "pos" : "neg";`
Switch	`switch (n) { case 1: ...; default: ... }`
For-Schleife	`for (var i = 0; i < 10; i++) { ... }`
For-in-Schleife	`for (var item in items) { ... }`
forEach	`items.forEach((x) => print(x));`
While-Schleife	`while (x < 100) { ... }`
Do-while	`do { ... } while (x < 100);`
Break / continue	`break;`, `continue;`

Funktionen

Funktionen sind erstklassig; die Pfeil-Syntax kürzt einzelne Ausdrücke.

Operation	Syntax
Eine Funktion definieren	`int add(int a, int b) { return a + b; }`
Pfeil-Funktion	`int square(int x) => x * x;`
Optional positional	`void log(String m, [int? code]) { ... }`
Benannte Parameter	`void box({int w = 0, int h = 0}) { ... }`
Erforderlich benannt	`void box({required int w}) { ... }`
Anonyme Funktion	`var f = (x) => x * 2;`
Als Argument übergeben	`nums.map((n) => n * 2)`
Typedef	`typedef IntOp = int Function(int);`

Klassen & Konstruktoren

Klassen halten Zustand und Verhalten; Konstruktoren gibt es in mehreren Formen.

Operation	Syntax
Eine Klasse definieren	`class Point { int x; int y; }`
Konstruktor	`Point(this.x, this.y);`
Benannter Konstruktor	`Point.origin() : x = 0, y = 0;`
Instanz erstellen	`var p = Point(1, 2);`
Methode	`double dist() { ... }`
Getter	`int get area => w * h;`
Vererbung	`class Circle extends Shape { ... }`
super aufrufen	`super(args)`
Abstrakte Klasse	`abstract class Shape { ... }`
Interface implementieren	`class Dog implements Animal { ... }`

Async (Future / async-await)

Futures stehen für später verfügbare Werte; await pausiert, bis sie sich auflösen.

Operation	Syntax
Async-Funktion	`Future<int> load() async { ... }`
Auf ein Future warten	`var data = await load();`
Einen Wert zurückgeben	`return 42;` innerhalb einer Async-Funktion
Verzögerung	`await Future.delayed(Duration(seconds: 1));`
Fehler behandeln	`try { await load(); } catch (e) { ... }`
Then-Verkettung	`load().then((v) => print(v));`
Parallel ausführen	`await Future.wait([a(), b()]);`
Async-Stream	`await for (var x in stream) { ... }`

Die Dart-Syntax, die du am häufigsten brauchst, auf einer Seite. Dieser Dart-Spickzettel ist eine Schnellreferenz für die Kernsprache - Variablen und Typen, Null Safety, Strings, Collections, Kontrollfluss, Funktionen, Klassen sowie die Futures und async/await, mit denen du die Apps hinter Flutter schreibst.

Alles hier ist Standard-Dart und läuft auf dem offiziellen SDK. Kopiere, was du brauchst, oder probiere jeden Codeschnipsel live im Dart-Playground aus - keine Installation nötig.

Dart-Spickzettel FAQ

Ist dieser Dart-Spickzettel kostenlos?

Ja. Dieser Dart-Spickzettel ist völlig kostenlos, ohne erforderliche Anmeldung. Setze ein Lesezeichen und komm jederzeit wieder, wenn du einen Null-Safety-Operator, eine Collection-Methode oder ein Async-Muster nachschlagen möchtest.

Wie funktioniert Null Safety in Dart?

In Dart ist jeder Typ standardmäßig nicht-nullbar - int count kann niemals null halten. Um null zu erlauben, fügst du ein ? hinzu (String? name), und der Compiler zwingt dich dann, den null-Fall zu behandeln. Helfer machen das kompakt: ?. für null-bewussten Zugriff, ?? für einen Ausweichwert und !, um einen Wert als nicht-null zuzusichern, wenn du sicher bist. Das fängt null-Fehler zur Compilezeit statt zur Laufzeit ab.

Was ist ein Future und wie funktionieren async und await?

Ein Future steht für einen Wert, der später verfügbar sein wird, etwa das Ergebnis eines Netzwerkaufrufs. Eine Funktion als async zu markieren erlaubt dir die Verwendung von await, das die Ausführung pausiert, bis das Future abgeschlossen ist, und dir dann den Wert liefert - so schreibst du asynchronen Code, der sich von oben nach unten wie synchroner Code liest. Umschließe awaits mit try/catch, um Fehler zu behandeln.

Kann ich Dart online üben?

Ja. Öffne den Dart-Playground, um jeden Codeschnipsel aus diesem Spickzettel in deinem Browser auszuführen - kein SDK zu installieren. Wenn du Struktur möchtest, führt dich Coddys kostenloser interaktiver Dart-Kurs Schritt für Schritt von Null Safety und Collections zu Klassen und async/await.

Ist dieser Spickzettel für Anfänger geeignet?

Ja. Er ist von den häufigsten Themen (Variablen, Null Safety, Kontrollfluss) hin zu den fortgeschrittenen (Klassen, Futures, async/await) gegliedert, sodass du die oberen Abschnitte schon am ersten Tag nutzen und in den Rest hineinwachsen kannst.