Chuleta de Dart

// Comentario de una línea
/* Comentario
   de varias líneas */

import 'dart:async';   // StreamController, Timer...  (solo si lo usas)

void main() {
  print('Hola Mundo');   // imprime y salta de línea
}

// main con argumentos (opcional):
// void main(List<String> args) { print(args); }

import 'dart:io';   // NO funciona en DartPad (solo con `dart run`)

stdout.write('Sin salto ');           // imprime sin salto de línea
String? texto = stdin.readLineSync(); // leer del teclado

int edad = 22;
double nota = 9.5;
String nombre = 'Marouan';
bool esEstudiante = true;

var ciudad = 'Barcelona';   // tipo inferido -> String (ya no puede cambiar de tipo)
dynamic dato = 'Hola';      // sin control de tipos: puede cambiar
dato = 42;                  // OK con dynamic, ERROR con var

final ahora = DateTime.now();  // se asigna una vez, valor calculado al EJECUTAR
const pi = 3.1416;             // constante fija al COMPILAR

print(edad.runtimeType);       // int
print('${nota.runtimeType}');  // double

String nom = 'Pau';
int edat = 20;

print('Hola $nom');                    // variable sola: $
print('El año que viene: ${edat + 1}'); // expresión: ${ }
print('Tipo: ${nom.runtimeType}');      // propiedad: ${ }
print('Hola ' + nom);                   // concatenar (menos usado)

print('Línea 1\nLínea 2');   // \n = salto de línea
print('');                   // línea en blanco
print('''
Texto
multilínea
''');

print("Ets major d'edat");    // comilla simple dentro de dobles
print('Ets major d\'edat');   // o escaparla con \'

String s = '  Hola Dart  ';
s.length          // 13
s.trim()          // 'Hola Dart'
s.toUpperCase()   // '  HOLA DART  '
s.toLowerCase()
s.contains('Dart')        // true
s.trim().split(' ')       // ['Hola', 'Dart']
s.trim().substring(0, 4)  // 'Hola'
s.isEmpty / s.isNotEmpty

String numText = '123';
int num = int.parse(numText);
print(num + 7);                       // 130

int seguro = int.tryParse('abc') ?? 0; // si falla, 0

bool a = true, b = false;
print('a && b -> ${a && b}');  // false (las dos deben ser true)
print('a || b -> ${a || b}');  // true  (basta una)
print('!a -> ${!a}');          // false (invierte)

print(7 / 2);   // 3.5
print(7 ~/ 2);  // 3
print(7 % 2);   // 1

String rol = esEstudiante ? 'Estudiante' : 'Profe';
print('Es ${esEstudiante ? "Estudiante" : "Profe"}');  // dentro de texto: ${ }

String nombre = 'Pau';   // NUNCA puede ser null
String? apodo;           // el ? permite null -> empieza valiendo null
print(apodo);            // null

// ??  -> valor por defecto si es null
print('Bienvenido, ${apodo ?? 'Invitado'}');

// ??= -> asigna SOLO si es null
int? puntuacion;
puntuacion ??= 100;   // 100
puntuacion ??= 50;    // sigue 100 (ya no era null)

// ?.  -> llama solo si no es null (si es null, devuelve null y no peta)
print(apodo?.length);   // null

// !   -> "te prometo que no es null" (si lo es, error en ejecución)
String seguro = apodo!;   // ⚠️ peta si apodo es null

// late -> no nullable, pero se inicializa más tarde
late String idUsuario;
idUsuario = 'U-01';

int temperatura = 18;

if (temperatura < 15) {
  print('Hace frío');
} else if (temperatura <= 25) {
  print('Templado');
} else {
  print('Hace calor');
}

String dia = 'dissabte';

switch (dia) {
  case 'dissabte':
  case 'diumenge':          // varios case seguidos = mismo bloque
    print('Fin de semana');
    break;
  default:
    print('Laborable');
}

switch (dia) {
  case 'dissabte' || 'diumenge':   // agrupar con ||
    print('Fin de semana');        // el break ya no es obligatorio
  default:
    print('Laborable');
}

// switch como EXPRESIÓN (devuelve un valor)
String tipo = switch (dia) {
  'dissabte' || 'diumenge' => 'Fin de semana',
  _ => 'Laborable',               // _ = cualquier otro caso
};

print(edat >= 18 ? 'Mayor de edad' : 'Menor de edad');

