Dart: apa itu, fitur bahasa Flutter dan pemrograman

Apa itu Dart?

Dart — bahasa pemrograman dengan sintaks mirip C, dikembangkan oleh Google di bawah pimpinan Lars Bak (pencipta Eclipse). Rilis pertama terjadi pada tahun 2011, tetapi popularitas sejati Dart diraih pada tahun 2018 dengan dirilisnya Flutter 1.0. Bahasa ini dirancang untuk membuat antarmuka pengguna: ia memiliki dukungan bawaan untuk stream, future, dan pola reaktif.

Filosofi Dart — "keseimbangan kinerja dan produktivitas". Bahasa ini mendukung dua strategi kompilasi: JIT (Just-In-Time) untuk pengembangan dengan hot reload dan AOT (Ahead-Of-Time) untuk build rilis dengan kinerja native. Kompilator JIT menyuntikkan kode yang dimodifikasi ke dalam aplikasi yang berjalan dalam hitungan milidetik, tanpa memerlukan kompilasi ulang APK — ini adalah keunggulan utama Dart dibandingkan bahasa lain dalam konteks pengembangan mobile.

Fitur utama Dart — sound null safety, diperkenalkan di Dart 2.12 (2021). Sistem tipe menjamin bahwa variabel tidak bisa null tanpa indikasi eksplisit (int?). Ini menghilangkan NullPointerException pada tahap kompilasi. Menurut data Google, penerapan null safety mengurangi jumlah crash di aplikasi Flutter sebesar 30% di lingkungan produksi.

Ekosistem Dart

Ekosistem Dart mencakup tiga arah utama: Flutter (aplikasi mobile dan desktop), AngularDart (aplikasi web) dan Dart Server (solusi server). Flutter — platform yang dominan: menurut Statista (2025), Flutter digunakan dalam 46% proyek mobile lintas platform, mengungguli React Native (38%) dan Xamarin (8%).

Sintaks Dart: tipe, fungsi, dan kelas

Sintaks Dart mirip dengan Java dan JavaScript, tetapi memiliki konstruksi uniknya sendiri. Semua di Dart adalah objek — bahkan int, double, dan bool mewarisi Object. Pengetikan bersifat opsional: variabel yang dideklarasikan sebagai var menyimpulkan tipe secara otomatis, tetapi disarankan untuk menentukan tipe secara eksplisit untuk keterbacaan dan kinerja.

Tipe dasar dan deklarasi

Dart mendukung int, double, String, bool, List, Set, Map, Record, Symbol, dan Runes. Tipe nullable — tipe apa pun dengan akhiran ? (int?, String?). Operator ?? (null-aware) mengembalikan nilai di kanan jika kiri adalah null. Notasi kaskade (..) memungkinkan pemanggilan beberapa metode pada objek yang sama tanpa mengulangi referensi.

