Dart: mi ez, a Flutter nyelv jellemzői és programozás

Mi az a Dart?

Dart — C-szerű szintaxisú programozási nyelv, amelyet a Google fejlesztett Lars Bak (az Eclipse alkotója) vezetésével. Az első kiadás 2011-ben történt, de a Dart igazi népszerűségét 2018-ban érte el a Flutter 1.0 megjelenésével. A nyelvet felhasználói felületek létrehozására tervezték: beépített támogatással rendelkezik streamekhez, future-ökhöz és reaktív mintákhoz.

A Dart filozófiája — "a teljesítmény és termelékenység egyensúlya". A nyelv két fordítási stratégiát támogat: JIT (Just-In-Time) a hot reloados fejlesztéshez és AOT (Ahead-Of-Time) a natív teljesítményű release buildekhez. A JIT fordító ezredmásodpercek alatt injektálja a módosított kódot a futó alkalmazásba anélkül, hogy az APK újrafordítását igényelné — ez a Dart kulcsfontosságú előnye más nyelvekkel szemben a mobilfejlesztés kontextusában.

A Dart kulcsfontosságú jellemzője — a sound null safety, amely a Dart 2.12-ben (2021) került bevezetésre. A típusrendszer garantálja, hogy egy változó nem lehet null explicit megjelölés nélkül (int?). Ez kiküszöböli a NullPointerException-t a fordítási fázisban. A Google adatai szerint a null safety bevezetése 30%-kal csökkentette a Flutter alkalmazások összeomlásainak számát a termelési környezetben.

Dart ökoszisztéma

A Dart ökoszisztéma három fő irányt foglal magában: Flutter (mobil és asztali alkalmazások), AngularDart (webalkalmazások) és Dart Server (szerveroldali megoldások). Flutter — a domináns platform: a Statista (2025) adatai szerint a Flutter a cross-platform mobil projektek 46%-ában használatos, megelőzve a React Native-t (38%) és a Xamarint (8%).

Dart szintaxis: típusok, függvények és osztályok

A Dart szintaxisa a Java-ra és JavaScript-re emlékeztet, de saját egyedi szerkezetekkel rendelkezik. A Dartban minden objektum — még az int, double és bool is az Object-ből származik. A típusozás opcionális: a var-ként deklarált változó automatikusan következtet a típusra, de az olvashatóság és teljesítmény érdekében ajánlott a típusokat explicit megadni.

Alapvető típusok és deklarációk

A Dart támogatja az int, double, String, bool, List, Set, Map, Record, Symbol és Runes típusokat. Nullable típus — bármely típus ? toldalékkal (int?, String?). A ?? operátor (null-aware) a jobb oldali értéket adja vissza, ha a bal oldali null. A kaszkád jelölés (..) lehetővé teszi több metódus meghívását ugyanazon az objektumon a referencia ismétlése nélkül.

// Alapvető típusok és deklarációk Dartban
void main() {
  // Explicit típusozás
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — a változó lehet null
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Null-aware operátor

  // Gyűjtemények generikusokkal
  List<String> items = ['Dart', 'Flutter', 'Mobile'];
  Map<String, dynamic> config = {
    'version': '3.0',
    'mode': 'debug',
  };

  // Kaszkád jelölés
  final list = <String>[]
    ..add('one')
    ..add('two')
    ..sort();
}

// Record — névtelen megváltoztathatatlan típus
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

A dynamic típus kikapcsolja a típusellenőrzést — csak JSON vagy dinamikus adatokkal való munka során használja. A Record — új típus a Dart 3.0-ban, amely lehetővé teszi értékek csoportosítását külön osztály létrehozása nélkül. A null-aware operátor ?? — a nullable értékekkel való munka szabványos módja, hosszú if-else ellenőrzéseket helyettesítve.

Osztályok és mixinek

Osztályok Dartban — egyszeres öröklés (extends), többszörös mixineken keresztül (mixin). A Dart nem támogatja az interfészeket különálló koncepcióként — bármely osztály implementálható (implements). Mixin — konstruktor nélküli osztály, amelynek metódusai és mezői a with kulcsszóval bármely osztályhoz hozzáadhatók.

// Osztályok, öröklés és mixinek Dartban
abstract class Animal {
  void sound(); // absztrakt metódus
}

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...
}

// Nevesített konstruktor
class Config {
  final String env;

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

A Duck osztály az Animal-ból származik és két mixint használ — Swimmer és Flyer. Ez a többszörös öröklést demonstrálja a rombuszszerkezet problémái nélkül: a mixinek lineárisan oldódnak fel (super chain). A nevesített konstruktorok (Config.development) — alternatívák a statikus gyári metódusokhoz objektumok létrehozásához előre beállított paraméterekkel.

Aszinkronitás Dartban: Future, Stream és async/await

Aszinkronitás Dartban Future (egyetlen érték), Stream (értékek sorozata) és async/await segítségével valósul meg. A Dart egyszálú event loop modellt használ, hasonlóan a JavaScript-hez, de fontos különbséggel: a hosszú számítások nem blokkolják a UI-t, mivel a Dart kód Isolate-ben — megosztott memória nélküli külön szálon fut.

A Future egy aszinkron műveletet reprezentál, amely egy idő után befejeződik. A Future lehet pending (várakozó), completed with value (sikeres) vagy completed with error (hibás) állapotban. A .then().catchError() lánc — alternatíva az async/await helyett, de az olvashatóság érdekében az await használata ajánlott.

// Aszinkron adatbetöltés Future és Stream segítségével
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future egyetlen kéréshez
  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 adatsorozathoz
  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');

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

