Video ini membahas positional parameters pada function di Dart. Konsep ini penting karena nantinya kamu akan sering menemukan function yang menerima beberapa parameter, baik di Dart maupun Flutter.

Saya akan jelaskan dari dasar, lalu kita bahas optional positional parameter, null safety, default value, dan aturan penting bahwa parameter opsional harus berada di bagian belakang.

1. Apa itu positional parameter?

Sederhananya:

Positional parameter adalah parameter yang nilainya ditentukan berdasarkan posisi/urutan.

Contoh:

void test(int a, int b, int c) {
  print("a = $a");
  print("b = $b");
  print("c = $c");
}

Function test() mempunyai 3 parameter:

a → parameter pertama
b → parameter kedua
c → parameter ketiga

Ketika kita memanggil:

test(10, 20, 30);

Dart akan memasangkan berdasarkan urutan:

10 → a
20 → b
30 → c

Jadi hasilnya:

a = 10
b = 20
c = 30

2. Kenapa disebut “positional”?

Karena Dart tidak melihat nama parameter ketika kita memanggil function tersebut.

Dart melihat posisinya.

Misalnya:

void test(int a, int b, int c) {
  print("a = $a");
  print("b = $b");
  print("c = $c");
}

Kemudian:

test(10, 20, 30);

Maka:

posisi 1 → 10 → a
posisi 2 → 20 → b
posisi 3 → 30 → c

Kamu tidak bisa mengatakan:

10 → c
20 → a
30 → b

dengan positional parameter biasa.

Urutannya harus:

a → b → c

3. Contoh sederhana

Misalnya kita punya:

void biodata(String nama, int umur, String kota) {
  print("Nama: $nama");
  print("Umur: $umur");
  print("Kota: $kota");
}

Kita panggil:

biodata("Budi", 20, "Madiun");

Maka:

"Budi"    → nama
20        → umur
"Madiun"  → kota

Output:

Nama: Budi
Umur: 20
Kota: Madiun

Kalau kita menulis:

biodata(20, "Budi", "Madiun");

akan error karena:

20      → nama
"Budi"  → umur

Tipe datanya tidak cocok.

Jadi positional parameter mempunyai dua hal penting:

1. Urutan penting
2. Tipe data juga harus sesuai

4. Apakah positional parameter wajib diisi?

Secara default, iya.

Perhatikan:

void test(int a, int b, int c) {
  print(a);
  print(b);
  print(c);
}

Kalau kita memanggil:

test(10, 20, 30);

Tidak ada masalah.

Tetapi kalau:

test(10, 20);

akan error.

Kenapa?

Karena function membutuhkan:

a → sudah ada 10
b → sudah ada 20
c → belum ada nilai

Sedangkan c adalah required positional parameter.

Artinya:

Parameter positional biasa harus diberikan ketika function dipanggil.

5. Bagaimana membuat positional parameter menjadi optional?

Nah, ini bagian penting dari video.

Gunakan tanda:

[]

Contoh:

void test(int a, int b, [int? c]) {
  print("a = $a");
  print("b = $b");
  print("c = $c");
}

Sekarang c menjadi:

optional positional parameter

Kenapa?

Karena c diletakkan di dalam:

[int? c]

Tanda [] menunjukkan bahwa parameter tersebut opsional secara positional.

6. Kenapa c menggunakan int??

Ini berkaitan dengan null safety.

Kita sudah tahu bahwa:

int

berarti tidak boleh menyimpan null.

Sedangkan:

int?

berarti boleh menyimpan null.

Misalnya:

void test(int a, int b, [int? c]) {
  print("a = $a");
  print("b = $b");
  print("c = $c");
}

Kita panggil:

test(10, 20);

Apa yang terjadi?

Kita tidak memberikan nilai untuk c.

Karena c optional, Dart tidak error.

Nilai c menjadi:

null

Sehingga:

a = 10
b = 20
c = null

7. Perhatikan perbedaan ini

Required positional

void test(int a, int b, int c) {}

Pemanggilan:

test(10, 20, 30);

Harus lengkap.

Optional positional

void test(int a, int b, [int? c]) {}

Pemanggilan:

test(10, 20, 30);

boleh.

Tetapi:

test(10, 20);

juga boleh.

Kalau tidak diberikan:

c = null

8. Contoh dengan dua kali pemanggilan

Misalnya:

void test(int a, int b, [int? c]) {
  print("a = $a");
  print("b = $b");
  print("c = $c");
}

void main() {
  test(10, 20, 30);

  test(55, 60);
}

Pemanggilan pertama:

test(10, 20, 30);

Karena positional:

10 → a
20 → b
30 → c

Output:

a = 10
b = 20
c = 30

Pemanggilan kedua:

test(55, 60);

Maka:

55 → a
60 → b
c  → tidak diberikan

Karena c adalah int?, hasilnya:

a = 55
b = 60
c = null

9. Bagaimana kalau kita tidak ingin c menjadi null?

Kita bisa memberikan default value.

Contoh:

void test(int a, int b, [int c = 0]) {
  print("a = $a");
  print("b = $b");
  print("c = $c");
}

