Dot shorthands (Punktschreibweise)

Die Punktschreibweise .foo lässt den Typnamen weg. Der Compiler erkennt den Zieltyp aus dem Kontext, sodass kompakterer Dart-Code geschrieben werden kann. Beim Zugriff auf Enumerationswerte, statische Mitglieder und Konstruktoren muss nicht vollständig Typ.foo notiert werden.

Einfach ausgedrückt: Die Punktschreibweise erlaubt Ausdrücke in folgenden Formen, gefolgt von weiteren verketteten Aufrufen:

• Bezeichner .myValue
• Konstruktor .new()
• Konstantenerstellung const .myValue()

Beispiel

enum Status { none, running, stopped, paused }

class Point {
  final int x, y;
  Point(this.x, this.y);
  Point.origin() : x = 0, y = 0;
}


void main() {
    // Abgekürzter benannter Konstruktor
    Point origin = .origin(); // Entspricht Point.origin()
  
    // Abgekürzter Enum-Zugriff
	Status currentStatus = .running; // Entspricht Status.running

	// Abgekürzte statische Methode
	int port = .parse('8080'); // Entspricht int.parse('8080')

}Code-Sprache: Dart (dart)

Kontexttyp (Context type)

Die Punktschreibweise nutzt denKontexttyp, damit der Compiler den passenden Typmember ableiten kann.

Kontexttyp: Der Typ, den Dart an dieser Stelle erwartet, abhängig von der Position des Ausdrucks.

Beispiel: Status currentStatus = .running

Der Compiler erkennt, dass die Variable vom Typ Status sein muss und interpretiert .running daher als Status.running.

Lexikalische Struktur und Syntax

Die Kurzschreibweise für statische Mitglieder ist ein Ausdruck,der mit . beginnt. Lässt sich der Typ aus dem Kontext ermitteln, können statische Mitglieder, Konstruktoren und Enum-Konstanten abgekürzt angesprochen werden.

Anwendungsfälle

1. Enumerationen

Bei Zuweisungen oder switch-Auswertungen ist der Enum-Typ eindeutig, daher eignet sich die Kurzschreibweise hervorragend:

enum LogLevel { debug, info, warning, error }

String colorCode(LogLevel level) {
  return switch (level) {
    .debug => 'gray',
    .info => 'blue',
    .warning => 'orange',
    .error => 'red',
  };
}

void main() {
   // Aufruf
   String warnColor = colorCode(.warning); // Automatische Erkennung von LogLevel.warning
}Code-Sprache: Dart (dart)

2. Benannter Konstruktor / Fabrikkonstruktor

Unterstützt die Übergabe von Typparametern an generische Klassenkonstruktoren:

class Point {
  final double x, y;
  const Point(this.x, this.y);
  const Point.origin() : x = 0, y = 0;

  factory Point.fromList(List<double> list) => Point(list[0], list[1]);
}



void main() {
    Point origin = .origin();
	Point p1 = .fromList([1.0, 2.0]);

	// Generische Klasse
	List<int> intList = .filled(5, 0); // List.filled(5,0)
}Code-Sprache: Dart (dart)

3. Parameterloser Konstruktor .new

Mit .new ruft man den standardmäßigen unbenannten Konstruktor einer Klasse abgekürzt auf. Gut geeignet zur Masseninitialisierung von Feldern in Zustandsklassen; generische Parameter werden automatisch abgeleitet:

// Vor der Kurzschreibweise
late final AnimationController _animationController = AnimationController(vsync: this);
final ScrollController _scrollController = ScrollController();

// Mit Kurzschreibweise
late final AnimationController _animationController = .new(vsync: this);
final ScrollController _scrollController = .new();
final GlobalKey<ScaffoldMessengerState> scaffoldKey = .new();
Map<String, Map<String, bool>> properties = .new();Code-Sprache: Dart (dart)

4 Statische Mitglieder (statische Methoden, statische Felder)

int httpPort = .parse('80');        // int.parse('80')
BigInt bigIntZero = .zero;          // BigInt.zeroCode-Sprache: Dart (dart)

5 Konstantenausdrücke

In einem Konstantenkontext funktioniert die Kurzschreibweise, solange das angesprochene Mitglied eine Kompilierzeitkonstante ist:

enum Status { none, running }
class Point {
  final double x, y;
  const Point(this.x, this.y);
  const Point.origin() : x = 0.0, y = 0.0;
}

const Status defaultStatus = .running;
const Point myOrigin = .origin();
const List<Point> keyPoints = [.origin(), .new(1.0, 1.0)];Code-Sprache: Dart (dart)

Verkettete Aufrufe

Nach einer Punktschreibweise lassen sich Instanzmethoden und Eigenschaften verketten. Der Compiler löst zuerst das Ziel der Kurzschreibweise über den Kontext auf, der Rückgabetyp nachfolgender verketteter Aufrufe muss typkompatibel sein:

String lowerH = .fromCharCode(72).toLowerCase();
// String.fromCharCode(72).toLowerCase()
print(lowerH); // hCode-Sprache: JavaScript (javascript)

void main() {
    String lowerH = .fromCharCode(72).toLowerCase();
	// String.fromCharCode(72).toLowerCase()
	print(lowerH); // h
}Code-Sprache: Dart (dart)

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
h
Code-Sprache: CSS (css)

Dot shorthands (Punktschreibweise)