Dart cheat sheet

enum Currency {
  gbp('£'),
  usd(r'$');
 
  const Currency(this.symbol);
  final String symbol;
}
 
class Money implements Comparable<Money> {
  final int pence;
  final Currency currency;
 
  const Money(this.pence, [this.currency = Currency.gbp]);
 
  Money.pounds(double pounds, [Currency currency = Currency.gbp])
      : this((pounds * 100).round(), currency);
 
  Money operator +(Money other) {
    if (other.currency != currency) {
      throw ArgumentError('Cannot add ${other.currency.name} to ${currency.name}');
    }
    return Money(pence + other.pence, currency);
  }
 
  @override
  int compareTo(Money other) => pence.compareTo(other.pence);
 
  @override
  bool operator ==(Object other) =>
      other is Money && other.pence == pence && other.currency == currency;
 
  @override
  int get hashCode => Object.hash(pence, currency);
 
  @override
  String toString() {
    final sign = pence < 0 ? '-' : '';
    final whole = pence.abs() ~/ 100;
    final fraction = (pence.abs() % 100).toString().padLeft(2, '0');
    return '$sign${currency.symbol}$whole.$fraction';
  }
}
 
void main() {
  const price = Money(1999);
  final total = price + Money.pounds(5);
  print(total);                                  // £24.99
  print([price, const Money(500)]..sort());      // [£5.00, £19.99]
  print(total == Money(2499));                   // true
 
  try {
    price + const Money(100, Currency.usd);
  } on ArgumentError catch (e) {
    print(e.message);                            // Cannot add usd to gbp
  }
}

sealed class Shape {}
 
class Circle extends Shape {
  Circle(this.radius);
  final double radius;
}
 
class Rectangle extends Shape {
  Rectangle(this.width, this.height);
  final double width, height;
}
 
class Triangle extends Shape {
  Triangle(this.base, this.height);
  final double base, height;
}
 
double area(Shape shape) => switch (shape) {
      Circle(:final radius) => 3.14159 * radius * radius,
      Rectangle(:final width, :final height) when width == height => width * width,
      Rectangle(:final width, :final height) => width * height,
      Triangle(:final base, :final height) => base * height / 2,
    };
 
(double total, Shape largest) summarise(List<Shape> shapes) {
  var total = 0.0;
  var largest = shapes.first;
  for (final shape in shapes) {
    total += area(shape);
    if (area(shape) > area(largest)) largest = shape;
  }
  return (total, largest);
}
 
void main() {
  final shapes = [Circle(1), Rectangle(2, 3), Triangle(4, 5)];
  final (total, largest) = summarise(shapes);
  print(total.toStringAsFixed(2));   // 19.14
  print(largest.runtimeType);        // Triangle
}

mixin Loggable {
  final List<String> history = [];
  void log(String event) => history.add('$runtimeType: $event');
}
 
mixin Discountable {
  int get pence;
  int discounted(int percent) => pence * (100 - percent) ~/ 100;
}
 
class Order with Loggable, Discountable {
  Order(this.id, this.pence) {
    log('created');
  }
 
  final int id;
  @override
  final int pence;
 
  void ship() => log('shipped');
}
 
extension on Order {
  bool get isNew => history.length == 1;
}
 
void main() {
  final order = Order(42, 2000);
  print(order.isNew);           // true
  order.ship();
  print(order.history);         // [Order: created, Order: shipped]
  print(order.discounted(15));  // 1700
}

import 'dart:convert';
 
class Repo {
  const Repo({
    required this.id,
    required this.fullName,
    required this.stars,
    this.description,
  });
 
  final int id;
  final String fullName;
  final int stars;
  final String? description;
 
  factory Repo.fromJson(Map<String, dynamic> json) {
    return switch (json) {
      {
        'id': int id,
        'full_name': String fullName,
        'stargazers_count': int stars,
      } =>
        Repo(
          id: id,
          fullName: fullName,
          stars: stars,
          description: json['description'] as String?,
        ),
      _ => throw FormatException('Not a repo: $json'),
    };
  }
 
  Map<String, dynamic> toJson() => {
        'id': id,
        'full_name': fullName,
        'stargazers_count': stars,
        'description': description,
      };
}
 
void main() {
  const body = '''
{ "id": 1, "full_name": "dart-lang/sdk", "stargazers_count": 10500, "description": null }
''';
 
  final repo = Repo.fromJson(jsonDecode(body) as Map<String, dynamic>);
  print('${repo.fullName} ${repo.stars}'); // dart-lang/sdk 10500
 
  print(const JsonEncoder.withIndent('  ').convert(repo));
 
  try {
    Repo.fromJson({'id': '1'});
  } on FormatException catch (e) {
    print(e.message); // Not a repo: {id: 1}
  }
}

import 'dart:async';
 
class Profile {
  const Profile(this.id, this.name);
  final int id;
  final String name;
}
 
class NotFound implements Exception {
  const NotFound(this.id);
  final int id;
}
 
Future<Profile> fetchProfile(int id) async {
  await Future.delayed(const Duration(milliseconds: 100)); // stands in for a network call
  if (id <= 0) throw NotFound(id);
  return Profile(id, 'User $id');
}
 
Stream<Profile> watchProfiles(List<int> ids) async* {
  for (final id in ids) {
    try {
      yield await fetchProfile(id);
    } on NotFound catch (e) {
      print('Skipping ${e.id}');
    }
  }
}
 
Future<void> main() async {
  final watch = Stopwatch()..start();
  final profiles = await Future.wait([1, 2, 3].map(fetchProfile));
  print(profiles.map((p) => p.name).toList()); // [User 1, User 2, User 3]
  print(watch.elapsedMilliseconds < 250);      // true: they ran at the same time
 
  try {
    await Future.wait([fetchProfile(1), fetchProfile(-1)]);
  } on NotFound catch (e) {
    print('No profile ${e.id}');                // No profile -1
  }
 
  await for (final profile in watchProfiles([1, -1, 2])) {
    print(profile.name);                        // User 1, Skipping -1, User 2
  }
 
  final names = await watchProfiles([3, 4]).map((p) => p.name).toList();
  print(names);                                 // [User 3, User 4]
}

# pubspec.yaml
name: greeter
description: Says hello from the command line.
version: 1.0.0
publish_to: none
 
environment:
  sdk: ^3.13.0
 
dependencies:
  args: ^2.7.0
 
dev_dependencies:
  lints: ^6.0.0
  test: ^1.25.0

// lib/greeter.dart
/// Builds the greeting for [name], falling back to "world".
String greeting(String name) => 'Hello, ${name.isEmpty ? 'world' : name}!';

// bin/greeter.dart
import 'package:args/args.dart';
import 'package:greeter/greeter.dart';
 
void main(List<String> arguments) {
  final parser = ArgParser()..addOption('name', abbr: 'n', defaultsTo: '');
  final results = parser.parse(arguments);
  print(greeting(results.option('name')!));
}

// test/greeter_test.dart
import 'package:greeter/greeter.dart';
import 'package:test/test.dart';
 
void main() {
  test('greets by name', () {
    expect(greeting('Ada'), 'Hello, Ada!');
  });
 
  group('empty name', () {
    test('falls back to world', () {
      expect(greeting(''), 'Hello, world!');
    });
  });
}