Kita bahas materi Variable di Dart dari dasar sampai memahami perbedaan var, dynamic, dan type annotation. Saya juga akan meluruskan beberapa istilah di transkrip supaya konsepnya tidak membingungkan.

1. Apa itu Variable?

Variable (variabel) adalah tempat untuk menyimpan atau mereferensikan data yang digunakan oleh program.

Misalnya:

int age = 20;

Kita bisa membaca ini sebagai:

“Buat sebuah variabel bernama age, bertipe int, dan isi dengan nilai 20.”

Secara sederhana, bayangkan variable seperti kotak yang memiliki nama:

age
┌─────────┐
│   20    │
└─────────┘

Kemudian kita bisa menggunakan nama age untuk mengakses nilainya:

print(age);

Output:

20

2. Variable dan Object di Dart

Ada satu konsep penting dari video:

“In Dart, everything is an object.”

Maksud sederhananya, banyak nilai yang kita gunakan di Dart direpresentasikan sebagai object.

Contohnya:

int age = 20;

20 merupakan object/nilai bertipe int.

Sedangkan age adalah nama variabel yang kita gunakan untuk mengakses nilai tersebut.

Secara konseptual bisa dibayangkan:

Variable
   │
   │ menunjuk/mereferensikan
   ▼
Object
┌─────────────┐
│     20      │
└─────────────┘

Jadi jangan terlalu terpaku pada istilah:

“Variable menyimpan alamat object.”

Untuk pemula, yang lebih penting adalah memahami:

Variable memberi kita nama untuk mengakses suatu nilai/object yang digunakan program.

3. Contoh Variable Sederhana

Misalnya kita membuat program data mahasiswa:

String name = "Siddharth";
int age = 20;
double height = 170.5;
bool isStudent = true;

Kita mempunyai empat variable:

Kemudian:

print(name);
print(age);
print(height);
print(isStudent);

Hasilnya:

Siddharth
20
170.5
true

4. Aturan Penamaan Variable di Dart

Ini bagian yang sangat penting.

Ketika membuat variable:

int age = 20;

age adalah nama variable.

Dart memiliki aturan mengenai nama tersebut.

4.1 Bisa menggunakan huruf

Contoh:

String name;
int age;
double price;

Huruf kecil maupun kapital bisa digunakan:

name
Name
NAME

Tetapi dalam praktik Dart, biasanya kita mengikuti gaya penamaan tertentu.

Umumnya gunakan camelCase:

firstName
lastName
phoneNumber
studentAge
totalPrice

Bukan:

first_name
FirstName
FIRSTNAME

Untuk variable biasa, gaya yang umum adalah camelCase.

5. Bisa Menggunakan Angka

Angka boleh digunakan dalam nama variable.

Contoh:

int age2;
String name123;
int student1;

Ini valid.

Tetapi ada aturan penting:

Nama variable tidak boleh diawali angka.

❌ Salah:

int 2age;

❌ Salah:

String 123name;

✅ Benar:

int age2;

✅ Benar:

String name123;

Jadi:

age2       ✅
student1   ✅
2age       ❌
1student   ❌

6. Underscore _

Underscore diperbolehkan.

Contoh:

int student_age;

Ini secara sintaks bisa valid.

Tetapi untuk variable biasa, konvensi Dart lebih umum menggunakan camelCase:

int studentAge;

Daripada:

int student_age;

Underscore juga memiliki peran khusus dalam Dart, terutama untuk private identifier pada library:

int _age = 20;

Untuk sekarang cukup ingat:

_ boleh digunakan dalam identifier

7. Dollar Sign $

Dart juga mengizinkan $ dalam identifier.

Contoh tertentu bisa menggunakan:

int price$;

Namun dalam kode Dart sehari-hari, kita hampir tidak perlu menggunakan $ sebagai bagian dari nama variable.

Jadi jangan berpikir:

“Karena boleh, berarti harus digunakan.”

Tidak.

Untuk pemula, jauh lebih baik biasakan:

studentName
totalPrice
userAge

8. Tidak Boleh Menggunakan Keyword

Dart mempunyai kata-kata khusus yang disebut keyword.

Contohnya:

class
if
else
for
while
return
var
dynamic
final
const
void