// for clásico
for (int i = 0; i < 5; i++) { print(i); }      // 0..4
for (int i = 10; i >= 1; i--) { print(i); }    // 10..1

// for-in: recorre elementos (como for-each de Java)
List<int> numeros = [2, 4, 6, 8, 10];
int suma = 0;
for (int n in numeros) { suma += n; }           // 30

// for con índice: numeros[i] es el VALOR, i es la POSICIÓN
for (int i = 0; i < numeros.length; i++) { suma += numeros[i]; }

// forEach con función flecha
numeros.forEach((n) => print(n));

// while: comprueba ANTES
var x = 1;
while (x <= 5) { print(x); x++; }   // sin x++ -> bucle infinito

// do-while: se ejecuta AL MENOS una vez, comprueba DESPUÉS
String pass;
do {
  pass = leerIntento();
} while (pass != '1234');   // termina con ; y SIN llaves detrás

// break / continue
for (int i = 0; i < 10; i++) {
  if (i == 3) continue;   // salta esta vuelta
  if (i == 6) break;      // sale del bucle
  print(i);
}

// Básica (las funciones van FUERA de main)
void saludar() {
  print('Hola!');
}

// Con retorno
int suma(int a, int b) {
  return a + b;
}

// Flecha => (una sola expresión)
int quadrat(int x) => x * x;

// Parámetro posicional OPCIONAL [ ] con valor por defecto
void mostrar(String texto, [String prefix = '>>']) {
  print('$prefix $texto');
}
mostrar('Hola');          // >> Hola
mostrar('Hola', '**');    // ** Hola

// Parámetros CON NOMBRE { } (estilo Flutter)
void presentar(String nom, {int edat = 0, String ciutat = 'Desconocida'}) {
  print('$nom, $edat años, $ciutat');
}
presentar('Pau');
presentar('Joan', ciutat: 'Olesa', edat: 30);   // cualquier orden

// required: con nombre pero OBLIGATORIO
void crear({required String id, String titulo = ''}) { }

// Una función que RECIBE otra función
int operar(int a, int b, int Function(int, int) func) {
  return func(a, b);
}

// Pasar una función con nombre (SIN paréntesis)
int sumar(int x, int y) => x + y;
operar(10, 5, sumar);                 // 15

// Pasar funciones anónimas (sin nombre)
operar(10, 5, (x, y) => x - y);       // 5
operar(10, 5, (x, y) {                // con llaves
  return x * y;
});                                   // 50

// En Flutter lo verás todo el rato:
// ElevatedButton(onPressed: () => print('Pulsado'), ...)

List<String> noms = ['Pau', 'Anna', 'Joan'];

noms.add('Marta');           // añade al final
noms.insert(1, 'Nil');       // inserta en posición 1
noms[0] = 'Pere';            // modifica posición 0
noms.remove('Joan');         // elimina por valor
noms.removeAt(0);            // elimina por posición
noms.addAll(['Laia', 'Marc']); // fusiona otra lista

noms.length       noms.isEmpty      noms.isNotEmpty
noms.first        noms.last         noms.contains('Anna')
noms.indexOf('Anna')               noms.sort()
noms.reversed.toList()

var todas = [...lista1, ...lista2];  // spread: une listas

for (String n in noms) { print(n); }
noms.forEach((n) => print('Hola, $n!'));

List<String> a;           // ❌ usarla da error de compilación (sin valor)
List<String>? b;          // vale null
b.add('x');               // ❌ error: puede ser null
b?.add('x');              // no peta, pero NO añade nada (sigue null)
List<String> c = [];      // ✅ correcto: lista vacía
c.add('x');

Set<String> asig = {'Android', 'Interfícies', 'BBDD'};

bool ok = asig.add('Android');   // false: ya existe -> se ignora
asig.add('Accés a dades');
asig.remove('BBDD');
asig.contains('Android');        // true
asig.length

for (String a in asig) { print(a); }
asig.forEach((a) => print(a));

Set<int> sinRepetidos = [1, 1, 2, 3].toSet();   // {1, 2, 3}

Map<String, double> notes = {
  'Pau': 7.5,
  'Anna': 4.0,
};

notes['Laia'] = 6.8;     // clave nueva -> añade
notes['Anna'] = 5.5;     // clave existente -> modifica
notes.remove('Pau');     // elimina por clave
notes['Xavi'];           // null (no existe)
notes.containsKey('Anna');
notes.keys     notes.values     notes.entries     notes.length

