Video ini membahas perbedaan yang sangat penting antara var dan dynamic di Dart.

Kalau video sebelumnya kita sudah tahu bahwa keduanya bisa digunakan untuk membuat variable, sekarang fokusnya adalah:

Apa sebenarnya perbedaan var dan dynamic? Mengapa var lebih aman? Kapan dynamic dibutuhkan?

Saya akan jelaskan dari konsep paling dasar, lalu masuk ke contoh error compile-time vs runtime, karena ini inti dari video.

1. Ingat kembali: var dan dynamic

Kita bisa membuat variable seperti ini:

var x = 10;

atau:

dynamic x = 10;

Sekilas terlihat hampir sama.

Tetapi perilakunya berbeda.

Perbedaan sederhananya:

var
↓
Dart mencari tahu tipe variable
↓
tipe menjadi relatif tetap

dynamic
↓
Dart membiarkan variable bersifat dinamis
↓
tipe value bisa berubah

Contoh:

var x = 10;

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

Sedangkan:

dynamic x = 10;

x = 20;       // ✅
x = "Hello";  // ✅

Nah, kenapa bisa begitu?

2. var Itu Bukan Sebuah Type

Ini poin pertama yang ditekankan video.

Ketika kita menulis:

var x = 10;

var bukan tipe data sebenarnya seperti:

int
String
double
bool

var adalah keyword yang meminta Dart melakukan type inference.

Contoh:

var x = 10;

Dart melihat:

10
↓
int

Maka Dart mengetahui bahwa:

x → int

Jadi secara konsep:

var x = 10;

kurang lebih Dart mengetahui:

x adalah int

3. Apa Itu Type Inference?

Type inference adalah kemampuan Dart untuk menentukan tipe data berdasarkan nilai yang diberikan.

Misalnya:

var age = 20;

Dart melihat:

20
↓
int

Maka:

age → int

Contoh lainnya:

var name = "Budi";

Dart mengetahui:

name → String

Dan:

var price = 10.5;

Dart mengetahui:

price → double

Jadi kita tidak harus selalu menulis:

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

Kita bisa menulis:

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

Dart akan melakukan inferensi.

4. dynamic Berbeda

Sekarang:

dynamic x = 10;

Di sini kita secara eksplisit mengatakan kepada Dart:

“x adalah variable dynamic.”

dynamic merupakan type yang khusus dalam Dart.

Karena itu dynamic dapat digunakan dalam berbagai posisi yang membutuhkan tipe.

Misalnya secara konsep kita dapat mempunyai function:

dynamic test() {
  return 10;
}

Artinya function tersebut memiliki return type dynamic.

Sedangkan:

var test() {
  return 10;
}

tidak valid untuk digunakan sebagai return type seperti itu.

Kenapa?

Karena:

var
↓
keyword untuk deklarasi variable + type inference

sedangkan:

dynamic
↓
keyword + sebuah type yang bisa digunakan sebagai type

Ini salah satu perbedaan fundamental antara keduanya.

5. Analogi Sederhana

Bayangkan kita punya dua kotak.

Kotak var

Pertama kita masukkan angka:

var box = 10;

Dart berkata:

“Oh, isi kotak ini int.”

┌──────────────┐
│ box          │
│ type: int    │
│ value: 10    │
└──────────────┘

Kemudian:

box = 20;

Boleh, karena 20 juga int.

Tetapi:

box = "Hello";

Tidak boleh, karena sekarang kita mencoba memasukkan String ke variable yang sudah diketahui sebagai int.

Kotak dynamic

dynamic box = 10;

Kotaknya lebih fleksibel:

┌────────────────┐
│ box            │
│ type: dynamic  │
│ value: 10      │
└────────────────┘

Kemudian:

box = "Hello";

Boleh.

Kemudian:

box = true;

Boleh.

Kemudian:

box = 20.5;

Boleh.

Jadi:

dynamic
   │
   ├── int
   ├── String
   ├── bool
   ├── double
   └── ...

6. Perbedaan Paling Penting: Static Type Checking

Sekarang masuk ke inti video.

Dart memiliki mekanisme static analysis/type checking.

Secara sederhana, Dart berusaha menemukan kesalahan dari kode sebelum program dijalankan.

Misalnya:

var x = 10;
var y = "Hello";

print(x + y);

Dart melihat:

x → int
y → String

Kemudian:

int + String

tidak sesuai.

Dart bisa mengatakan:

