Dart: ce este, caracteristicile limbajului Flutter și programare

Ce este Dart?

Dart — limbaj de programare cu sintaxă în stil C, dezvoltat de Google sub conducerea lui Lars Bak (creatorul Eclipse). Prima lansare a avut loc în 2011, dar adevărata popularitate a câștigat-o Dart în 2018 odată cu lansarea Flutter 1.0. Limbajul este proiectat pentru crearea interfețelor de utilizator: are suport încorporat pentru stream-uri, future și pattern-uri reactive.

Filozofia Dart — "echilibrul dintre performanță și productivitate". Limbajul suportă două strategii de compilare: JIT (Just-In-Time) pentru dezvoltare cu reîncărcare la cald și AOT (Ahead-Of-Time) pentru versiunile finale cu performanță nativă. Compilatorul JIT injectează codul modificat în aplicația care rulează în milisecunde, fără a necesita recompilarea APK — acesta este avantajul cheie al Dart față de alte limbaje în contextul dezvoltării mobile.

Caracteristica cheie a Dart — sound null safety, introdusă în Dart 2.12 (2021). Sistemul de tipuri garantează că o variabilă nu poate fi null fără indicare explicită (int?). Aceasta elimină NullPointerException în faza de compilare. Conform datelor Google, implementarea null safety a redus numărul de crash-uri în aplicațiile Flutter cu 30% în mediul de producție.

Ecosistemul Dart

Ecosistemul Dart include trei direcții principale: Flutter (aplicații mobile și desktop), AngularDart (aplicații web) și Dart Server (soluții server). Flutter — platforma dominantă: conform datelor Statista (2025), Flutter este folosit în 46% din proiectele mobile cross-platform, depășind React Native (38%) și Xamarin (8%).

Sintaxa Dart: tipuri, funcții și clase

Sintaxa Dart amintește de Java și JavaScript, dar are propriile construcții unice. Totul în Dart este obiect — chiar și int, double și bool moștenesc Object. Tipizarea este opțională: o variabilă declarată ca var deduce automat tipul, dar se recomandă specificarea explicită a tipurilor pentru lizibilitate și performanță.

Tipuri de bază și declarații

Dart suportă int, double, String, bool, List, Set, Map, Record, Symbol și Runes. Tip Nullable — orice tip cu sufixul ? (int?, String?). Operatorul ?? (null-aware) returnează valoarea din dreapta dacă stânga este null. Notația în cascadă (..) permite apelarea mai multor metode pe același obiect fără repetarea referinței.

// Tipuri de bază și declarații în Dart
void main() {
  // Tipizare explicită
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — variabila poate fi null
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Operator null-aware

  // Colecții cu generice
  List<String> items = ['Dart', 'Flutter', 'Mobile'];
  Map<String, dynamic> config = {
    'version': '3.0',
    'mode': 'debug',
  };

  // Notație în cascadă
  final list = <String>[]
    ..add('one')
    ..add('two')
    ..sort();
}

// Record — tip anonim imutabil
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

Tipul dynamic dezactivează verificarea tipurilor — folosiți-l doar când lucrați cu JSON sau date dinamice. Record — tip nou în Dart 3.0, care permite gruparea valorilor fără a crea o clasă separată. Operatorul null-aware ?? — modalitatea standard de lucru cu valori nullable, înlocuind verificările lungi if-else.

Clase și mixin-uri

Clasele în Dart — moștenire unică (extends), multiplă prin mixin-uri (mixin). Dart nu suportă interfețe ca concept separat — orice clasă poate fi implementată (implements). Mixin — clasă fără constructor, ale cărei metode și câmpuri pot fi adăugate în orice clasă prin cuvântul cheie with.

// Clase, moștenire și mixin-uri în Dart
abstract class Animal {
  void sound(); // metodă abstractă
}

mixin Swimmer {
  void swim() => print('Swimming...');
}

mixin Flyer {
  void fly() => print('Flying...');
}

class Duck extends Animal with Swimmer, Flyer {
  @override
  void sound() => print('Quack!');
}

void main() {
  final duck = Duck();
  duck.sound(); // Quack!
  duck.swim();  // Swimming...
  duck.fly();   // Flying...
}

// Constructor numit
class Config {
  final String env;

  Config.development() : env = 'dev';
  Config.production()  : env = 'prod';
}

Clasa Duck moștenește Animal și folosește două mixin-uri — Swimmer și Flyer. Aceasta demonstrează moștenirea multiplă fără problemele structurii romboidale: mixin-urile se rezolvă liniar (super chain). Constructorii numiți (Config.development) — alternativă la metodele statice de fabrică pentru crearea obiectelor cu parametri prestabiliți.

Asincronitatea în Dart: Future, Stream și async/await

Asincronitatea în Dart este realizată prin Future (valoare unică), Stream (secvență de valori) și async/await. Dart folosește modelul single-thread cu event loop, similar JavaScript, dar cu o diferență importantă: calculele lungi nu blochează UI, deoarece codul Dart se execută în Isolate — un fir separat fără memorie partajată.

Future reprezintă o operație asincronă care se va finaliza după un timp. Future poate fi în stare pending (așteptare), completed with value (succes) sau completed with error (eroare). Lanțul .then().catchError() — alternativă la async/await, dar se recomandă utilizarea await pentru lizibilitate.

