Cheat Sheet de Dart

var name = 'Alice';

Variable con tipo inferido

String name = 'Alice';

Variable con tipo explícito

final age = 30;

Constante en tiempo de ejecución (asignación única)

const pi = 3.14;

Constante en tiempo de compilación

late String description;

No-nulable con inicialización diferida

int double num String bool

Tipos integrados

dynamic x = 'anything';

Tipo dinámico (any)

var name = 'World';
print('Hello, $name!');

Interpolación de cadena

print('Sum: ${a + b}');

Interpolar expresión

if (x > 0) { ... } else if (x == 0) { ... } else { ... }

If/else

for (var i = 0; i < 10; i++) { ... }

Bucle for clásico

for (var item in list) { ... }

Bucle for-in

list.forEach((item) => print(item));

Iteración con forEach

while (condition) { ... }

Bucle while

switch (x) {
  case 1: ...; break;
  default: ...;
}

Sentencia switch

String? maybeName;

Tipo nullable

name ?? 'Anonymous'

Operador de coalescencia nula

name ??= 'default';

Asignar si es null

user?.name?.length

Cadena con null-aware

name!

Aserción no-nulo (bang)

if (name != null) { print(name.length); }

Promoción a no-nulo tras check

var list = [1, 2, 3];

Literal de lista

List<int> list = [1, 2, 3];

Lista tipada

list.add(4);

Añadir elemento

list.removeAt(0);

Eliminar por índice

list.where((x) => x > 2).toList()

Filtrar lista

list.map((x) => x * 2).toList()

Transformar cada elemento

list.reduce((a, b) => a + b)

Reducir a un solo valor

var set = {1, 2, 3};

Literal de set

var map = {'a': 1, 'b': 2};

Literal de map

map['key'] = value;

Establecer valor del map

map.containsKey('key')

Comprobar si existe la clave

[...list1, ...list2]

Operador spread

[if (c) 'a', for (var i in list) i]

If/for en colecciones

int add(int a, int b) => a + b;

Función flecha

void greet(String name) {
  print('Hello $name');
}

Función con nombre

void greet({String name = 'World'}) {}

Parámetros nombrados con defaults

void greet({required String name}) {}

Parámetro nombrado obligatorio

void log(String msg, [String? tag]) {}

Parámetro posicional opcional

var f = (int x) => x * 2;

Función anónima (lambda)

class User {
  String name;
  int age;
  User(this.name, this.age);
}

Clase con constructor

User({required this.name, this.age = 0});

Parámetros de constructor nombrados

User.guest() : name = 'Guest', age = 0;

Constructor nombrado

class Admin extends User { ... }

Herencia

class Duck with Swimmer, Flyer { ... }

Mixins

abstract class Shape { double area(); }

Clase abstracta

class Point {
  final double x, y;
  const Point(this.x, this.y);
}

Clase inmutable con const constructor

String get fullName => '$first $last';

Getter

set age(int v) { _age = v; }

Setter

static const version = '1.0';

Miembro estático

Future<String> fetch() async {
  return 'data';
}

Función asíncrona

final data = await fetch();

Await de un Future

try {
  await risky();
} catch (e) { ... }

Manejo de errores asíncrono

Stream<int> counter() async* {
  for (var i = 0; ; i++) yield i;
}

Generador async (Stream)

await for (var event in stream) { ... }

Escuchar un stream

Future.delayed(Duration(seconds: 1), () => 'done')

Future con delay

Future.wait([f1, f2, f3])

Esperar múltiples futures