Variabel #

int angka = 42;
// Variabel 'angka' menyimpan referensi ke objek int dengan nilai 42
// bukan nilai 42 secara langsung di stack seperti di C/Java

var nama = 'Budi';        // Dart menyimpulkan: String
var umur = 25;            // Dart menyimpulkan: int
var tinggi = 1.75;        // Dart menyimpulkan: double
var aktif = true;         // Dart menyimpulkan: bool
var skor = [90, 85, 92];  // Dart menyimpulkan: List<int>

// Setelah tipe disimpulkan, tidak bisa diganti tipe lain
nama = 'Siti';   // ✓ String ke String
nama = 42;       // ✗ error: int tidak bisa diassign ke String

// ANTI-PATTERN: menggunakan var ketika tipe tidak obvious dari nilai
var hasil = prosesData();        // apa tipe kembalian prosesData()?
var x = a * b + c / d;          // tipe apa yang dihasilkan ekspresi ini?
var config = ambilKonfigurasi(); // Map? Object? String? tidak jelas

// BENAR: gunakan tipe eksplisit ketika tipe tidak obvious
double hasilHitung = a * b + c / d;
Map<String, dynamic> config = ambilKonfigurasi();
List<Produk> daftarProduk = repository.ambilSemua();

String nama = 'Budi';
int umur = 25;
double gaji = 8_500_000.0;   // underscore sebagai pemisah ribuan — valid di Dart
bool sudahVerifikasi = false;

// Tipe koleksi dengan generic
List<String> kota = ['Jakarta', 'Bandung', 'Surabaya'];
Map<String, int> skor = {'matematika': 90, 'fisika': 85};
Set<String> tag = {'dart', 'flutter', 'mobile'};

// 1. Deklarasi tanpa nilai awal (tidak bisa pakai var)
String namaLengkap;           // ✓ tipe eksplisit
// var namaLengkap;           // ✗ var tanpa nilai awal: tipe jadi dynamic

// 2. Parameter fungsi
void sapa(String nama, int umur) { ... }   // ✓
// void sapa(var nama, var umur) { ... }   // ✗ tidak valid

// 3. Return type fungsi
String formatNama(String depan, String belakang) {  // ✓
  return '$depan $belakang';
}

// 4. Properti kelas
class Pengguna {
  String nama;              // ✓ tipe eksplisit di properti kelas
  int umur;
  Pengguna(this.nama, this.umur);
}

final String nama = 'Budi';
// nama = 'Siti'; // ✗ error: final variable tidak bisa di-assign ulang

final umur = 25;  // tipe diinferensikan: int

// Inisialisasi bisa ditunda ke runtime (berbeda dari const)
final DateTime sekarang = DateTime.now();        // ✓ nilai runtime
final List<String> kota = ['Jakarta', 'Bandung'];

// Variabel final sendiri tidak bisa diganti, tapi isi list masih bisa
kota.add('Surabaya');   // ✓ isi list bisa dimodifikasi
kota = ['Medan'];       // ✗ error: referensi final tidak bisa diganti

// ANTI-PATTERN: semua variabel var padahal sebagian tidak pernah diubah
var nama = 'Budi';           // nama tidak pernah diubah di sisa kode
var umur = 25;               // umur juga tidak pernah diubah
var counter = 0;             // counter diubah di dalam loop — ini wajar pakai var

// BENAR: final untuk yang tidak berubah, var/tipe eksplisit untuk yang berubah
final String nama = 'Budi';
final int umur = 25;
int counter = 0;             // ini memang perlu diubah

class Produk {
  final String id;          // tidak boleh berubah setelah dibuat
  final String nama;
  double harga;             // harga bisa berubah (misal saat promosi)
  int stok;                 // stok berubah saat transaksi

  Produk({
    required this.id,
    required this.nama,
    required this.harga,
    this.stok = 0,
  });
}