// Tipe dasar dan deklarasi di Dart
void main() {
  // Pengetikan eksplisit
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — variabel bisa null
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Operator null-aware

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

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

// Record — tipe anonim tidak berubah
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

Tipe dynamic menonaktifkan pemeriksaan tipe — gunakan hanya saat bekerja dengan JSON atau data dinamis. Record — tipe baru di Dart 3.0, memungkinkan pengelompokan nilai tanpa membuat kelas terpisah. Operator null-aware ?? — cara standar bekerja dengan nilai nullable, menggantikan pemeriksaan if-else yang panjang.

Kelas dan mixin

Kelas di Dart — pewarisan tunggal (extends), ganda melalui mixin (mixin). Dart tidak mendukung antarmuka sebagai konsep terpisah — kelas apa pun dapat diimplementasikan (implements). Mixin — kelas tanpa konstruktor, yang metode dan bidangnya dapat ditambahkan ke kelas mana pun melalui kata kunci with.

// Kelas, pewarisan dan mixin di Dart
abstract class Animal {
  void sound(); // metode abstrak
}

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

// Konstruktor bernama
class Config {
  final String env;

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

Kelas Duck mewarisi Animal dan menggunakan dua mixin — Swimmer dan Flyer. Ini mendemonstrasikan pewarisan ganda tanpa masalah struktur belah ketupat: mixin diselesaikan secara linear (super chain). Konstruktor bernama (Config.development) — alternatif untuk metode pabrik statis untuk membuat objek dengan parameter yang telah ditentukan.

Async dalam Dart: Future, Stream dan async/await

Async dalam Dart diimplementasikan melalui Future (nilai tunggal), Stream (urutan nilai) dan async/await. Dart menggunakan model event loop single-thread, mirip dengan JavaScript, tetapi dengan perbedaan penting: komputasi yang lama tidak memblokir UI, karena kode Dart dieksekusi di Isolate — thread terpisah tanpa memori bersama.

Future mewakili operasi asinkron yang akan selesai setelah beberapa waktu. Future bisa dalam status pending (menunggu), completed with value (sukses) atau completed with error (error). Rantai .then().catchError() — alternatif untuk async/await, tetapi disarankan menggunakan await untuk keterbacaan.

// Pemuatan data asinkron dengan Future dan Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future untuk permintaan tunggal
  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 untuk urutan data
  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');

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

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

Kelas ApiService mendemonstrasikan dua jenis async: Future untuk permintaan HTTP (satu respons) dan Stream untuk penghitung sekuensial (generator dengan async* dan yield). Stream efisien untuk bekerja dengan sensor, geolokasi, Firebase Realtime Database — di mana pun data masuk secara terus-menerus. Isolate menggunakan memori terpisah — data dikirim melalui SendPort/ReceivePort.

Dart dan Flutter: arsitektur aplikasi

Dart dan Flutter membentuk satu tumpukan: Flutter — framework UI, Dart — bahasa deskripsi UI. Di Flutter, semuanya adalah widget (Widget) — dari tombol hingga seluruh aplikasi. Widget bisa stateful (dengan keadaan yang dapat diubah) dan stateless (tidak dapat diubah). Dart mendeskripsikan UI deklaratif: build() mengembalikan pohon widget yang dirender Flutter menggunakan Skia (atau Impeller di iOS).

Struktur aplikasi Flutter

Aplikasi Flutter di Dart terdiri dari main() → runApp(MyApp()) → MaterialApp. MaterialApp mencakup routing (routes), tema (theme) dan lokalisasi. Setiap layar adalah Scaffold, berisi AppBar, Body (biasanya Column/ListView) dan BottomNavigationBar. Navigasi melalui Navigator.push/pop atau rute bernama.

// Aplikasi Flutter sederhana di 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 dengan keadaan internal _counter. Panggilan setState() memberi tahu Flutter tentang perlunya membangun ulang UI — kode Dart memulai ulang build(), membuat pohon widget baru. Flutter membandingkan secara efisien (diff) pohon lama dan baru, hanya memperbarui bagian layar yang berubah. Hot Reload mengganti build() tanpa mereset keadaan _counter.

Kompilasi Dart: JIT vs AOT

Kompilasi Dart — hibrida: JIT untuk pengembangan dan AOT untuk produksi. Dalam mode debug, Dart VM menjalankan kompilator JIT yang menginterpretasi byte-code dengan kemungkinan penggantian kode panas. Dalam rilis, dart compile exe atau flutter build membuat biner AOT native untuk arsitektur tertentu (arm64, x86_64, armv7).

Kompilasi JIT Dart dalam mode debug menyediakan hot reload dalam ~1 detik — pengembang melihat perubahan UI tanpa kehilangan keadaan aplikasi. Kompilasi AOT memberikan kinerja yang mendekati aplikasi native Swift/Kotlin. Menurut data Google, Flutter di Dart AOT mencapai 60 FPS animasi bahkan pada perangkat kelas menengah.

Alat pengembang Dart

Alat pengembang Dart mencakup Dart SDK (kompilator dart, dartanalyzer, dartfmt, pub), Flutter SDK dan plugin IDE. Dart SDK diinstal bersama Flutter SDK di folder flutter/bin/cache/dart-sdk. Pub — manajer paket, membaca pubspec.yaml dan mengunduh dependensi dari pub.dev.

Alat utama

dart analyze — analisator statis yang memeriksa tipe, impor yang tidak digunakan dan potensi kesalahan. dart format — pemformat, secara otomatis membawa kode ke gaya seragam. dart doc — generator dokumentasi dari komentar ///. Flutter DevTools — profiler dengan tampilan pohon widget, log, memori dan jaringan. Dart VM Service — debug aplikasi yang berjalan melalui WebSocket.

# pubspec.yaml — konfigurasi proyek 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

File pubspec.yaml mendeskripsikan dependensi proyek Dart. Bidang environment:sdk menentukan versi Dart — stabil saat ini 3.x. Dependencies — pustaka utama, dev_dependencies — untuk pengujian dan pembuatan kode. json_annotation + json_serializable menghasilkan kode untuk serialisasi JSON melalui build_runner. flutter_lints — kumpulan aturan untuk analisator.