// Încărcarea asincronă a datelor cu Future și Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future pentru cerere unică
  Future<Map<String, dynamic>> fetchUser(int id) async {
    final response = await http.get(
      Uri.parse('$baseUrl/users/$id'),
    );

    if (response.statusCode == 200) {
      return jsonDecode(response.body);
    } else {
      throw Exception('Failed to load user: ${response.statusCode}');
    }
  }

  // Stream pentru secvență de date
  Stream<int> countStream(int max) async* {
    for (var i = 1; i <= max; i++) {
      await Future.delayed(Duration(seconds: 1));
      yield i;
    }
  }
}

void main() async {
  final api = ApiService('https://api.example.com');

  // Utilizarea await
  final user = await api.fetchUser(1);
  print('User: ${user['name']}');

  // Procesarea Stream cu await for
  await for (final count in api.countStream(5)) {
    print('Count: $count');
  }
}

Clasa ApiService demonstrează două tipuri de asincronitate: Future pentru o cerere HTTP (un răspuns) și Stream pentru un contor secvențial (generator cu async* și yield). Stream este eficient pentru lucrul cu senzori, geolocație, Firebase Realtime Database — oriunde datele vin continuu. Isolate utilizează memorie separată — datele sunt transmise prin SendPort/ReceivePort.

Dart și Flutter: arhitectura aplicației

Dart și Flutter formează un singur stack: Flutter — framework UI, Dart — limbajul de descriere a UI-ului. În Flutter totul este un widget (Widget) — de la un buton până la întreaga aplicație. Widget-urile pot fi stateful (cu stare modificabilă) și stateless (imutabile). Dart descrie UI-ul declarativ: build() returnează un arbore de widget-uri pe care Flutter îl randă cu Skia (sau Impeller pe iOS).

Structura aplicației Flutter

Aplicația Flutter în Dart constă din main() → runApp(MyApp()) → MaterialApp. MaterialApp include rutare (routes), temă (theme) și localizare. Fiecare ecran este un Scaffold, care conține AppBar, Body (de obicei Column/ListView) și BottomNavigationBar. Navigare prin Navigator.push/pop sau rute numite.

// Aplicație simplă Flutter în Dart
import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Dart Demo',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: HomeScreen(),
    );
  }
}

class HomeScreen extends StatefulWidget {
  @override
  _HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  int _counter = 0;

  void _increment() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Dart + Flutter')),
      body: Center(
        child: Text('Counter: $_counter'),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _increment,
        child: Icon(Icons.add),
      ),
    );
  }
}

Widget-ul HomeScreen — StatefulWidget cu starea internă _counter. Apelul setState() notifică Flutter despre necesitatea reconstruirii UI-ului — codul Dart repornește build(), creând un nou arbore de widget-uri. Flutter compară eficient (diff) arborele vechi și cel nou, actualizând doar părțile modificate ale ecranului. Hot Reload înlocuiește build() fără a reseta starea _counter.

Compilarea Dart: JIT vs AOT

Compilarea Dart — hibridă: JIT pentru dezvoltare și AOT pentru producție. În modul debug, Dart VM rulează compilatorul JIT care interpretează byte-code cu posibilitatea de înlocuire la cald a codului. În versiunea release dart compile exe sau flutter build creează un binar AOT nativ pentru o arhitectură specifică (arm64, x86_64, armv7).

Compilarea JIT a Dart în modul debug asigură reîncărcarea la cald în ~1 secundă — dezvoltatorul vede modificările UI fără a pierde starea aplicației. Compilarea AOT oferă performanță apropiată de aplicațiile native Swift/Kotlin. Conform datelor Google, Flutter pe Dart AOT atinge 60 FPS chiar și pe dispozitive de segment mediu.

Instrumente pentru dezvoltatorul Dart

Instrumentele pentru dezvoltatorul Dart includ Dart SDK (compilator dart, dartanalyzer, dartfmt, pub), Flutter SDK și plugin-uri IDE. Dart SDK se instalează împreună cu Flutter SDK în folderul flutter/bin/cache/dart-sdk. Pub — managerul de pachete, care citește pubspec.yaml și descarcă dependențele din pub.dev.

Instrumente cheie

dart analyze — analizator static care verifică tipurile, importurile neutilizate și erorile potențiale. dart format — formator care aduce automat codul la un stil unitar. dart doc — generator de documentație din comentariile ///. Flutter DevTools — profiler cu vizualizarea arborelui de widget-uri, log-urilor, memoriei și rețelei. Dart VM Service — depanarea aplicației care rulează prin WebSocket.

# pubspec.yaml — configurarea proiectului Dart
name: my_flutter_app
description: A new Flutter project.
version: 1.0.0

environment:
  sdk: '>=3.0.0 <4.0.0'

dependencies:
  flutter:
    sdk: flutter
  http: ^1.2.0
  provider: ^6.1.0
  shared_preferences: ^2.2.0
  json_annotation: ^4.8.0

dev_dependencies:
  flutter_test:
    sdk: flutter
  build_runner: ^2.4.0
  json_serializable: ^6.7.0
  flutter_lints: ^3.0.0

Fișierul pubspec.yaml descrie dependențele proiectului Dart. Câmpul environment:sdk specifică versiunea Dart — stabilă curentă 3.x. Dependencies — bibliotecile principale, dev_dependencies — pentru testare și generare de cod. json_annotation + json_serializable generează cod pentru serializarea JSON prin build_runner. flutter_lints — set de reguli pentru analizator.