Dart: vad är det, egenskaper hos språket Flutter och programmering

Vad är Dart?

Dart — programmeringsspråk med C-liknande syntax, utvecklat av Google under ledning av Lars Bak (skaparen av Eclipse). Den första utgåvan var 2011, men verklig popularitet fick Dart 2018 med lanseringen av Flutter 1.0. Språket är utformat för att skapa användargränssnitt: det har inbyggt stöd för streams, futures och reaktiva mönster.

Darts filosofi — "balans mellan prestanda och produktivitet". Språket stöder två kompileringsstrategier: JIT (Just-In-Time) för utveckling med hot reload och AOT (Ahead-Of-Time) för release-byggen med naturlig prestanda. JIT-kompilatorn injicerar modifierad kod i den körande applikationen på millisekunder utan att kräva omkompilering av APK — detta är Darts viktigaste fördel jämfört med andra språk i sammanhanget mobil utveckling.

Den viktigaste egenskapen hos Dart — sound null safety, introducerad i Dart 2.12 (2021). Typsystemet garanterar att en variabel inte kan vara null utan explicit angivelse (int?). Detta eliminerar NullPointerException i kompileringsfasen. Enligt Google minskade införandet av null safety antalet krascher i Flutter-applikationer med 30% i produktionsmiljö.

Darts ekosystem

Darts ekosystem omfattar tre huvudriktningar: Flutter (mobila och stationära applikationer), AngularDart (webbapplikationer) och Dart Server (serverlösningar). Flutter — den dominerande plattformen: enligt Statista (2025) används Flutter i 46% av cross-platform mobila projekt, före React Native (38%) och Xamarin (8%).

Dart-syntax: typer, funktioner och klasser

Dart-syntax påminner om Java och JavaScript men har egna unika konstruktioner. Allt i Dart är objekt — även int, double och bool ärver från Object. Typning är valfri: en variabel deklarerad som var härleder typen automatiskt, men det rekommenderas att explicit ange typer för läsbarhet och prestanda.

Grundläggande typer och deklarationer

Dart stöder int, double, String, bool, List, Set, Map, Record, Symbol och Runes. Nullable typ — vilken typ som helst med suffix ? (int?, String?). Operatorn ?? (null-aware) returnerar värdet till höger om vänster är null. Kaskadnotation (..) gör det möjligt att anropa flera metoder på samma objekt utan att upprepa referensen.

// Grundläggande typer och deklarationer i Dart
void main() {
  // Explicit typning
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — variabel kan vara null
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Null-aware operator

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

  // Kaskadnotation
  final list = <String>[]
    ..add('one')
    ..add('two')
    ..sort();
}

// Record — anonym oföränderlig typ
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

Typen dynamic stänger av typkontroll — använd den endast vid arbete med JSON eller dynamisk data. Record — ny typ i Dart 3.0, som möjliggör gruppering av värden utan att skapa en separat klass. Null-aware operatorn ?? — standardsättet att arbeta med nullable-värden, som ersätter långa if-else-kontroller.

Klasser och mixins

Klasser i Dart — enkel arv (extends), multipel via mixins (mixin). Dart stöder inte interfaces som separat koncept — vilken klass som helst kan implementeras (implements). Mixin — klass utan konstruktor, vars metoder och fält kan läggas till i vilken klass som helst via nyckelordet with.

// Klasser, arv och mixins i Dart
abstract class Animal {
  void sound(); // abstrakt metod
}

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

