Dart: co to je, vlastnosti jazyka Flutter a programování

Co je Dart?

Dart — programovací jazyk s C-like syntaxí, vyvinutý společností Google pod vedením Larse Bakka (tvůrce Eclipse). První vydání proběhlo v roce 2011, ale skutečnou popularitu získal Dart v roce 2018 s vydáním Flutter 1.0. Jazyk je navržen pro tvorbu uživatelských rozhraní: má vestavěnou podporu pro streamy, futures a reaktivní vzory.

Filozofií Dartu je "rovnováha výkonu a produktivity". Jazyk podporuje dvě strategie kompilace: JIT (Just-In-Time) pro vývoj s hot restartem a AOT (Ahead-Of-Time) pro release sestavení s nativním výkonem. JIT kompilátor vstřikuje upravený kód do běžící aplikace v milisekundách, aniž by vyžadoval překompilování APK — to je klíčová výhoda Dartu oproti jiným jazykům v kontextu mobilního vývoje.

Klíčová vlastnost Dartu — sound null safety, zavedená v Dart 2.12 (2021). Systém typů garantuje, že proměnná nemůže být null bez explicitního označení (int?). To eliminuje NullPointerException ve fázi kompilace. Podle údajů Googlu snížilo zavedení null safety počet pádů v aplikacích Flutter o 30% v produkčním prostředí.

Ekosystém Dartu

Ekosystém Dartu zahrnuje tři hlavní směry: Flutter (mobilní a desktopové aplikace), AngularDart (webové aplikace) a Dart Server (serverová řešení). Flutter — dominantní platforma: podle Statista (2025) je Flutter používán ve 46% cross-platform mobilních projektů, před React Native (38%) a Xamarinem (8%).

Syntaxe Dartu: typy, funkce a třídy

Syntaxe Dartu připomíná Javu a JavaScript, ale má vlastní jedinečné konstrukce. Vše v Dartu je objekt — dokonce i int, double a bool dědí z Object. Typování je volitelné: proměnná deklarovaná jako var automaticky odvodí typ, ale doporučuje se typy explicitně uvádět kvůli čitelnosti a výkonu.

Základní typy a deklarace

Dart podporuje int, double, String, bool, List, Set, Map, Record, Symbol a Runes. Nullable typ — libovolný typ s příponou ? (int?, String?). Operátor ?? (null-aware) vrací hodnotu vpravo, pokud je levá null. Kaskádová notace (..) umožňuje volat více metod na stejném objektu bez opakování reference.

// Základní typy a deklarace v Dartu
void main() {
  // Explicitní typování
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — proměnná může být null
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Null-aware operátor

  // Kolekce s generiky
  List<String> items = ['Dart', 'Flutter', 'Mobile'];
  Map<String, dynamic> config = {
    'version': '3.0',
    'mode': 'debug',
  };

  // Kaskádová notace
  final list = <String>[]
    ..add('one')
    ..add('two')
    ..sort();
}

// Record — anonymní neměnný typ
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

Typ dynamic vypíná kontrolu typů — používejte ho pouze při práci s JSON nebo dynamickými daty. Record — nový typ v Dart 3.0, umožňující seskupování hodnot bez vytváření samostatné třídy. Null-aware operátor ?? — standardní způsob práce s nullable hodnotami, nahrazující dlouhé if-else kontroly.

Třídy a mixiny

Třídy v Dartu — jednoduchá dědičnost (extends), vícenásobná přes mixiny (mixin). Dart nepodporuje rozhraní jako samostatný koncept — jakákoli třída může být implementována (implements). Mixin — třída bez konstruktoru, jejíž metody a pole mohou být přidány do libovolné třídy pomocí klíčového slova with.

// Třídy, dědičnost a mixiny v Dartu
abstract class Animal {
  void sound(); // abstraktní metoda
}

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

// Pojmenovaný konstruktor
class Config {
  final String env;

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

Třída Duck dědí z Animal a používá dva mixiny — Swimmer a Flyer. To demonstruje vícenásobnou dědičnost bez problémů kosočtverečné struktury: mixiny se řeší lineárně (super chain). Pojmenované konstruktory (Config.development) — alternativa ke statickým továrním metodám pro vytváření objektů s přednastavenými parametry.

Asynchronnost v Dartu: Future, Stream a async/await

Asynchronnost v Dartu je realizována prostřednictvím Future (jednotlivá hodnota), Stream (sekvence hodnot) a async/await. Dart používá jednovláknový model event loop, podobně jako JavaScript, ale s důležitým rozdílem: dlouhé výpočty neblokují UI, protože kód Dartu se spouští v Isolate — samostatném vlákně bez sdílené paměti.

Future představuje asynchronní operaci, která se dokončí po určité době. Future může být ve stavu pending (čekání), completed with value (úspěch) nebo completed with error (chyba). Řetěz .then().catchError() — alternativa k async/await, ale pro čitelnost se doporučuje používat await.

// Asynchronní načítání dat pomocí Future a Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future pro jediný požadavek
  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 pro sekvenci dat
  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');

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

