Dart: bu nima, Flutter tilining xususiyatlari va dasturlash

Dart nima?

Dart — C-ga o'xshash sintaksisga ega, Google kompaniyasi tomonidan Lars Bakk (Eclipse yaratuvchisi) rahbarligida ishlab chiqilgan dasturlash tili. Birinchi reliz 2011-yilda bo'lib o'tdi, ammo Dart haqiqiy mashhurlikka 2018-yilda Flutter 1.0 chiqishi bilan erishdi. Til foydalanuvchi interfeyslarini yaratish uchun mo'ljallangan: u strimlar, futurelar va reaktiv naqshlar uchun o'rnatilgan qo'llab-quvvatlashga ega.

Dart falsafasi — "unumdorlik va mahsuldorlik muvozanati". Til ikkita kompilyatsiya strategiyasini qo'llab-quvvatlaydi: issiq qayta yuklash bilan ishlab chiqish uchun JIT (Just-In-Time) va mahalliy unumdorlik bilan reliz yig'imlari uchun AOT (Ahead-Of-Time). JIT-kompilyator o'zgartirilgan kodni ishlayotgan ilovaga millisekundlar ichida kiritadi, APKni qayta kompilyatsiya qilishni talab etmaydi — bu Dartning mobil ishlanma kontekstida boshqa tillarga nisbatan asosiy ustunligidir.

Dartning asosiy xususiyati — Dart 2.12 (2021) da joriy qilingan sound null safety. Tur tizimi o'zgaruvchining aniq ko'rsatmasiz (int?) null bo'lishi mumkin emasligini kafolatlaydi. Bu NullPointerExceptionni kompilyatsiya bosqichida yo'q qiladi. Google ma'lumotlariga ko'ra, null safety joriy qilinishi Flutter ilovalaridagi qulashlar sonini ishlab chiqarish muhitida 30% ga kamaytirdi.

Dart ekotizimi

Dart ekotizimi uchta asosiy yo'nalishni o'z ichiga oladi: Flutter (mobil va ish stoli ilovalari), AngularDart (veb-ilovalar) va Dart Server (server yechimlari). Flutter — dominant platforma: Statista (2025) ma'lumotlariga ko'ra, Flutter kross-platformali mobil loyihalarning 46 foizida qo'llaniladi, React Native (38 foiz) va Xamarin (8 foiz) dan oldinda.

Dart sintaksisi: turlar, funksiyalar va sinflar

Dart sintaksisi Java va JavaScriptni eslatadi, lekin o'ziga xos konstruksiyalarga ega. Dartda hamma narsa ob'ektdir — hatto int, double va bool Objectdan meros oladi. Tiplash ixtiyoriy: var deb e'lon qilingan o'zgaruvchi turni avtomatik chiqaradi, ammo o'qilish va unumdorlik uchun turlarni aniq ko'rsatish tavsiya etiladi.

Asosiy turlar va e'lonlar

Dart int, double, String, bool, List, Set, Map, Record, Symbol va Runesni qo'llab-quvvatlaydi. Nullable tur — ? qo'shimchali istalgan tur (int?, String?). ?? operatori (null-aware) chapda null bo'lsa o'ngdagi qiymatni qaytaradi. Kaskad notatsiyasi (..) bir ob'ektda referensni takrorlamasdan bir nechta metodni chaqirishga imkon beradi.

// Dartda asosiy turlar va e'lonlar
void main() {
  // Aniq tiplash
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — o'zgaruvchi null bo'lishi mumkin
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Null-aware operatori

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

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

// Record — anonim o'zgarmas tur
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

dynamic turi tur tekshiruvini o'chiradi — uni faqat JSON yoki dinamik ma'lumotlar bilan ishlashda foydalaning. Record — Dart 3.0 dagi yangi tur, alohida sinf yaratmasdan qiymatlarni guruhlashga imkon beradi. Null-aware operator ?? — nullable qiymatlar bilan ishlashning standart usuli, uzun if-else tekshiruvlarini almashtiradi.

Sinflar va miksinlar

Dartda sinflar — yakka meros (extends), miksinalar orqali ko'p (mixin). Dart interfeyslarni alohida tushuncha sifatida qo'llab-quvvatlamaydi — istalgan sinf implementatsiya qilinishi mumkin (implements). Miksin — konstruktori bo'lmagan sinf, uning metodlari va maydonlari with kalit so'zi orqali istalgan sinfga qo'shilishi mumkin.

// Dartda sinflar, meros va miksinalar
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...
}

// Nomlangan konstruktor
class Config {
  final String env;

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

Duck sinfi Animaldan meros oladi va ikkita miksin — Swimmer va Flyerdan foydalanadi. Bu rombsimon struktura muammolarisiz ko'p merosni namoyish etadi: miksinalar chiziqli hal qilinadi (super chain). Nomlangan konstruktorlar (Config.development) — oldindan o'rnatilgan parametrlar bilan ob'ektlar yaratish uchun statik fabrika metodlariga alternativadir.

Dartda asinxronlik: Future, Stream va async/await

Dartda asinxronlik Future (yakka qiymat), Stream (qiymatlar ketma-ketligi) va async/await orqali amalga oshiriladi. Dart JavaScriptga o'xshash bir oqimli event loop modelidan foydalanadi, ammo muhim farq bilan: uzoq muddatli hisoblashlar UI ni bloklamaydi, chunki Dart kodi Isolateda — umumiy xotirasiz alohida oqimda bajariladi.

Future bir muncha vaqtdan keyin tugallanadigan asinxron operatsiyani ifodalaydi. Future pending (kutish), completed with value (muvaffaqiyat) yoki completed with error (xato) holatida bo'lishi mumkin. .then().catchError() zanjiri — async/await ga alternativ, ammo o'qilish uchun awaitdan foydalanish tavsiya etiladi.

// Future va Stream bilan asinxron ma'lumotlarni yuklash
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Yakka so'rov uchun Future
  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}');
    }
  }

  // Ma'lumotlar ketma-ketligi uchun Stream
  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');

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

  // Streamni await for bilan qayta ishlash
  await for (final count in api.countStream(5)) {
    print('Count: $count');
  }
}

