Dart: ano ito, mga tampok ng wika ng Flutter at programming

Ano ang Dart?

Dart — programming language na may C-like syntax, na binuo ng Google sa pamumuno ni Lars Bak (lumikha ng Eclipse). Ang unang release ay noong 2011, ngunit ang tunay na kasikatan ng Dart ay dumating noong 2018 sa paglabas ng Flutter 1.0. Ang wika ay dinisenyo para sa paggawa ng user interfaces: mayroon itong built-in na suporta para sa mga stream, future at reactive pattern.

Ang pilosopiya ng Dart — "balanse ng performance at productivity". Sinusuportahan ng wika ang dalawang estratehiya ng compilation: JIT (Just-In-Time) para sa development na may hot reload at AOT (Ahead-Of-Time) para sa release build na may native performance. Ang JIT compiler ay nag-i-inject ng binagong code sa tumatakbong application sa millisecond, nang hindi nangangailangan ng recompilation ng APK — ito ang pangunahing bentahe ng Dart kumpara sa ibang mga wika sa konteksto ng mobile development.

Ang pangunahing tampok ng Dart — sound null safety, na ipinakilala sa Dart 2.12 (2021). Ginagarantiya ng type system na ang variable ay hindi maaaring maging null nang walang malinaw na indikasyon (int?). Tinatanggal nito ang NullPointerException sa yugto ng compilation. Ayon sa datos ng Google, ang pagpapatupad ng null safety ay nagbawas ng bilang ng mga crash sa Flutter applications ng 30% sa production environment.

Ecosystem ng Dart

Ecosystem ng Dart ay sumasaklaw sa tatlong pangunahing direksyon: Flutter (mobile at desktop applications), AngularDart (web applications) at Dart Server (server solutions). Flutter — ang dominanteng platform: ayon sa Statista (2025), ang Flutter ay ginagamit sa 46% ng cross-platform mobile projects, nangunguna sa React Native (38%) at Xamarin (8%).

Syntax ng Dart: mga uri, function at klase

Syntax ng Dart ay kahawig ng Java at JavaScript, ngunit may sariling natatanging konstruksyon. Lahat sa Dart ay object — kahit int, double at bool ay nagmamana ng Object. Ang pag-type ay opsyonal: ang variable na idineklara bilang var ay awtomatikong nagdi-deduce ng uri, ngunit inirerekomenda na malinaw na tukuyin ang mga uri para sa readability at performance.

Mga pangunahing uri at deklarasyon

Dart ay sumusuporta sa int, double, String, bool, List, Set, Map, Record, Symbol at Runes. Nullable type — anumang uri na may suffix ? (int?, String?). Ang operator ?? (null-aware) ay nagbabalik ng halaga sa kanan kung ang kaliwa ay null. Ang cascade notation (..) ay nagpapahintulot sa pagtawag ng maraming pamamaraan sa iisang object nang hindi inuulit ang reference.