  // Zpracování Streamu pomocí await for
  await for (final count in api.countStream(5)) {
    print('Count: $count');
  }
}

Třída ApiService demonstruje dva typy asynchronnosti: Future pro HTTP požadavek (jedna odpověď) a Stream pro sekvenční čítač (generátor s async* a yield). Stream je efektivní pro práci se senzory, geolokací, Firebase Realtime Database — všude tam, kde data přicházejí kontinuálně. Isolate používá oddělenou paměť — data jsou přenášena přes SendPort/ReceivePort.

Dart a Flutter: architektura aplikace

Dart a Flutter tvoří jeden stack: Flutter — UI framework, Dart — jazyk popisu UI. Ve Flutteru je vše widget (Widget) — od tlačítka po celou aplikaci. Widgety mohou být stateful (s měnitelným stavem) a stateless (neměnné). Dart popisuje deklarativní UI: build() vrací strom widgetů, který Flutter renderuje pomocí Skia (nebo Impeller na iOS).

Struktura aplikace Flutter

Aplikace Flutter v Dartu se skládá z main() → runApp(MyApp()) → MaterialApp. MaterialApp zahrnuje směrování (routes), téma (theme) a lokalizaci. Každá obrazovka je Scaffold obsahující AppBar, Body (obvykle Column/ListView) a BottomNavigationBar. Navigace přes Navigator.push/pop nebo pojmenované cesty.

// Jednoduchá Flutter aplikace v Dartu
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 HomeScreen — StatefulWidget s vnitřním stavem _counter. Volání setState() informuje Flutter o potřebě překreslení UI — kód Dartu restartuje build(), čímž vytvoří nový strom widgetů. Flutter efektivně porovnává (diff) starý a nový strom a aktualizuje pouze změněné části obrazovky. Hot Reload nahrazuje build() bez resetování stavu _counter.

Kompilace Dartu: JIT vs AOT

Kompilace Dartu — hybridní: JIT pro vývoj a AOT pro produkci. V režimu debug spouští Dart VM JIT kompilátor, který interpretuje bytekód s možností horké výměny kódu. V release dart compile exe nebo flutter build vytváří nativní AOT binárku pro konkrétní architekturu (arm64, x86_64, armv7).

JIT kompilace Dartu v režimu debug poskytuje hot restart za ~1 sekundu — vývojář vidí změny UI bez ztráty stavu aplikace. AOT kompilace poskytuje výkon blízký nativním aplikacím Swift/Kotlin. Podle údajů Googlu dosahuje Flutter na Dart AOT 60 FPS animací i na zařízeních střední třídy.

Nástroje vývojáře Dartu

Nástroje vývojáře Dartu zahrnují Dart SDK (kompilátor dart, dartanalyzer, dartfmt, pub), Flutter SDK a pluginy IDE. Dart SDK se instaluje spolu s Flutter SDK do složky flutter/bin/cache/dart-sdk. Pub — správce balíčků, který čte pubspec.yaml a stahuje závislosti z pub.dev.

Klíčové nástroje

dart analyze — statický analyzátor kontrolující typy, nepoužité importy a potenciální chyby. dart format — formátovač, který automaticky převádí kód do jednotného stylu. dart doc — generátor dokumentace z komentářů ///. Flutter DevTools — profiler s náhledem stromu widgetů, logů, paměti a sítě. Dart VM Service — ladění běžící aplikace přes WebSocket.

# pubspec.yaml — konfigurace projektu 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

Soubor pubspec.yaml popisuje závislosti projektu Dart. Pole environment:sdk určuje verzi Dartu — aktuální stabilní 3.x. Dependencies — hlavní knihovny, dev_dependencies — pro testování a generování kódu. json_annotation + json_serializable generují kód pro serializaci JSON přes build_runner. flutter_lints — sada pravidel pro analyzátor.