Sekarang kita punya:

[int c = 0]

Artinya:

Jika caller tidak memberikan nilai c, gunakan 0.

10. Contoh default value

Kita panggil:

test(10, 20, 30);

Hasil:

a = 10
b = 20
c = 30

Karena kita memberikan nilai 30.

Tetapi kalau:

test(10, 20);

maka:

a = 10
b = 20
c = 0

Karena tidak ada nilai c, sehingga Dart menggunakan:

0

sebagai default value.

11. Jadi optional parameter punya dua kemungkinan

Misalnya:

void test(int a, [int? b]) {}

Jika b tidak diberikan:

b = null

Sedangkan:

void test(int a, [int b = 0]) {}

Jika b tidak diberikan:

b = 0

Jadi:

12. Apa sebenarnya default value?

Default value adalah:

Nilai yang otomatis digunakan ketika caller tidak memberikan nilai untuk optional parameter tersebut.

Contoh:

void greet(String name, [String message = "Hello"]) {
  print("$message, $name");
}

Kalau:

greet("Budi", "Selamat pagi");

hasil:

Selamat pagi, Budi

Tetapi:

greet("Budi");

hasil:

Hello, Budi

Karena message tidak diberikan.

Dart menggunakan:

"Hello"

sebagai default value.

13. Hal penting: default value hanya untuk parameter optional

Ini salah:

void test(int a = 0) {
}

Karena a adalah required positional parameter.

Untuk positional parameter, default value digunakan pada bagian optional:

void test([int a = 0]) {
}

Sekarang a optional.

14. Kenapa tidak boleh begini?

Misalnya kita punya:

void test([int a], int b) {
}

Ini tidak diperbolehkan.

Kenapa?

Karena akan menimbulkan masalah dalam menentukan posisi.

Bayangkan kita memanggil:

test(10);

Pertanyaannya:

10 → a?
atau
10 → b?

Ambigu.

Karena a boleh tidak ada, sementara b wajib ada.

Dart menghindari situasi seperti ini.

15. Aturan penting: optional positional harus di belakang

Ini aturan yang sangat penting:

Optional positional parameters harus berada setelah required positional parameters.

Misalnya:

void test(int a, [int? b, int? c]) {
}

Ini valid.

Strukturnya:

a → required
b → optional
c → optional

16. Kenapa b dan c boleh optional?

Karena keduanya berada di belakang.

Kita bisa memanggil:

test(10, 20, 30);

Hasil:

a = 10
b = 20
c = 30

Atau:

test(10, 20);

Hasil:

a = 10
b = 20
c = null

Atau:

test(10);

Hasil:

a = 10
b = null
c = null

Ini masuk akal karena Dart bisa menentukan posisinya dengan jelas.

17. Kenapa harus dari kanan ke kiri?

Video mengatakan kita harus berpikir:

right to left

Maksudnya bukan kita benar-benar menulis parameter dari kanan ke kiri.

Maksudnya adalah:

Ketika menentukan mana positional parameter yang optional, bagian yang dibuat optional harus dimulai dari parameter paling belakang.

Misalnya:

void test(int a, int b, int c) {}

Kita ingin membuat 1 parameter optional.

Yang bisa dibuat optional adalah:

void test(int a, int b, [int? c]) {}

Bukan:

void test([int? a], int b, int c) {}

18. Kalau ingin 2 parameter optional?

Misalnya:

void test(int a, int b, int c) {}

Kita ingin b dan c optional.

Maka:

void test(int a, [int? b, int? c]) {}

Jadi:

a → wajib
b → optional
c → optional

19. Tidak boleh membuat a dan b optional saja

Kita tidak boleh membuat:

void test([int? a, int? b], int c) {}

Karena c adalah required positional parameter yang muncul setelah optional positional parameter.

Ini tidak diperbolehkan.

Kalau memang kita ingin:

a optional
b optional
c wajib

maka positional parameter bukan desain yang tepat.

Biasanya kita bisa menggunakan named parameters, misalnya:

void test({
  int? a,
  int? b,
  required int c,
}) {
}

Lalu pemanggilannya:

test(c: 30);

atau:

test(a: 10, c: 30);

Ini salah satu alasan kenapa Dart menyediakan positional parameters dan named parameters.

20. Positional vs named parameter

Ini perbedaan yang sangat penting untuk kamu pahami sebelum lanjut belajar function lebih jauh.

Positional

void person(String name, int age) {
}

Pemanggilan:

person("Budi", 20);

Urutan menentukan arti:

"Budi" → name
20      → age

Named

void person({
  required String name,
  required int age,
}) {
}

Pemanggilan:

person(
  name: "Budi",
  age: 20,
);

Di sini kita menggunakan nama parameter.

Bahkan urutannya bisa ditukar:

person(
  age: 20,
  name: "Budi",
);

Tetap benar.

21. Analogi sederhana

Bayangkan kamu punya mesin:

┌─────────────────────┐
│       FUNCTION      │
│                     │
│ input 1 → A         │
│ input 2 → B         │
│ input 3 → C         │
└─────────────────────┘

Dengan positional parameter:

test(10, 20, 30);

Dart mengatakan:

Input pertama  → A
Input kedua    → B
Input ketiga   → C

Jadi seperti kursi bioskop berdasarkan nomor kursi.

Kursi 1 → A
Kursi 2 → B
Kursi 3 → C

Kamu tidak bisa memberikan penumpang pertama langsung ke kursi 3 sambil melewati aturan posisi.

22. Bedakan parameter dan argument

Ini juga penting.

Ketika kita menulis:

void test(int a, int b) {}

a dan b disebut:

parameter

Sedangkan ketika kita memanggil:

test(10, 20);

10 dan 20 disebut:

argument

Jadi:

void test(int a, int b)
             ↑     ↑
          parameter

dan:

test(10, 20);
     ↑   ↑
   argument

23. Contoh yang lebih realistis

Misalnya kita membuat function untuk menghitung total harga:

void calculateTotal(
  int price,
  int quantity, [
  int discount = 0,
]) {
  int total = (price * quantity) - discount;

  print("Total: $total");
}

Kita bisa memanggil:

calculateTotal(10000, 3, 5000);

Perhitungannya:

price    = 10000
quantity = 3
discount = 5000

total = (10000 × 3) - 5000
      = 30000 - 5000
      = 25000

Output:

Total: 25000

Kalau tidak memberikan discount:

calculateTotal(10000, 3);

maka:

price    = 10000
quantity = 3
discount = 0

Output:

Total: 30000

Ini contoh penggunaan optional positional parameter yang cukup masuk akal.

24. Pola yang perlu kamu hafalkan

Semua wajib

void test(int a, int b, int c) {}

Pemanggilan:

test(10, 20, 30);

Hanya c optional

void test(int a, int b, [int? c]) {}

Bisa:

test(10, 20);

atau:

test(10, 20, 30);

c optional dengan default value

void test(int a, int b, [int c = 0]) {}

Bisa:

test(10, 20);

dan otomatis:

c = 0

b dan c optional

void test(int a, [int? b, int? c]) {}

Bisa:

test(10);

atau:

test(10, 20);

atau:

test(10, 20, 30);

25. Kesalahan yang sering dilakukan pemula

Kesalahan 1 — Mengira [] adalah List

Dalam konteks parameter:

void test(int a, [int? b]) {}

[] bukan berarti List.

Di sini [] adalah syntax untuk optional positional parameters.

Kesalahan 2 — Mengira optional berarti otomatis punya default value

Tidak selalu.

void test([int? x]) {}

Kalau tidak diberikan:

x = null

Sedangkan:

void test([int x = 0]) {}

Kalau tidak diberikan:

x = 0

Jadi:

optional ≠ selalu punya default value

Kesalahan 3 — Membuat parameter tengah optional

Tidak boleh:

void test([int? a], int b) {}

Optional positional harus berada di belakang.

26. Catatan tentang null safety

Bagian video yang mengatakan:

kalau optional parameter tidak diberi nilai, maka nilainya null

perlu sedikit diperhalus.

Benar jika parameter optional tersebut nullable dan tidak mempunyai default value.

Contoh:

void test([int? c]) {}

Tidak memberikan c:

c = null

Tetapi kalau:

void test([int c = 0]) {}

tidak memberikan c:

c = 0

Jadi bukan semua optional parameter otomatis null.

27. Bagaimana cara mengingat semuanya?

Gunakan pola sederhana ini:

()       → tidak ada parameter
(a)      → parameter wajib
(a, b)   → semua wajib

(a, [b]) → a wajib, b optional

(a, [b, c])
         → a wajib, b dan c optional

Dan aturan emasnya:

Required positional → duluan. Optional positional → belakangan.

28. Hubungannya dengan Flutter

Konsep ini akan sering kamu temui ketika menggunakan Flutter.

Misalnya kamu membuat function:

void showUser(String name, [String? role]) {
  print("Name: $name");
  print("Role: $role");
}

Kamu bisa:

showUser("Budi");

atau:

showUser("Budi", "Admin");

Namun dalam Flutter/Dart modern, kamu juga akan sangat sering melihat named parameters, contohnya:

Text(
  "Hello",
  textAlign: TextAlign.center,
);

atau:

Container(
  width: 100,
  height: 100,
);

Ini menggunakan konsep parameter bernama, bukan sekadar positional parameter.

Jadi setelah memahami positional parameters, materi berikutnya yang sangat penting adalah named parameters, karena keduanya sering dipakai bersamaan ketika membuat aplikasi Flutter.

Ringkasan super singkat

Inti paling penting:

void test(int a, int b, [int? c]) {}

artinya:

a → wajib
b → wajib
c → opsional

Sedangkan:

void test(int a, [int? b, int? c]) {}

artinya:

a → wajib
b → opsional
c → opsional

Dan kalau:

void test(int a, int b, [int c = 0]) {}

artinya:

a → wajib
b → wajib
c → opsional
c default → 0

Kalimat yang paling penting untuk diingat:

Positional parameter ditentukan berdasarkan urutan, dan optional positional parameter harus berada di bagian paling belakang.