// Recorrer claves
for (String nom in notes.keys) {
  print('$nom -> ${notes[nom]}');
}

// Recorrer clave-valor
notes.forEach((nom, nota) => print('$nom: $nota'));

for (var e in notes.entries) {
  print('${e.key} = ${e.value}');
}

// Valores de distintos tipos (típico de JSON)
Map<String, dynamic> alumne = {
  'nom': 'Marouan',
  'edat': 22,
  'repetidor': false,
  'asignaturas': ['Android', 'Interfícies'],
};

List<int> nums = [1, 2, 3, 4, 5];

// map: transforma CADA elemento
var triple = nums.map((n) => n * 3).toList();        // [3, 6, 9, 12, 15]

// where: FILTRA (se queda con los que cumplen)
var pares = nums.where((n) => n % 2 == 0).toList();  // [2, 4]

// Set con map -> .toSet()
var min = {'DART', 'KoTLiN'}.map((p) => p.toLowerCase()).toSet();

// Map.map -> devuelve MapEntry(clave, valor)
Map<String, String> estados = notes.map(
  (nom, nota) => MapEntry(nom, nota >= 5 ? 'Aprobado' : 'Suspenso'),
);

// Filtrar un Map
var altas = Map.fromEntries(notes.entries.where((e) => e.value >= 8));

// Encadenar
var aprobados = notes.entries
    .where((e) => e.value >= 5)
    .map((e) => e.key.toUpperCase())
    .toList();

class Persona {
  String nom;
  int edat;

  // 1) Constructor corto con this.
  Persona(this.nom, this.edat);

  // 2) Constructor con lista de inicialización (va después de los :)
  // Persona(String n, int e) : nom = n, edat = e;

  // 3) Constructor CON NOMBRE (Dart no tiene sobrecarga)
  Persona.buit() : nom = 'Sin nombre', edat = 0;

  // toString: lo que sale al hacer print(objeto)
  @override
  String toString() => 'Persona(nombre: $nom, edad: $edat)';
}

var p1 = Persona('Anna', 25);   // sin new
var p2 = Persona.buit();
print(p1);                      // Persona(nombre: Anna, edad: 25)

class Alumne {
  String nom;
  late final String idAlumne;     // se asigna UNA vez, más tarde

  Alumne(this.nom, String id) {
    idAlumne = id;                // se asigna en el cuerpo { }
  }

  Alumne.fromMap(Map<String, dynamic> map)
      : nom = map['nom'] ?? 'Desconocido' {   // initializer list
    idAlumne = map['id'] ?? 'SIN-ID';         // cuerpo
  }
}

class Sensor {
  late final String id;
  String tipus;

  // [ ] = parámetro opcional con valor por defecto
  Sensor(String id, [this.tipus = 'genérico']) {
    this.id = id;   // this.id = atributo, id = parámetro
  }
}

class CompteBancari {
  double _saldo = 0;            // privado: empieza por _

  // getter: se usa SIN paréntesis -> compte.saldo
  double get saldo => _saldo;

  // setter con validación -> compte.saldo = 100;
  set saldo(double valor) {
    if (valor >= 0) {
      _saldo = valor;
    } else {
      print('Error: el saldo no puede ser negativo');
    }
  }

  void ingresar(double cantidad) {
    if (cantidad <= 0) return;
    saldo = saldo + cantidad;   // pasa por el setter
  }
}

class Rectangle {
  double ancho, alto;
  Rectangle(this.ancho, this.alto);
  double get area => ancho * alto;   // getter calculado
}

compte.saldo = 150;     // llama al setter
compte.saldo = -50;     // setter -> mensaje de error, no cambia
print(compte.saldo);    // llama al getter -> 150.0
print(pista.area);      // getter, SIN ()

class Animal {
  String nom;
  Animal(this.nom);

  void ferSoroll() {
    print('$nom hace un ruido genérico');
  }
}

class Gos extends Animal {
  Gos(String nom) : super(nom);   // llama al constructor del padre
  // Dart 3 (equivalente): Gos(super.nom);

  @override
  void ferSoroll() {              // sobrescribe el del padre
    print('$nom dice: ¡Guau!');
  }
}

// Mixin = bloque de métodos que "pegas" a una clase con with
mixin Caminador {
  void caminar() => print('Caminando...');
}
mixin Saltador {
  void saltar() => print('¡Saltando!');
}

