Dart: Spickzettel

Die Sprache hinter Flutter

Ausführen: Online im DartPad (dartpad.dev) oder lokal: Datei main.dart speichern und mit dart run main.dart starten.

dart main.dart              # Datei ausführen
dart create meine_app       # Projekt anlegen
dart run                    # Projekt starten
dart test                   # Tests
dart format .               # Code formatieren
dart analyze                # statische Analyse
dart pub add http           # Paket hinzufügen
dart compile exe main.dart  # native ausführbare Datei

void main() {
  int a = 17, b = 5;
  print('${a + b} ${a - b} ${a * b} ${a / b} ${a ~/ b} ${a % b}');   // ~/ : Ganzzahldivision
  print('${-17 % 5} ${(-17).remainder(5)} ${2 * 3 + 4} ${a.isEven} ${a.isOdd}');
  double d = 3.14159;
  print('${d.round()} ${d.floor()} ${d.ceil()} ${d.toStringAsFixed(2)} ${d.truncate()}');
  print('${int.parse('42') + 1} ${double.parse('2.5')} ${int.tryParse('x')} ${42.toString()}');
  print('${10.compareTo(5)} ${(3.7).abs()} ${(-3).abs()} ${5.clamp(1, 3)} ${1e3} ${0.1 + 0.2}');
  print('${a.toDouble()} ${d.toInt()} ${255.toRadixString(16)} ${int.parse('ff', radix: 16)}');

  String s = 'Hallo Welt';
  print('${s.length} ${s[0]} ${s.substring(0, 5)} ${s.toUpperCase()} ${s.toLowerCase()}');
  print('${s.contains('Welt')} ${s.startsWith('Hal')} ${s.indexOf('W')} ${s.replaceAll('l', 'L')}');
  print('${s.split(' ')} ${'  trim '.trim()} ${'ab' * 3} ${'x'.padLeft(3, '0')} ${s.codeUnitAt(0)}');
  print('${s.split('').reversed.join()} ${'a,b,,c'.split(',')}');
  print('Zeile 1\nZeile 2\tTab \\ \$ ');
  print(r'Roh: $kein\n Ersatz');
  print('''Mehrzeiliger
String''');
  StringBuffer sb = StringBuffer();
  for (var i = 0; i < 3; i++) { sb.write('$i,'); }
  print(sb.toString());
}

int addiere(int a, int b) => a + b;                 // Pfeilsyntax für Einzeiler

String gruss(String name, {String anrede = 'Hallo', int? alter}) {      // benannte Parameter
  var text = '$anrede, $name!';
  if (alter != null) text += ' ($alter)';
  return text;
}

int summe(List<int> zahlen, [int start = 0]) {       // optionale Positionsparameter
  var s = start;
  for (final z in zahlen) { s += z; }
  return s;
}

(int, int) minMax(List<int> liste) {                 // Record als Rückgabe (Dart 3)
  return (liste.reduce((a, b) => a < b ? a : b), liste.reduce((a, b) => a > b ? a : b));
}

int fakultaet(int n) => n <= 1 ? 1 : n * fakultaet(n - 1);

Function(int) addierer(int n) => (x) => x + n;       // Closure als Rückgabewert

void main() {
  print(addiere(2, 3));
  print(gruss('Mia'));
  print(gruss('Tom', anrede: 'Hi', alter: 25));
  print(summe([1, 2, 3]));
  print(summe([1, 2, 3], 10));
  final (kleinster, groesster) = minMax([4, 9, 1, 7]);
  print('$kleinster $groesster');
  print(fakultaet(10));
  var plus5 = addierer(5);
  print(plus5(10));

  var verdopple = (int x) => x * 2;                  // anonyme Funktion
  print([1, 2, 3].map(verdopple).toList());
  print([1, 2, 3].map((e) => e * e).toList());
}

class Konto {
  final String inhaber;
  double _stand;                       // _ macht Member privat (pro Datei)
  static int anzahl = 0;

  Konto(this.inhaber, [this._stand = 0]) {      // Kurzform: Parameter direkt in Felder
    anzahl++;
  }

