Future în Dart

abstract interface class Future<T>

Future<T>(FutureOr<T> computation())
Future<T> f = ...;  T rezultat = await f;

Ce face Future

Un Future<T> este promisiunea unei valori de tipul T care va fi disponibilă în viitor, sau a unei erori. Operațiile lente (rețea, fișiere, timp) returnează un Future, ca programul să poată face altceva între timp.

Cel mai simplu îl folosești cu await, într-o funcție marcată async: final text = await citeste();. Funcția async returnează și ea un Future. Erorile se prind cu try/catch, exact ca în codul sincron.

Constructorul Future(() => ...) rulează funcția mai târziu, după ce codul curent se termină (în bucla de evenimente). Un future poate fi în trei stări: în așteptare, terminat cu o valoare sau terminat cu o eroare.

Parametri

Parametru	Descriere
computation	Pentru constructorul Future(...): funcția care calculează valoarea, rulată mai târziu.

Ce returnează

Un Future<T> care se termină cu valoarea funcției sau cu eroarea aruncată de ea.

Exemple

Exemplul 1: Așteptarea unei descărcări simulate

Future<String> descarcaProfil(String nume) async {
  await Future.delayed(const Duration(milliseconds: 100));
  return 'Profil: $nume, Iași';
}

Future<void> main() async {
  print('Pornesc descărcarea...');
  final profil = await descarcaProfil('Ana');
  print(profil);
  print('Gata.');
}

Rezultat

Pornesc descărcarea...
Profil: Ana, Iași
Gata.

Exemplul 2: Ordinea: codul sincron rulează înainte

Funcția dată constructorului Future nu rulează imediat, ci după ce main termină partea sincronă.

Future<void> main() async {
  final f = Future(() {
    print('2. calculez în future');
    return 42;
  });
  print('1. future creat');
  final rezultat = await f;
  print('3. rezultat: $rezultat');
}

Rezultat

1. future creat
2. calculez în future
3. rezultat: 42

Exemplul 3: Erori prinse cu try/catch

Future<double> pretProdus(String cod) async {
  await Future.delayed(const Duration(milliseconds: 10));
  if (cod != 'P1') throw ArgumentError('produs necunoscut: $cod');
  return 49.99;
}

Future<void> main() async {
  for (final cod in ['P1', 'P9']) {
    try {
      print('$cod costă ${await pretProdus(cod)} lei');
    } on ArgumentError catch (e) {
      print('Eroare: ${e.message}');
    }
  }
}

Rezultat

P1 costă 49.99 lei
Eroare: produs necunoscut: P9

Greșeli frecvente

• Uiți await și afișezi Instance of 'Future<String>' în loc de valoare.
• Scrii void main() și folosești await în ea. await este permis doar în funcții async; scrie Future<void> main() async.

Comenzi înrudite

• async și await: async marchează o funcție asincronă (întoarce Future), iar await așteaptă rezultatul unui Future fără să blocheze programul.
• Future.then: Înregistrează o funcție care primește valoarea future-ului când e gata și returnează un future nou cu rezultatul ei.
• Future.delayed: Creează un future care se termină după o durată dată, opțional cu valoarea unei funcții; pauza asincronă din Dart.
• Future.wait: Future.wait așteaptă mai multe future-uri în paralel și dă lista rezultatelor; Future.any dă primul rezultat terminat.
• Completer: Creează un Future pe care îl termini tu, manual, mai târziu; leagă codul cu callback-uri de codul cu await.
• Stream: Un șir de valori care sosesc în timp, una după alta (mesaje, clicuri, linii dintr-un fișier); îl parcurgi cu await for.