class Robot with Caminador, Saltador {   // no hereda de nadie
  void presentar() => print('Soy un robot');
}

// Mixin CON restricción: solo para hijos de Animal
mixin Domesticable on Animal {
  void menjar() => print('$nom está comiendo');  // puede usar nom
}

class Gat extends Animal with Domesticable {
  Gat(String nom) : super(nom);
}

// class Roca with Domesticable {}   // ❌ ERROR: Roca no es un Animal

// Dart no tiene la palabra 'interface' de Java:
// se usa una clase abstracta + implements
abstract class Enviable {
  void enviar();          // método sin cuerpo
}

class Email implements Enviable {
  String destinatari;
  Email(this.destinatari);

  @override
  void enviar() => print('Enviando EMAIL a $destinatari');
}

class Whatsapp implements Enviable {
  String telefon;
  Whatsapp(this.telefon);

  @override
  void enviar() => print('Enviando WHATSAPP al $telefon');
}

// Implementar VARIAS
class Document implements Printable, Guardable { ... }

// Polimorfismo: una lista del tipo padre con hijos distintos
List<Enviable> mensajes = [Email('a@b.com'), Whatsapp('600 111 222')];
for (Enviable m in mensajes) {
  m.enviar();   // cada uno ejecuta SU versión
}

class Task {
  String id;
  String titol;
  bool completada;

  // Constructor con nombre: Task(id: 'T-01', titol: '...')
  Task({
    required this.id,
    required this.titol,
    this.completada = false,
  });

  // Map/JSON -> Objeto
  Task.fromJson(Map<String, dynamic> json)
      : id = json['id'] ?? '',
        titol = json['titol'] ?? '',
        completada = json['completada'] ?? false;

  // Objeto -> Map/JSON
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'titol': titol,
      'completada': completada,
    };
  }

  void canviarEstat() => completada = !completada;

  @override
  String toString() => 'Task($id, $titol, $completada)';
}

Task t1 = Task(id: 'T-01', titol: 'Aprobar el teórico');
Map<String, dynamic> json = t1.toJson();
Task t2 = Task.fromJson(json);

// Si el JSON trae 10 en vez de 10.0, Dart lo lee como int
// y asignarlo a un double peta. Solución:
preu = (map['preu'] ?? 0).toDouble();

// Future<T> = UN valor que llegará más tarde
Future<String> obtenirUsuari() async {
  await Future.delayed(Duration(seconds: 2));   // simula el servidor
  return 'Datos del usuario descargados';
}

void main() async {                  // async para poder usar await
  print('Inicio descarga...');
  String res = await obtenirUsuari();  // espera aquí 2 s
  print(res);
  print('Final');
}

// Funciones async que no devuelven nada:
Future<void> exercici1() async { ... }
// y en main:  await exercici1();

// Stream<T> = VARIOS valores a lo largo del tiempo
Stream<int> temporitzador() {
  return Stream.periodic(
    Duration(milliseconds: 500),   // uno cada medio segundo
    (i) => i,                      // 0, 1, 2, 3...
  ).take(5);                       // solo 5 y se cierra
}

// await for: recibe cada valor, sale cuando el Stream se cierra
await for (var valor in temporitzador()) {
  print('Valor recibido: $valor');
}
print('Temporizador finalizado');

import 'dart:async';

StreamController<String> controller = StreamController<String>();

// 1) Primero el oyente
controller.stream.listen(
  (msg) => print('Notificación: $msg'),     // onData
  onError: (e) => print('Error recibido: $e'),
  onDone: () => print('Canal cerrado'),
);

// 2) Luego emites
controller.add('Usuario conectado');
await Future.delayed(Duration(milliseconds: 500));
controller.addError('ERROR 501');   // el oyente sigue escuchando
await controller.close();           // -> onDone

// 3) Añadir después de cerrar lanza excepción
try {
  controller.add('Después de cerrar');
} catch (e) {
  print('No se puede: $e');   // Bad state: Cannot add new events after calling close
}

try {
  int n = int.parse('hola');
} on FormatException catch (e) {   // captura un tipo concreto
  print('No es un número: $e');
} catch (e) {                      // cualquier otro error
  print('Error: $e');
} finally {
  print('Esto se ejecuta siempre');
}

throw Exception('Algo ha ido mal');   // lanzar un error