  Konto.leer(String inhaber) : this(inhaber, 0);          // benannter Konstruktor

  double get stand => _stand;                              // Getter
  set stand(double wert) {                                 // Setter mit Prüfung
    if (wert < 0) throw ArgumentError('Stand darf nicht negativ sein');
    _stand = wert;
  }

  void einzahlen(double betrag) {
    if (betrag <= 0) throw ArgumentError.value(betrag, 'betrag', 'muss positiv sein');
    _stand += betrag;
  }

  @override
  String toString() => '$inhaber: ${_stand.toStringAsFixed(2)}';
}

void main() {
  var k = Konto('Mia', 100);
  k.einzahlen(50);
  print(k);
  print('${k.stand} ${Konto.anzahl}');
  var leer = Konto.leer('Tom');
  print(leer);
  try {
    k.einzahlen(-5);
  } on ArgumentError catch (e) {
    print('Fehler: ${e.message}');
  }
  k.stand = 10;
  print(k.stand);
  var kette = StringBuffer()..write('a')..write('b')..write('c');       // Kaskade ..
  print(kette);
}

Future<String> ladeNutzer(int id) async {
  await Future.delayed(Duration(milliseconds: 50));
  if (id < 0) throw ArgumentError('ungültige ID');
  return 'Nutzer $id';
}

Future<void> main() async {
  print(await ladeNutzer(1));

  var ergebnisse = await Future.wait([ladeNutzer(2), ladeNutzer(3), ladeNutzer(4)]);   // parallel
  print(ergebnisse);

  try {
    await ladeNutzer(-1);
  } catch (e) {
    print('Fehler: $e');
  } finally {
    print('fertig');
  }

  var f = Future.value(42).then((v) => v * 2);       // Variante mit then
  print(await f);
  print(await Future.any([
    Future.delayed(Duration(milliseconds: 100), () => 'langsam'),
    Future.delayed(Duration(milliseconds: 10), () => 'schnell'),
  ]));
  var mitTimeout = await Future.delayed(Duration(milliseconds: 200), () => 'spät')
      .timeout(Duration(milliseconds: 20), onTimeout: () => 'Timeout');
  print(mitTimeout);
}

flutter create meine_app
cd meine_app
flutter run               # startet auf Gerät/Emulator/Browser
flutter test
flutter build apk         # Android
flutter build web

void main() {
  const text = '''
Dart ist schnell. Dart ist modern, und Dart macht Spaß!
Modern und schnell: das ist Dart.
''';
  final woerter = RegExp(r'[a-zäöüß]+')
      .allMatches(text.toLowerCase())
      .map((m) => m.group(0)!)
      .toList();

  final haeufigkeit = <String, int>{};
  for (final w in woerter) {
    haeufigkeit.update(w, (n) => n + 1, ifAbsent: () => 1);
  }
  final top = haeufigkeit.entries.toList()
    ..sort((a, b) {
      final c = b.value.compareTo(a.value);
      return c != 0 ? c : a.key.compareTo(b.key);
    });

  print('${woerter.length} Wörter, ${haeufigkeit.length} verschiedene');
  for (final e in top.take(4)) {
    print('${e.key.padRight(8)} ${'#' * e.value} ${e.value}');
  }
  print('Längstes Wort: ${woerter.reduce((a, b) => a.length >= b.length ? a : b)}');
}

var x = 1;  final y = 2;  const z = 3;  int? n;  late String s;
int f(int a, {int b = 0, required String c}) => a + b;       void g([int a = 1]) {}
if (...) {} else {}     switch (x) { case 1: ... }     for (var i = 0; i < n; i++) {}     for (final e in liste) {}
class A extends B with M implements I { A(this.x); final int x; }     abstract class T {}     mixin M {}     enum E { a, b }
extension X on String { int get doppelt => length * 2; }     sealed class S {}
Future<int> h() async { return await andere(); }     Stream<int> s() async* { yield 1; }
try {} on Fehler catch (e, st) {} finally {}     throw Exception('...');