// Mga pangunahing uri at deklarasyon sa Dart
void main() {
  // Eksplisitong pag-type
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — variable ay maaaring maging null
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Null-aware operator

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

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

// Record — anonymous immutable type
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

Ang uri na dynamic ay nagdi-disable ng type checking — gamitin lamang ito kapag nagtatrabaho sa JSON o dynamic na datos. Record — bagong uri sa Dart 3.0, na nagpapahintulot sa paggrupo ng mga halaga nang hindi gumagawa ng hiwalay na klase. Ang null-aware operator ?? — karaniwang paraan ng pagtatrabaho sa nullable values, na pumapalit sa mahabang if-else checks.

Mga klase at mixin

Mga klase sa Dart — solong inheritance (extends), maramihan sa pamamagitan ng mixin (mixin). Hindi sinusuportahan ng Dart ang interfaces bilang hiwalay na konsepto — anumang klase ay maaaring i-implement (implements). Mixin — klase na walang constructor, na ang mga pamamaraan at field ay maaaring idagdag sa anumang klase sa pamamagitan ng keyword na with.

// Mga klase, inheritance at mixin sa Dart
abstract class Animal {
  void sound(); // abstract method
}

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

// Named constructor
class Config {
  final String env;

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

Ang klase na Duck ay nagmamana ng Animal at gumagamit ng dalawang mixin — Swimmer at Flyer. Ipinapakita nito ang maramihang inheritance nang walang problema ng rhombus structure: ang mga mixin ay linear na nire-resolve (super chain). Ang mga named constructor (Config.development) — alternatibo sa static factory methods para sa paggawa ng mga object na may preset na parameter.

Asynchrony sa Dart: Future, Stream at async/await

Asynchrony sa Dart ay naipatupad sa pamamagitan ng Future (iisang halaga), Stream (pagkakasunod-sunod ng mga halaga) at async/await. Gumagamit ang Dart ng single-thread event loop model, katulad ng JavaScript, ngunit may mahalagang pagkakaiba: ang mahabang computation ay hindi bumabara sa UI, dahil ang Dart code ay isinasagawa sa Isolate — hiwalay na thread na walang shared memory.

Future ay kumakatawan sa isang asynchronous operation na makukumpleto pagkatapos ng ilang oras. Ang Future ay maaaring nasa estado na pending (naghihintay), completed with value (tagumpay) o completed with error (error). Ang chain na .then().catchError() — alternatibo sa async/await, ngunit inirerekomenda na gamitin ang await para sa readability.

// Asynchronous na pag-load ng datos gamit ang Future at Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future para sa iisang request
  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 para sa pagkakasunod-sunod ng datos
  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');

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

  // Pagproseso ng Stream gamit ang await for
  await for (final count in api.countStream(5)) {
    print('Count: $count');
  }
}

Ang klase na ApiService ay nagpapakita ng dalawang uri ng asynchrony: Future para sa HTTP request (isang tugon) at Stream para sa sequential counter (generator na may async* at yield). Ang Stream ay epektibo para sa pagtatrabaho sa mga sensor, geolocation, Firebase Realtime Database — kahit saan ang datos ay patuloy na dumarating. Ang Isolate ay gumagamit ng hiwalay na memorya — ang datos ay inihahatid sa pamamagitan ng SendPort/ReceivePort.

Dart at Flutter: arkitektura ng application

Dart at Flutter ay bumubuo ng isang stack: Flutter — UI framework, Dart — wika ng paglalarawan ng UI. Sa Flutter, lahat ay widget (Widget) — mula sa button hanggang sa buong application. Ang mga widget ay maaaring stateful (may nagbabagong estado) at stateless (hindi nagbabago). Inilalarawan ng Dart ang declarative UI: ang build() ay nagbabalik ng widget tree na ni-re-render ng Flutter gamit ang Skia (o Impeller sa iOS).

Istraktura ng Flutter application

Flutter application sa Dart ay binubuo ng main() → runApp(MyApp()) → MaterialApp. Ang MaterialApp ay may kasamang routing (routes), theme at localization. Bawat screen ay Scaffold, na naglalaman ng AppBar, Body (karaniwang Column/ListView) at BottomNavigationBar. Navigation sa pamamagitan ng Navigator.push/pop o named routes.

// Simpleng Flutter application sa 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 na HomeScreen — StatefulWidget na may panloob na estado na _counter. Ang pagtawag ng setState() ay nagpapaalam sa Flutter tungkol sa pangangailangan na muling itayo ang UI — ang Dart code ay nagre-restart ng build(), na lumilikha ng bagong widget tree. Epektibong inihahambing (diff) ng Flutter ang luma at bagong tree, na ina-update lamang ang mga nabagong bahagi ng screen. Pinapalitan ng Hot Reload ang build() nang hindi nire-reset ang estado na _counter.

Compilation ng Dart: JIT vs AOT

Compilation ng Dart — hybrid: JIT para sa development at AOT para sa production. Sa debug mode, ang Dart VM ay nagpapatakbo ng JIT compiler na nag-i-interpret ng byte-code na may posibilidad ng hot code replacement. Sa release, ang dart compile exe o flutter build ay gumagawa ng native AOT binary para sa specific na arkitektura (arm64, x86_64, armv7).

JIT compilation ng Dart sa debug mode ay nagbibigay ng hot reload sa ~1 segundo — nakikita ng developer ang mga pagbabago sa UI nang hindi nawawala ang estado ng application. Ang AOT compilation ay nagbibigay ng performance na malapit sa native Swift/Kotlin applications. Ayon sa datos ng Google, ang Flutter sa Dart AOT ay umaabot sa 60 FPS animation kahit sa mid-range na device.

Mga tool ng Dart developer

Mga tool ng Dart developer ay kinabibilangan ng Dart SDK (compiler na dart, dartanalyzer, dartfmt, pub), Flutter SDK at IDE plugins. Ang Dart SDK ay naka-install kasama ng Flutter SDK sa folder na flutter/bin/cache/dart-sdk. Pub — package manager, na nagbabasa ng pubspec.yaml at nagdo-download ng dependencies mula sa pub.dev.

Mga pangunahing tool

dart analyze — static analyzer na sumusuri ng mga uri, hindi nagamit na import at potensyal na error. dart format — formatter, na awtomatikong nagdadala ng code sa pare-parehong estilo. dart doc — generator ng documentation mula sa /// comments. Flutter DevTools — profiler na may view ng widget tree, logs, memory at network. Dart VM Service — debugging ng tumatakbong application sa pamamagitan ng WebSocket.

# pubspec.yaml — configuration ng Dart project
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

Ang file na pubspec.yaml ay naglalarawan ng dependencies ng Dart project. Ang field na environment:sdk ay tumutukoy sa bersyon ng Dart — kasalukuyang stable 3.x. Dependencies — pangunahing library, dev_dependencies — para sa testing at code generation. json_annotation + json_serializable ay gumagawa ng code para sa JSON serialization sa pamamagitan ng build_runner. flutter_lints — set ng mga patakaran para sa analyzer.