“Ini operasi yang tidak valid.”

Sebelum program dijalankan.

Itulah yang disebut compile-time/static checking dalam konteks pembahasan video.

7. Contoh var dengan Operasi Salah

Perhatikan:

var x = 10;
var y = "Hello";

print(x + y);

Dart mengetahui:

x = int
y = String

Kemudian kita mencoba:

int + String

❌ Tidak valid.

Karena Dart sudah mengetahui tipe kedua variable tersebut.

Secara sederhana:

        x + y
        │   │
        │   └── String
        └────── int
             ↓
       tidak cocok
             ↓
       ERROR terdeteksi
       sebelum runtime

Ini keuntungan besar dari static type checking.

8. Sekarang Gunakan dynamic

Kita ubah:

dynamic x = 10;
dynamic y = "Hello";

print(x + y);

Sekarang Dart tidak melakukan pengecekan tipe dengan cara yang sama seperti pada variable yang tipenya sudah diketahui secara statis.

Akibatnya, kode tersebut bisa lolos dari analisis awal.

Tetapi ketika dijalankan, operasi:

10 + "Hello"

tidak valid.

Akhirnya program menghasilkan:

Runtime Exception

Jadi:

var
↓
kesalahan bisa terdeteksi lebih awal
↓
compile/static analysis error

Sedangkan:

dynamic
↓
operasi bisa lolos static analysis
↓
masalah baru diketahui ketika dijalankan
↓
runtime error/exception

9. Compile-Time vs Runtime

Ini wajib kamu pahami karena akan sering muncul saat belajar programming.

Compile-time

Kesalahan ditemukan sebelum program berjalan.

Contoh:

var x = 10;

x = "Hello";

Dart sudah tahu:

x → int

Tetapi kita mencoba memberikan:

String

Maka Dart bisa memperingatkan/error sebelum kode dijalankan.

Runtime

Kesalahan terjadi ketika program sedang berjalan.

Contoh:

dynamic x = 10;

print(x.toUpperCase());

Program dapat melewati static analysis karena x adalah dynamic.

Tetapi saat runtime ternyata:

x = 10

dan int tidak memiliki method:

toUpperCase()

Maka terjadi exception saat program dijalankan.

10. Contoh toUpperCase()

Ini contoh yang sangat bagus dari video.

Kita punya:

var x = 10;

Kemudian:

x.toUpperCase();

toUpperCase() adalah method yang digunakan untuk String.

Contoh:

String name = "Budi";

print(name.toUpperCase());

Hasil:

BUDI

Tetapi x adalah:

int

Jadi:

var x = 10;

x.toUpperCase();

❌ Tidak valid.

Dart sudah mengetahui bahwa:

x → int

dan int tidak mempunyai method toUpperCase() yang sesuai.

11. Kalau Menggunakan dynamic

Sekarang:

dynamic x = 10;

x.toUpperCase();

Pada tahap static analysis, Dart tidak memperlakukan x seperti variable yang sudah diketahui bertipe int dengan cara yang sama.

Jadi kode tersebut dapat melewati pengecekan statis.

Tetapi ketika program dijalankan:

x
↓
10
↓
int
↓
coba panggil toUpperCase()
↓
❌ method tidak tersedia
↓
Runtime Exception

Ini sangat penting:

dynamic tidak membuat operasi yang salah menjadi benar.

dynamic hanya membuat Dart lebih longgar dalam melakukan pengecekan tipe secara statis.

12. Jadi dynamic Bukan “Tanpa Type”

Ini kesalahpahaman yang sering terjadi.

Jangan berpikir:

“dynamic berarti variable tidak punya tipe.”

Lebih tepat:

dynamic membuat variable dapat diperlakukan secara dinamis dan menunda sebagian pemeriksaan tipe hingga runtime.

Contoh:

dynamic x = 10;

Saat ini object/value yang dipegang x adalah:

10 → int

Kemudian:

x = "Hello";

Sekarang value yang dipegang:

"Hello" → String

Kemudian:

x = true;

Sekarang:

true → bool

13. Perbedaan Assignment var vs dynamic

Ini contoh paling jelas.

var

var x = 10;

x = 20;       // ✅
x = 30;       // ✅

x = "Hello";  // ❌
x = 10.5;     // ❌

Kenapa?

Karena:

x pertama kali → int

Dan tipe x sudah diketahui.

dynamic

dynamic x = 10;