Kata-kata tersebut sudah memiliki fungsi khusus dalam bahasa Dart.

Karena itu kita tidak bisa sembarangan menjadikannya nama variable.

❌ Contoh:

int class = 10;

❌

String return = "hello";

❌

int var = 20;

Karena class, return, dan var sudah merupakan keyword.

9. Huruf Besar dan Kecil Itu Berbeda

Dart bersifat case-sensitive.

Artinya:

age

berbeda dengan:

Age

dan berbeda lagi dengan:

AGE

Contoh:

int age = 20;

print(age);

Benar.

Tetapi:

print(Age);

akan bermasalah karena Age bukan variable yang sama dengan age.

Bayangkan:

age  → variable A
Age  → variable B
AGE  → variable C

Meskipun terlihat mirip bagi manusia, Dart menganggapnya berbeda.

10. Cara Membuat Variable di Dart

Dalam materi ini ada tiga cara yang diperkenalkan:

1. Type annotation
2. var
3. dynamic

Mari kita bahas satu per satu.

11. Cara Pertama: Type Annotation

Ini cara yang paling eksplisit.

Kita menuliskan tipe data + nama variable + nilai.

Contoh:

int age = 20;

Strukturnya:

int       age       =       20
│         │         │       │
│         │         │       └── value
│         │         └────────── assignment
│         └──────────────────── variable name
└────────────────────────────── data type

Contoh lainnya:

double price = 19.99;

String name = "Siddharth";

bool isStudent = true;

12. Kenapa Disebut Type Annotation?

Karena kita secara eksplisit memberi tahu Dart tipe variable tersebut.

Misalnya:

int age = 20;

Kita mengatakan:

“age adalah int.”

Sehingga kita tidak bisa sembarangan memasukkan String:

int age = "twenty";

❌ Salah.

Karena "twenty" adalah String, bukan int.

Yang benar:

int age = 20;

13. Type Annotation dengan List

Di video ada contoh seperti:

List<int> values = [10, 20, 30];

Ini berarti:

values adalah sebuah List yang berisi data bertipe int.

Strukturnya:

List<int>
  │   │
  │   └── tipe item di dalam List
  └────── tipe collection

Isi:

values
   │
   ▼
┌─────────────────┐
│ 10 │ 20 │ 30    │
└─────────────────┘

Kita akan membahas List, Set, Map, dan Generics lebih mendalam nanti.

14. Cara Kedua: var

Nah, sekarang kita masuk ke bagian yang sangat penting.

Kita bisa menulis:

var age = 20;

Tidak seperti sebelumnya:

int age = 20;

Kita tidak menuliskan int.

Kenapa tetap bisa?

Karena Dart dapat menentukan tipe dari nilai yang diberikan.

var age = 20;

Dart melihat:

20
↓
int

Sehingga Dart mengetahui bahwa:

age → int

Secara sederhana:

var age = 20;
        ↓
Dart melihat 20
        ↓
Dart mengetahui tipe = int

15. Contoh var

var age = 20;
var name = "Budi";
var price = 25.5;
var isStudent = true;

Dart akan mengetahui:

age        → int
name       → String
price      → double
isStudent  → bool

Jadi var bukan berarti:

“Variable ini tidak punya tipe.”

Justru ini salah satu kesalahpahaman yang sering terjadi.

var tetap mempunyai tipe.

Contoh:

var age = 20;

Dart akan mengetahui bahwa age bertipe:

int

16. var Bukan Berarti Bisa Berubah Menjadi Apa Saja

Misalnya:

var age = 20;

Setelah itu:

age = 25;

✅ Boleh.

Karena:

20 → int
25 → int

Tetapi:

age = "Budi";

❌ Tidak boleh.

Karena:

age → int
"Budi" → String

Jadi walaupun kita menulis var, Dart tetap menjaga type safety.

17. Bagaimana Kalau Nilainya Berasal dari Function?

var juga bisa digunakan ketika nilai diperoleh dari function.

Contoh:

var name = getName();

Misalnya:

String getName() {
  return "Budi";
}

Maka:

var name = getName();

Dart dapat mengetahui tipe hasilnya berdasarkan return type function tersebut.