const double pi = 3.14159265358979;
const int maksimalRetry = 3;
const String versiApp = '1.0.0';

// Ekspresi const juga valid — asalkan semua komponennya const
const double duaPi = 2 * pi;          // ✓ semua komponen sudah diketahui
const int batasMaksimal = 10 * 10;    // ✓ literal aritmatika

// ANTI-PATTERN: mencoba membuat nilai runtime menjadi const
const DateTime sekarang = DateTime.now(); // ✗ error: DateTime.now() adalah runtime value
const String input = stdin.readLineSync()!; // ✗ error: input pengguna adalah runtime

// BENAR: gunakan final untuk nilai yang hanya bisa ditentukan saat runtime
final DateTime sekarang = DateTime.now(); // ✓
final String input = stdin.readLineSync()!; // ✓

// Objek const — satu instance dibagi di seluruh program (canonical instance)
const listKonstanta = [1, 2, 3];    // List<int> yang immutable sepenuhnya
const mapKonstanta = {'a': 1};      // Map yang immutable sepenuhnya

// Berbeda dengan final list yang hanya referensinya yang tidak bisa diganti
final listFinal = [1, 2, 3];
listFinal.add(4);        // ✓ isi list final bisa dimodifikasi
listKonstanta.add(4);    // ✗ error: const list tidak bisa dimodifikasi sama sekali

// Kelas yang mendukung const constructor
class Warna {
  final int r, g, b;
  const Warna(this.r, this.g, this.b);
}

// Instance const — dibuat sekali saat compile, tidak dibuat ulang saat runtime
const Warna merah = Warna(255, 0, 0);
const Warna hijau = Warna(0, 255, 0);

// Identitas referensi terjamin sama untuk nilai const yang identik
const a = Warna(255, 0, 0);
const b = Warna(255, 0, 0);
print(identical(a, b)); // true — satu objek yang sama

// Non-nullable — dijamin tidak pernah null oleh compiler
String nama = 'Budi';
int umur = 25;
// nama = null;  // ✗ error kompilasi

// Nullable — bisa menyimpan null, harus ditangani sebelum digunakan
String? alamat;          // nilai awal: null
int? nilaiUjian;         // nilai awal: null

alamat = 'Jl. Merdeka 1';
nilaiUjian = null;       // ✓ valid untuk nullable

String? kota;

// 1. Operator ?? — berikan nilai default jika null
String tampilan = kota ?? 'Kota tidak diketahui';

// 2. Operator ?. — akses properti/method hanya jika tidak null
int? panjangKota = kota?.length;    // hasilnya int? bukan int

// 3. if null check — Dart melakukan type promotion setelah pengecekan
if (kota != null) {
  // Di dalam blok ini, Dart tahu 'kota' pasti String (bukan String?)
  print(kota.length);   // ✓ aman, tidak perlu ?.
  print(kota.toUpperCase());
}

// 4. Null assertion operator ! — paksa non-null (gunakan dengan hati-hati)
print(kota!.length);    // throws jika kota ternyata null saat runtime

// ANTI-PATTERN: menggunakan ! secara sembarangan tanpa menjamin nilainya
String? input = ambilInputPengguna();
print(input!.length);   // ✗ akan crash jika pengguna tidak mengisi apapun

// BENAR: tangani null secara eksplisit
String? input = ambilInputPengguna();
if (input == null || input.isEmpty) {
  print('Input tidak boleh kosong');
  return;
}
// Di sini, Dart tahu input pasti non-null
print(input.length);   // ✓ aman

String? nama;
nama ??= 'Tamu';    // assign 'Tamu' hanya jika nama masih null
print(nama);        // Tamu

nama ??= 'Admin';   // tidak melakukan apa-apa karena nama sudah 'Tamu'
print(nama);        // Tamu

late String koneksiDatabase;

void inisialisasiApp() {
  koneksiDatabase = 'postgresql://localhost/mydb';
}