  // Stream feldolgozása await for segítségével
  await for (final count in api.countStream(5)) {
    print('Count: $count');
  }
}

Az ApiService osztály kétféle aszinkronitást demonstrál: Future egy HTTP kéréshez (egy válasz) és Stream egy szekvenciális számlálóhoz (generátor async* és yield segítségével). A Stream hatékony az érzékelőkkel, geolokációval, Firebase Realtime Database-val való munkához — mindenhol, ahol az adatok folyamatosan érkeznek. Az Isolate külön memóriát használ — az adatok SendPort/ReceivePort-on keresztül kerülnek továbbításra.

Dart és Flutter: alkalmazásarchitektúra

Dart és Flutter egyetlen stack-et alkot: Flutter — UI keretrendszer, Dart — a UI leírásának nyelve. Flutterben minden widget (Widget) — a gombtól a teljes alkalmazásig. A widgetek lehetnek stateful (változtatható állapotúak) és stateless (változatlanok). A Dart deklaratív UI-t ír le: a build() egy widgetfát ad vissza, amelyet a Flutter a Skia (vagy iOS-en Impeller) segítségével renderel.

Flutter alkalmazás szerkezete

A Flutter alkalmazás Dartban a main() → runApp(MyApp()) → MaterialApp részből áll. A MaterialApp tartalmazza az útválasztást (routes), témát (theme) és lokalizációt. Minden képernyő egy Scaffold, amely AppBar-t, Body-t (általában Column/ListView) és BottomNavigationBar-t tartalmaz. Navigáció a Navigator.push/pop vagy nevesített útvonalak segítségével.

// Egyszerű Flutter alkalmazás Dartban
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),
      ),
    );
  }
}

A HomeScreen widget — StatefulWidget belső _counter állapottal. A setState() hívás értesíti a Flutter-t a UI újraépítésének szükségességéről — a Dart kód újraindítja a build()-et, új widgetfát hozva létre. A Flutter hatékonyan összehasonlítja (diff) a régi és új fát, csak a képernyő megváltozott részeit frissítve. A Hot Reload lecseréli a build()-et a _counter állapotának visszaállítása nélkül.

Dart fordítás: JIT vs AOT

A Dart fordítás — hibrid: JIT a fejlesztéshez és AOT a termeléshez. Debug módban a Dart VM elindítja a JIT fordítót, amely a bájtkódot értelmezi a kód forró cseréjének lehetőségével. Release-ben a dart compile exe vagy flutter build natív AOT binárist hoz létre egy adott architektúrához (arm64, x86_64, armv7).

A Dart JIT fordítása debug módban ~1 másodperces hot reload-ot biztosít — a fejlesztő az alkalmazás állapotának elvesztése nélkül látja a UI változásokat. Az AOT fordítás a natív Swift/Kotlin alkalmazásokhoz közeli teljesítményt nyújt. A Google adatai szerint a Flutter Dart AOT-on akár 60 FPS animációt is elér középkategóriás eszközökön.

Dart fejlesztő eszközei

A Dart fejlesztő eszközei magukban foglalják a Dart SDK-t (dart fordító, dartanalyzer, dartfmt, pub), a Flutter SDK-t és IDE bővítményeket. A Dart SDK a Flutter SDK-val együtt kerül telepítésre a flutter/bin/cache/dart-sdk mappában. Pub — csomagkezelő, amely a pubspec.yaml fájlt olvassa és a függőségeket a pub.dev-ről tölti le.

Kulcsfontosságú eszközök

dart analyze — statikus elemző, amely ellenőrzi a típusokat, nem használt importokat és potenciális hibákat. dart format — formázó, amely automatikusan egységes stílusba hozza a kódot. dart doc — dokumentációgenerátor /// megjegyzésekből. Flutter DevTools — profilozó a widgetfa, naplók, memória és hálózat megtekintésével. Dart VM Service — futó alkalmazás hibakeresése WebSocketen keresztül.

# pubspec.yaml — Dart projekt konfigurációja
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

A pubspec.yaml fájl írja le a Dart projekt függőségeit. Az environment:sdk mező a Dart verzióját határozza meg — jelenlegi stabil 3.x. Dependencies — fő könyvtárak, dev_dependencies — teszteléshez és kódgeneráláshoz. A json_annotation + json_serializable kódot generál a JSON szerializációhoz a build_runner segítségével. flutter_lints — szabálykészlet az elemző számára.