x = 20;       // ✅
x = "Hello";  // ✅
x = 10.5;     // ✅
x = true;     // ✅

Karena x bersifat dynamic.

14. Perhatikan runtimeType

Video juga menggunakan sesuatu seperti:

x.runtimeType

Ini berguna untuk melihat tipe object/value yang sedang dipegang variable saat runtime.

Contoh:

dynamic x = 10;

print(x.runtimeType);

Output:

int

Kemudian:

x = "Hello";

print(x.runtimeType);

Output:

String

Kemudian:

x = 10.5;

print(x.runtimeType);

Output:

double

Jadi:

dynamic x = 10
      ↓
runtimeType → int

x = "Hello"
      ↓
runtimeType → String

x = 10.5
      ↓
runtimeType → double

15. var Juga Bisa Menggunakan runtimeType

Misalnya:

var x = 10;

print(x.runtimeType);

Output:

int

Kemudian:

x = 20;

Tetap:

int

Karena x memang sudah diinfer sebagai int.

Kita bisa membayangkan:

var x = 10
     ↓
x → int
     ↓
20 masih int → ✅
String → ❌
double → ❌

16. Tabel Perbedaan var dan dynamic

Ini tabel yang sebaiknya kamu ingat:

17. Analogi Guru dan Murid

Supaya lebih mudah, bayangkan ada seorang guru.

var

Kamu memberikan sebuah kotak kepada guru:

var box = 10;

Guru melihat:

“Oh, ini kotak integer.”

Kemudian kamu masukkan:

20

Guru berkata:

“Boleh, masih integer.”

Tapi ketika kamu memasukkan:

"Hello"

Guru langsung berkata:

“Tidak boleh. Kotak ini sudah diketahui sebagai integer.”

dynamic

Kamu memberikan kotak:

dynamic box = 10;

Guru berkata:

“Oke, kotak ini dinamis.”

Kamu memasukkan:

20

Boleh.

"Hello"

Boleh.

true

Boleh.

Tetapi suatu saat kamu mencoba melakukan operasi yang tidak cocok:

"Hello" + operasi khusus integer

Barulah masalahnya muncul ketika program berjalan.

18. Kenapa var Lebih Disarankan?

Video mengatakan bahwa dokumentasi Dart merekomendasikan menggunakan var dibanding dynamic jika dynamic tidak benar-benar diperlukan.

Alasannya sederhana:

var mempertahankan manfaat static typing.

Contoh:

var name = "Budi";

Dart tahu:

name → String

Sehingga IDE/compiler bisa membantu kita:

• menemukan kesalahan lebih awal
• memberikan autocomplete yang lebih akurat
• mengetahui method apa yang tersedia
• membantu refactoring
• membuat kode lebih mudah dipahami
• mengurangi error runtime

Misalnya:

var name = "Budi";

name.toUpperCase();

IDE tahu name adalah String, sehingga bisa membantu memberikan autocomplete untuk method String.

19. Mengapa dynamic Tetap Ada?

Kalau dynamic berpotensi membuat error runtime, kenapa Dart menyediakan dynamic?

Karena ada situasi di mana kita memang belum mengetahui tipe data secara pasti pada saat compile-time.

Salah satu contoh yang disebut video adalah JSON.

Misalnya kita mendapatkan data dari server:

{
  "name": "Budi",
  "age": 20
}

Data dari luar program terkadang perlu diproses secara dinamis terlebih dahulu.

Dalam kasus seperti ini, dynamic bisa berguna.

Tetapi dalam aplikasi Flutter yang besar, biasanya kita berusaha mengubah data tersebut menjadi model/class dengan tipe yang jelas sesegera mungkin.

Misalnya konsepnya:

JSON
 ↓
decode
 ↓
data
 ↓
Model/User class
 ↓
User yang typed

Dengan begitu kita mendapatkan kembali manfaat type safety.

20. Jangan Mengartikan “Gunakan var Selalu”

Pernyataan:

“Gunakan var, jangan dynamic.”

terlalu sederhana.

Yang lebih tepat:

Gunakan tipe yang paling tepat dan sejelas mungkin. Gunakan var ketika type inference membuat kode tetap jelas. Gunakan dynamic ketika memang membutuhkan dynamic behavior.

Contoh:

String name = "Budi";

sangat jelas.

var name = "Budi";

juga jelas.

Tetapi:

dynamic name = "Budi";

biasanya tidak diperlukan jika kita sudah tahu bahwa name adalah String.