void main() {
  inisialisasiApp();
  print(koneksiDatabase);  // ✓ aman, sudah diinisialisasi
}

class FormPendaftaran extends StatefulWidget {
  // Controller ini harus diinisialisasi di initState(), bukan di konstruktor
  late TextEditingController namaController;
  late TextEditingController emailController;

  @override
  void initState() {
    super.initState();
    namaController = TextEditingController();
    emailController = TextEditingController();
  }

  @override
  void dispose() {
    namaController.dispose();
    emailController.dispose();
    super.dispose();
  }
}

class LaporanBulanan {
  // Data ini mahal untuk dihitung — hanya dihitung sekali saat pertama diakses
  late final List<Transaksi> _transaksiTerfilter = _hitungTransaksi();

  List<Transaksi> _hitungTransaksi() {
    // Operasi berat: query database, filter, sort
    print('Menghitung transaksi...'); // hanya muncul sekali
    return repository.ambilSemua().where((t) => t.bulan == bulanIni).toList();
  }
}

class KoneksiDatabase {
  late final String connectionString;

  void hubungkan(String host, String dbName) {
    connectionString = 'postgresql://$host/$dbName'; // hanya bisa di-set sekali
  }
}

// ANTI-PATTERN: menggunakan late untuk menghindari null safety tanpa alasan jelas
class Pengguna {
  late String nama;      // ✗ lebih baik nullable String? atau required di konstruktor
  late int umur;         // ✗ mengundang LateInitializationError yang sulit di-debug
}

// BENAR: gunakan null safety secara eksplisit
class Pengguna {
  String? nama;          // nullable jika memang bisa tidak ada
  int umur;

  Pengguna({required this.umur, this.nama});
}

// Top-level variable — bisa diakses dari seluruh file
int hitungGlobal = 0;

class Kalkulator {
  // Instance variable — bisa diakses dari semua method di kelas ini
  double _memori = 0;

  double tambah(double a, double b) {
    // Local variable — hanya ada di dalam fungsi ini
    double hasil = a + b;

    if (hasil > 1000) {
      // Block variable — hanya ada di dalam blok if ini
      String pesan = 'Hasil sangat besar: $hasil';
      print(pesan);
    }

    // print(pesan); // ✗ error: 'pesan' tidak ada di scope sini

    return hasil;
  }
}

String nama = 'Global';

void contohShadowing() {
  String nama = 'Lokal';   // menyembunyikan variabel global 'nama'
  print(nama);             // Lokal

  {
    String nama = 'Block'; // menyembunyikan 'Lokal'
    print(nama);           // Block
  }

  print(nama);             // Lokal — kembali ke scope fungsi
}

// ANTI-PATTERN: shadowing yang tidak disengaja menyebabkan bug halus
class PenghitungSkor {
  int skor = 0;

  void tambahPoin(int skor) {    // parameter 'skor' menyembunyikan field 'skor'
    skor += 10;                   // ini mengubah parameter, BUKAN field!
    // Field this.skor tidak berubah — bug yang sulit dilacak
  }
}

// BENAR: gunakan nama yang berbeda atau this. untuk membedakan
class PenghitungSkor {
  int skor = 0;

  void tambahPoin(int poin) {    // nama parameter berbeda
    skor += poin;                // jelas: 'skor' adalah field
  }

  // Atau jika memang harus sama nama:
  void setSkor(int skor) {
    this.skor = skor;            // this. menunjuk ke field secara eksplisit
  }
}

Function buatPenghitung(int mulaiDari) {
  int hitung = mulaiDari;  // variabel ini di-capture oleh closure

  return () {
    hitung++;              // mengakses dan memodifikasi variabel luar
    return hitung;
  };
}

void main() {
  var hitungA = buatPenghitung(0);
  var hitungB = buatPenghitung(10);

  print(hitungA()); // 1
  print(hitungA()); // 2
  print(hitungB()); // 11 — state masing-masing closure terpisah
  print(hitungA()); // 3
}