ApiService sinfi ikki tur asinxronlikni namoyish etadi: HTTP so'rovi uchun Future (bitta javob) va ketma-ket hisoblagich uchun Stream (async* va yield bilan generator). Stream sensorlar, geolokatsiya, Firebase Realtime Database bilan ishlash uchun samarali — ma'lumotlar uzluksiz kelib turadigan hamma joyda. Isolate alohida xotiradan foydalanadi — ma'lumotlar SendPort/ReceivePort orqali uzatiladi.

Dart va Flutter: ilova arxitekturasi

Dart va Flutter yagona stackni tashkil qiladi: Flutter — UI freymvorki, Dart — UI tavsiflash tili. Flutterda hamma narsa vidjetdir (Widget) — tugmadan to butun ilovagacha. Vidjetlar stateful (o'zgaruvchan holatli) va stateless (o'zgarmas) bo'lishi mumkin. Dart deklarativ UI ni tavsiflaydi: build() Flutter Skia (yoki iOSda Impeller) orqali render qiladigan vidjetlar daraxtini qaytaradi.

Flutter ilovasining tuzilishi

Flutter ilovasi Dartda main() → runApp(MyApp()) → MaterialApp dan iborat. MaterialApp marshrutlashtirish (routes), mavzu (theme) va lokalizatsiyani o'z ichiga oladi. Har bir ekran — AppBar, Body (odatda Column/ListView) va BottomNavigationBardan iborat Scaffold. Navigator.push/pop yoki nomlangan marshrutlar orqali navigatsiya.

// Dartda oddiy Flutter ilovasi
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),
      ),
    );
  }
}

HomeScreen vidjeti — ichki _counter holatiga ega StatefulWidget. setState() chaqiruvi Flutterni UI ni qayta qurish zarurligi haqida xabardor qiladi — Dart kodi build()ni qayta ishga tushiradi, yangi vidjetlar daraxtini yaratadi. Flutter eski va yangi daraxtni samarali taqqoslaydi (diff), ekranning faqat o'zgargan qismlarini yangilaydi. Hot Reload _counter holatini tiklamasdan build()ni almashtiradi.

Dart kompilyatsiyasi: JIT vs AOT

Dart kompilyatsiyasi — gibrid: ishlab chiqish uchun JIT va ishlab chiqarish uchun AOT. Debug rejimida Dart VM kodni issiq almashtirish imkoniyati bilan bayt-kodni sharhlovchi JIT-kompilyatorni ishga tushiradi. Relizda dart compile exe yoki flutter build ma'lum arxitektura (arm64, x86_64, armv7) uchun mahalliy AOT binar faylini yaratadi.

Dartning debug rejimida JIT kompilyatsiyasi ~1 soniyada issiq qayta yuklashni ta'minlaydi — dasturchi ilova holatini yo'qotmasdan UI o'zgarishlarini ko'radi. AOT kompilyatsiyasi mahalliy Swift/Kotlin ilovalariga yaqin unumdorlik beradi. Google ma'lumotlariga ko'ra, Dart AOTdagi Flutter o'rta segment qurilmalarida ham 60 FPS animatsiyaga erishadi.

Dart dasturchisining vositalari

Dart dasturchisining vositalari Dart SDK (dart kompilyatori, dartanalyzer, dartfmt, pub), Flutter SDK va IDE plaginlarini o'z ichiga oladi. Dart SDK Flutter SDK bilan birga flutter/bin/cache/dart-sdk papkasida o'rnatiladi. Pub — paket boshqaruvchisi, pubspec.yaml faylini o'qiydi va bog'liqliklarni pub.dev dan yuklab oladi.

Asosiy vositalar

dart analyze — turlarni, foydalanilmagan importlarni va potentsial xatolarni tekshiruvchi statik analizator. dart format — kodni yagona uslubga avtomatik moslashtiruvchi formatlagich. dart doc — /// sharhlaridan hujjat generatori. Flutter DevTools — vidjetlar daraxti, loglar, xotira va tarmoqni ko'rish imkoniyatiga ega profiler. Dart VM Service — WebSocket orqali ishlayotgan ilovani tuzatish.

# pubspec.yaml — Dart loyihasining konfiguratsiyasi
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

pubspec.yaml fayli Dart loyihasining bog'liqliklarini tavsiflaydi. environment:sdk maydoni Dart versiyasini belgilaydi — joriy barqaror 3.x. Dependencies — asosiy kutubxonalar, dev_dependencies — test va kod generatsiyasi uchun. json_annotation + json_serializable build_runner orqali JSON serializatsiyasi uchun kod yaratadi. flutter_lints — analizator uchun qoidalar to'plami.