getName()
   ↓
String
   ↓
name

18. var dengan Expression

Expression adalah sesuatu yang menghasilkan sebuah nilai.

Contoh:

var result = 10 + 20;

Dart mengetahui:

10 + 20
  ↓
30
  ↓
int

Jadi:

result

bertipe int.

Contoh lain:

var price = 100 * 2;

Hasilnya:

price = 200

19. Cara Ketiga: dynamic

Sekarang kita masuk ke:

dynamic

Contoh:

dynamic value = 10;

Kita juga bisa:

dynamic value = "Hello";

atau:

dynamic value = true;

atau:

dynamic value = 10.5;

dynamic memberikan fleksibilitas lebih besar karena variable tersebut dapat menerima nilai dengan tipe berbeda.

Contoh:

dynamic value = 10;

value = "Hello";

value = true;

value = 10.5;

Secara konsep:

value
 │
 ├── 10
 │
 ├── "Hello"
 │
 ├── true
 │
 └── 10.5

Ini berbeda dengan var.

20. Perbedaan var dan dynamic

Ini inti penting dari video.

Lihat dua kode berikut.

var

var value = 10;

value = 20;       // ✅
value = "Hello";  // ❌

Karena setelah initialization:

value → int

Tipe tersebut sudah diketahui.

dynamic

dynamic value = 10;

value = 20;       // ✅
value = "Hello";  // ✅
value = true;     // ✅

Karena dynamic memberikan fleksibilitas tipe.

Perbandingannya:

21. Analogi var vs dynamic

Bayangkan ada dua kotak.

Kotak var

Awalnya kita masukkan angka:

var box = 10

Kotak tersebut seperti diberi label:

┌───────────────┐
│ BOX           │
│ Tipe: INTEGER │
│       10      │
└───────────────┘

Kita masih bisa mengganti:

10 → 20 → 30

selama tetap int.

Tetapi tidak:

10 → "Hello"

Kotak dynamic

dynamic box = 10;

Kotaknya lebih fleksibel:

┌───────────────┐
│ BOX           │
│ dynamic       │
│      10       │
└───────────────┘

Kemudian:

10
↓
"Hello"
↓
true
↓
10.5

Bisa berubah tipe.

22. Tapi Kenapa Tidak Selalu Pakai dynamic?

Ini pertanyaan yang sangat bagus.

Kalau dynamic sangat fleksibel, kenapa tidak semua variable menggunakan:

dynamic

?

Karena fleksibilitas tersebut juga bisa mengurangi keamanan dan bantuan dari compiler.

Misalnya:

dynamic value = "Hello";

Kita kemudian melakukan sesuatu yang hanya cocok untuk tipe tertentu.

Dengan dynamic, beberapa kesalahan tipe bisa baru terlihat saat program dijalankan, bukan sejak awal ketika kode dianalisis/di-compile.

Sementara type yang lebih spesifik memungkinkan Dart membantu kita lebih banyak.

Karena itu, dalam kode Dart normal, biasanya kita lebih menyukai:

String name = "Budi";

atau:

var name = "Budi";

daripada:

dynamic name = "Budi";

jika memang tidak ada alasan menggunakan dynamic.

23. Type Annotation vs var vs dynamic

Sekarang kita gabungkan semuanya.

Type annotation

int age = 20;

Kita sendiri mengatakan:

“age adalah int.”

var

var age = 20;

Kita mengatakan:

“Dart, tentukan tipe age berdasarkan nilai ini.”

Dart kemudian menyimpulkan:

age → int

dynamic

dynamic age = 20;

Kita mengatakan:

“age boleh memiliki nilai dengan tipe yang dinamis.”

24. Diagram Sederhana

                VARIABLE
                   │
       ┌───────────┼───────────┐
       │           │           │
       ▼           ▼           ▼
 Type Annotation   var       dynamic
       │           │           │
       │           │           │
       ▼           ▼           ▼
   int age=20   var age=20   dynamic age=20
       │           │           │
       ▼           ▼           ▼
   int tetap    Dart infer    lebih fleksibel
                 → int        tipe

25. Kapan Menggunakan Mana?

Untuk pemula, gunakan aturan praktis ini.