// Inference dari literal
var angka = 42;          // int
var teks = 'halo';       // String
var daftar = [1, 2, 3];  // List<int>
var peta = {'a': 1};     // Map<String, int>

// Inference dari ekspresi
var hasil = 10 / 3;      // double (bukan int, meski keduanya int)
var gabung = [1, 2] + [3, 4]; // ✗ tidak valid — Dart tidak overload operator +

// Inference di generic
var pasangan = {'nama': 'Budi', 'umur': 25};
// Dart menyimpulkan: Map<String, Object> karena nilai campuran String dan int

// ANTI-PATTERN: var pada deklarasi tanpa nilai — hasilnya dynamic
var tanpaNilai;              // ✗ Dart menyimpulkan dynamic, kehilangan type safety
tanpaNilai = 'teks';         // ✓ valid
tanpaNilai = 42;             // ✓ juga valid — tapi ini membingungkan
tanpaNilai = [1, 2, 3];      // ✓ juga valid — sama sekali tidak type-safe

// BENAR: gunakan tipe eksplisit jika tidak memberikan nilai awal
String? namaDepan;           // jelas tipenya String?
int? skorUjian;              // jelas tipenya int?

// dynamic — matikan type checker sepenuhnya (hindari jika bisa)
dynamic apa = 'teks';
apa = 42;                // ✓ valid
apa.metodeTidakAda();    // ✓ valid saat compile, ✗ crash saat runtime

// Object — supertype semua tipe non-nullable (type-safe, tapi butuh cast)
Object sesuatu = 'teks';
sesuatu = 42;            // ✓ valid
// sesuatu.length;       // ✗ error kompilasi: Object tidak punya .length
(sesuatu as String).length; // ✓ cast eksplisit diperlukan

// var — tipe diinferensikan, tetap type-safe setelah inferensi
var inferensi = 'teks';  // disimpulkan: String
// inferensi = 42;       // ✗ error: int tidak bisa ke String
inferensi.length;        // ✓ Dart tahu ini String, .length valid

// ANTI-PATTERN: menggunakan dynamic sebagai cara mudah menghindari tipe
dynamic data = ambilDariApi();
print(data.nama);     // crash saat runtime jika API berubah format

// BENAR: definisikan tipe yang jelas atau gunakan pattern matching
Map<String, dynamic> data = ambilDariApi();
String nama = data['nama'] as String;  // cast eksplisit dengan pesan error yang jelas

// ✓ lowerCamelCase untuk variabel dan parameter
String namaLengkap = 'Budi Santoso';
int jumlahKunjungan = 0;
bool sudahLogin = false;

// ✓ _lowerCamelCase untuk variabel dan method private
String _tokenSesi = '';
int _hitungInternal = 0;

// ✓ UpperCamelCase untuk nama kelas dan tipe
class PenggunaPremium { ... }
typedef KallbackData = void Function(String data);

// ✓ lowerCamelCase untuk konstanta (berbeda dari Java/C yang pakai SCREAMING_CASE)
const int batasUlangCoba = 3;         // ✓ Dart style
// const int BATAS_ULANG_COBA = 3;   // ✗ bukan Dart style

// ✓ Nama yang deskriptif, hindari singkatan yang tidak umum
int jumlahPengguna = 100;   // ✓
int jlhPngg = 100;          // ✗ singkatan tidak perlu
int n = 100;                // ✗ terlalu singkat, tidak bermakna

// ANTI-PATTERN: nama variabel yang tidak bermakna
var a = hitungTotal();
var b = ambilPengguna();
var c = a * 1.1;

// BENAR: nama yang menjelaskan maksud
double subtotal = hitungTotal();
Pengguna penggunaSaatIni = ambilPengguna();
double totalDenganPajak = subtotal * 1.1;