// Namngiven konstruktor
class Config {
  final String env;

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

Klassen Duck ärver från Animal och använder två mixins — Swimmer och Flyer. Detta demonstrerar multipel arv utan problem med rombstruktur: mixins löses linjärt (super chain). Namngivna konstruktorer (Config.development) — alternativ till statiska fabriksmetoder för att skapa objekt med förinställda parametrar.

Asynkronitet i Dart: Future, Stream och async/await

Asynkronitet i Dart realiseras genom Future (enskilt värde), Stream (sekvens av värden) och async/await. Dart använder en entrådig event loop-modell, liknande JavaScript, men med en viktig skillnad: långvariga beräkningar blockerar inte UI, eftersom Dart-kod körs i Isolate — en separat tråd utan delat minne.

Future representerar en asynkron operation som slutförs efter en tid. Future kan vara i tillståndet pending (väntar), completed with value (framgång) eller completed with error (fel). Kedjan .then().catchError() — alternativ till async/await, men det rekommenderas att använda await för läsbarhet.

// Asynkron datahämtning med Future och Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future för enskild förfrågan
  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 för datasekvens
  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');

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

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

Klassen ApiService demonstrerar två typer av asynkronitet: Future för en HTTP-förfrågan (ett svar) och Stream för en sekventiell räknare (generator med async* och yield). Stream är effektivt för arbete med sensorer, geolokalisering, Firebase Realtime Database — överallt där data kommer kontinuerligt. Isolate använder separat minne — data överförs via SendPort/ReceivePort.

Dart och Flutter: applikationsarkitektur

Dart och Flutter bildar en enda stack: Flutter — UI-ramverk, Dart — språk för UI-beskrivning. I Flutter är allt en widget (Widget) — från en knapp till hela applikationen. Widgets kan vara stateful (med föränderligt tillstånd) och stateless (oföränderliga). Dart beskriver deklarativt UI: build() returnerar ett widgetträd som Flutter renderar med Skia (eller Impeller på iOS).

Struktur för Flutter-applikation

En Flutter-applikation i Dart består av main() → runApp(MyApp()) → MaterialApp. MaterialApp inkluderar routing (routes), tema (theme) och lokalisering. Varje skärm är en Scaffold, som innehåller AppBar, Body (vanligtvis Column/ListView) och BottomNavigationBar. Navigering via Navigator.push/pop eller namngivna rutter.

// Enkel Flutter-applikation i 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 HomeScreen — StatefulWidget med internt tillstånd _counter. Anrop av setState() meddelar Flutter om behovet av att bygga om UI — Dart-kod startar om build() och skapar ett nytt widgetträd. Flutter jämför effektivt (diff) det gamla och nya trädet och uppdaterar endast de ändrade delarna av skärmen. Hot Reload ersätter build() utan att återställa tillståndet _counter.

Dart-kompilering: JIT vs AOT

Dart-kompilering — hybrid: JIT för utveckling och AOT för produktion. I felsökningsläge startar Dart VM JIT-kompilatorn som tolkar bytekod med möjlighet till het kodväxling. I release skapar dart compile exe eller flutter build en native AOT-binär för en specifik arkitektur (arm64, x86_64, armv7).

JIT-kompilering av Dart i felsökningsläge ger hot reload på ~1 sekund — utvecklaren ser UI-förändringar utan att förlora applikationens tillstånd. AOT-kompilering ger prestanda nära native Swift/Kotlin-applikationer. Enligt Google uppnår Flutter på Dart AOT 60 FPS-animationer även på mellanklass-enheter.

Verktyg för Dart-utvecklare

Verktyg för Dart-utvecklare inkluderar Dart SDK (kompilatorn dart, dartanalyzer, dartfmt, pub), Flutter SDK och IDE-plugin. Dart SDK installeras tillsammans med Flutter SDK i mappen flutter/bin/cache/dart-sdk. Pub — pakethanterare som läser pubspec.yaml och laddar ner beroenden från pub.dev.

Viktigaste verktygen

dart analyze — statisk analysator som kontrollerar typer, oanvända importer och potentiella fel. dart format — formaterare som automatiskt anpassar koden till en enhetlig stil. dart doc — dokumentationsgenerator från ///-kommentarer. Flutter DevTools — profilerare med visning av widgetträd, loggar, minne och nätverk. Dart VM Service — felsökning av körande applikation via WebSocket.

# pubspec.yaml — konfiguration av Dart-projekt
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

Fil pubspec.yaml beskriver ett Dart-projekts beroenden. Fältet environment:sdk anger Dart-versionen — nuvarande stabila 3.x. Dependencies — huvudsakliga bibliotek, dev_dependencies — för testning och kodgenerering. json_annotation + json_serializable genererar kod för JSON-serialisering via build_runner. flutter_lints — regeluppsättning för analysatorn.