Gunakan type annotation ketika tipe ingin dibuat sangat jelas

int age = 20;
String name = "Budi";
double price = 10.5;

Ini sangat mudah dibaca.

Gunakan var ketika tipe sudah jelas dari nilai

var age = 20;
var name = "Budi";

Ini juga sangat umum di Dart.

Gunakan dynamic hanya ketika memang membutuhkan perilaku dinamis

dynamic data;

Misalnya ketika berinteraksi dengan data yang memang tidak diketahui bentuk/tipe pastinya pada saat compile-time.

Jangan menggunakan dynamic hanya karena:

“Saya malas menentukan tipe.”

26. Satu Hal yang Perlu Diluruskan dari Video

Video mengatakan ada tiga cara membuat variable:

type annotation
var
dynamic

Untuk tujuan pembelajaran awal, pembagian ini cukup membantu.

Tetapi sebenarnya Dart memiliki konsep deklarasi variable yang lebih luas, termasuk:

final
const
late

Misalnya:

final name = "Budi";

atau:

const pi = 3.14;

final dan const akan kita temui ketika membahas immutability dan constants.

Jadi jangan menganggap:

“Variable di Dart cuma bisa dibuat dengan tiga cara tersebut.”

Tiga cara itu adalah fokus materi video saat ini.

27. Contoh Program Lengkap

Coba lihat contoh berikut:

void main() {
  int age = 20;
  String name = "Budi";
  double height = 170.5;

  var city = "Madiun";
  var score = 90;

  dynamic data = 100;

  print(name);
  print(age);
  print(height);

  print(city);
  print(score);

  print(data);

  data = "Hello";
  print(data);
}

Secara konsep:

int age = 20
     ↓
age → int

String name = "Budi"
     ↓
name → String

var city = "Madiun"
     ↓
Dart infer → String

var score = 90
     ↓
Dart infer → int

dynamic data = 100
     ↓
data → dynamic
     ↓
bisa menjadi "Hello"

28. Kesalahan yang Sering Dilakukan Pemula

❌ Variable diawali angka

int 1age = 20;

Salah.

Gunakan:

int age1 = 20;

❌ Menggunakan keyword

int class = 10;

Salah.

❌ Menganggap var = bebas tipe

var age = 20;

age = "Budi";

Salah.

var bukan dynamic.

❌ Menggunakan dynamic untuk semuanya

dynamic name = "Budi";
dynamic age = 20;
dynamic price = 10.5;

Bisa saja dalam konteks tertentu, tetapi biasanya tidak diperlukan.

Lebih baik:

String name = "Budi";
int age = 20;
double price = 10.5;

atau:

var name = "Budi";
var age = 20;
var price = 10.5;

29. Cara Mudah Mengingat

Ingat tiga kata ini:

Explicit → Infer → Dynamic

1. Explicit — type annotation

int age = 20;

Kita secara langsung menyebutkan tipe.

2. Infer — var

var age = 20;

Dart menyimpulkan tipe dari nilai.

3. Dynamic — dynamic

dynamic age = 20;

Variable lebih fleksibel terhadap tipe.

30. Kesimpulan

Dari video ini, hal paling penting yang harus kamu pahami adalah:

VARIABLE
   │
   ├── nama untuk mengakses data/value
   │
   ├── punya aturan penamaan
   │     ├── tidak boleh diawali angka
   │     ├── keyword tidak boleh digunakan
   │     ├── case-sensitive
   │     └── _ dan $ diperbolehkan dalam identifier
   │
   └── bisa dideklarasikan dengan:
         │
         ├── Type annotation
         │      int age = 20;
         │
         ├── var
         │      var age = 20;
         │
         └── dynamic
                dynamic age = 20;

Dan perbedaan paling penting:

var x = 10;

➡️ Dart mengetahui x sebagai int, sehingga tidak bebas berubah menjadi String.

Sedangkan:

dynamic x = 10;

➡️ x dapat menerima nilai dengan tipe berbeda.

Jadi untuk kode Dart/Flutter sehari-hari, pola yang paling sering kamu temui adalah type yang jelas atau var, sedangkan dynamic digunakan ketika memang ada kebutuhan untuk perilaku dinamis.