21. Hubungan dengan Type Annotation

Sebenarnya kita sekarang punya tiga pilihan yang sudah dipelajari:

Explicit type

int age = 20;

Kita mengatakan langsung:

age adalah int.

var

var age = 20;

Kita mengatakan:

Dart, tentukan tipe berdasarkan value.

Hasilnya:

age → int

dynamic

dynamic age = 20;

Kita mengatakan:

Variable ini bersifat dynamic.

Dan nantinya dapat menampung value dengan tipe berbeda.

22. Diagram Besar

Kalau diringkas:

                  VARIABLE
                     │
          ┌──────────┴──────────┐
          │                     │
         var                 dynamic
          │                     │
          ▼                     ▼
   Type inference          Dynamic type
          │                     │
          ▼                     ▼
   var x = 10             dynamic x = 10
          │                     │
          ▼                     ▼
      x → int             x → dynamic
          │                     │
          │                     ├── x = 20
          │                     ├── x = "Hello"
          │                     ├── x = true
          │                     └── x = 10.5
          │
          ├── x = 20     ✅
          │
          ├── x = "Hi"   ❌
          │
          └── x = true   ❌

23. Contoh yang Sangat Penting

Perhatikan dua program berikut.

Program A — var

void main() {
  var x = 10;

  print(x + 20);
}

Dart tahu:

x → int
20 → int

Maka:

10 + 20
↓
30

✅ Aman.

Program B — dynamic

void main() {
  dynamic x = 10;

  print(x + 20);
}

Ini juga bisa berjalan:

10 + 20
↓
30

Tetapi sekarang static analyzer memiliki lebih sedikit informasi tentang x.

Kemudian kalau:

dynamic x = "Hello";

print(x + 20);

masalah baru muncul ketika operasi tersebut dijalankan.

24. Kesalahan Konsep yang Harus Dihindari

❌ “var berarti tipe datanya tidak diketahui.”

Tidak.

var justru menggunakan type inference.

var x = 10;

Dart mengetahui:

x → int

❌ “dynamic berarti tidak ada tipe.”

Tidak tepat.

dynamic adalah type khusus yang membuat pemeriksaan tipe lebih dinamis.

❌ “dynamic lebih bagus karena fleksibel.”

Belum tentu.

Fleksibilitas memiliki trade-off:

lebih fleksibel
      ↓
lebih sedikit informasi tipe saat compile-time
      ↓
lebih sedikit perlindungan static typing
      ↓
lebih banyak potensi error runtime

❌ “var dan dynamic sama saja.”

Tidak.

Perbedaan utamanya adalah bagaimana Dart memperlakukan informasi tipe dan melakukan static checking.

25. Inti Video dalam Satu Contoh

Kalau kamu hanya ingin mengingat satu contoh dari video, ingat ini:

var x = 10;

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

Karena:

var x = 10
    ↓
type inference
    ↓
x → int

Sedangkan:

dynamic x = 10;

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

Karena:

dynamic x
    ↓
type dapat berubah

Dan ketika melakukan operasi yang tidak cocok:

dynamic x = 10;

x.toUpperCase();

bisa lolos dari static checking tetapi kemudian menghasilkan runtime error/exception, karena nilai sebenarnya adalah int.

26. Ringkasan Super Singkat

Pegang kalimat ini:

var = Dart menentukan tipe untuk kita, tetapi tipe hasilnya tetap terikat pada variable tersebut.

dynamic = Dart memberi kita fleksibilitas tipe dan mengurangi manfaat static type checking.

Contoh:

var x = 10;

berarti secara konsep:

x → int

Sedangkan:

dynamic x = 10;

berarti:

x → dynamic
value saat ini → int

dan nanti bisa:

x = "Hello";

sehingga:

value saat ini → String

🧠 Cara mengingatnya

VAR
"Type-nya ditebak Dart"
        ↓
lebih aman
lebih banyak static checking
tipe variable tetap setelah inference

DYNAMIC
"Type-nya dibuat dinamis"
        ↓
lebih fleksibel
lebih sedikit static checking
lebih berpotensi error saat runtime

Rekomendasi praktis untuk belajar Flutter: biasakan menggunakan type annotation atau var terlebih dahulu. Jangan menggunakan dynamic hanya karena ingin menghindari error tipe. dynamic sebaiknya dipahami sebagai alat khusus ketika data atau API yang kita hadapi memang membutuhkan perilaku dinamis.