Materi ini membahas function parameter di Dart secara lebih mendalam. Kalau materi sebelumnya membahas jenis function, sekarang fokusnya adalah bagaimana mengirim data ke dalam function.

Ada satu koreksi kecil dari caption: “DOT” yang terdengar di video maksudnya adalah Dart, dan istilah “Edge” maksudnya age.

1. Apa itu parameter?

Kita mulai dari konsep paling sederhana.

Misalnya kita punya function:

void sayHello() {
  print("Hello");
}

Function tersebut tidak membutuhkan data dari luar.

Tapi bagaimana kalau kita ingin mengatakan:

“Hello Budi”

“Hello Andi”

“Hello Siti”

Kita bisa membuat function menerima nama sebagai input.

void sayHello(String name) {
  print("Hello $name");
}

Sekarang name disebut parameter.

Kita bisa memanggilnya:

sayHello("Budi");

atau:

sayHello("Andi");

atau:

sayHello("Siti");

Jadi gambaran sederhananya:

sayHello("Budi")
       ↓
   "Budi" masuk
       ↓
      name
       ↓
print("Hello $name")
       ↓
Hello Budi

Ingat:

Parameter = tempat untuk menerima data dari luar function.

2. Parameter dan argument itu berbeda

Ini penting supaya tidak bingung.

Perhatikan:

void sayHello(String name) {
  print("Hello $name");
}

name disebut parameter.

Ketika kita memanggil:

sayHello("Budi");

"Budi" disebut argument.

Jadi:

FUNCTION DEFINITION

void sayHello(String name)
                   ↑
                parameter


FUNCTION CALL

sayHello("Budi")
         ↑
       argument

Cara mudah mengingat:

• Parameter → variabel yang disiapkan function untuk menerima data.
• Argument → nilai yang kita kirim ketika memanggil function.

3. Tiga jenis parameter dalam materi ini

Menurut video, ada tiga jenis parameter yang akan kita pelajari:

1. Positional parameter
2. Named parameter
3. Optional parameter

Perbedaan paling pentingnya adalah bagaimana kita memberikan argument ketika memanggil function.

4. Positional Parameter

Kita mulai dari yang paling sederhana.

Contoh:

void myFunction(String name, int age) {
  print(name);
  print(age);
}

Function ini mempunyai dua parameter:

String name
int age

Urutannya:

parameter pertama → name
parameter kedua   → age

Karena ini positional parameter, posisi sangat penting.

5. Cara memanggil positional parameter

Kita harus memberikan nilai sesuai urutan:

myFunction("Budi", 23);

Maka:

name = "Budi"
age  = 23

Karena:

"Budi" → parameter pertama → String name
23     → parameter kedua   → int age

Hasil:

Budi
23

6. Kenapa disebut “positional”?

Karena Dart melihat posisinya.

Misalnya:

void myFunction(String name, int age) {
  print(name);
  print(age);
}

Kita memanggil:

myFunction("Budi", 23);

Posisinya:

Posisi 1 → "Budi" → String
Posisi 2 → 23     → int

Sesuai.

7. Kalau posisinya dibalik?

Misalnya:

myFunction(23, "Budi");

Ini salah.

Kenapa?

Karena Dart membaca:

23
↓
parameter pertama
↓
String name

Padahal 23 adalah int, bukan String.

Kemudian:

"Budi"
↓
parameter kedua
↓
int age

Padahal "Budi" adalah String, bukan int.

Maka akan terjadi error.

Jadi untuk positional parameter:

Urutan argument harus sesuai dengan urutan parameter.

8. Contoh lain positional parameter

Misalnya function untuk menghitung luas persegi panjang:

int area(int length, int width) {
  return length * width;
}

Panggil:

int result = area(10, 5);

Maka:

length = 10
width  = 5

Hasil:

10 × 5 = 50

Kalau kita menulis:

area(5, 10);

secara tipe data tetap valid:

length = 5
width  = 10

Tetapi nilainya bertukar.

Inilah pentingnya posisi pada positional parameter.

9. Named Parameter

Sekarang kita masuk ke jenis kedua.

Named parameter berbeda dengan positional parameter.

Contoh:

void myFunction({
  required String name,
  required int age,
}) {
  print(name);
  print(age);
}

Perhatikan ada:

{
  ...
}

Kurung kurawal di parameter menunjukkan bahwa kita menggunakan named parameters.

10. Kenapa disebut named parameter?

Karena ketika memanggil function, kita memberikan nama parameternya.

Misalnya:

myFunction(
  name: "Budi",
  age: 23,
);

Di sini kita tidak hanya memberikan:

"Budi"
23

tetapi kita mengatakan secara jelas:

name → "Budi"
age  → 23

11. Posisi tidak lagi menjadi masalah

Ini adalah perbedaan besar antara positional dan named parameter.

Function:

void myFunction({
  required String name,
  required int age,
}) {
  print(name);
  print(age);
}

Kita bisa:

myFunction(
  name: "Budi",
  age: 23,
);

Atau:

myFunction(
  age: 23,
  name: "Budi",
);

Keduanya valid.

Kenapa?

Karena Dart melihat nama parameter, bukan posisi.

12. Perbandingan positional vs named

Positional

void person(String name, int age) {
  print(name);
  print(age);
}

Pemanggilan:

person("Budi", 23);

Dart membaca:

posisi 1 → name
posisi 2 → age

Named

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

Pemanggilan:

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

Dart membaca:

age  → 23
name → "Budi"

Tidak peduli urutannya.

13. Apa fungsi required?

Nah, ini bagian yang cukup penting.

Dalam video ada error seperti:

parameter cannot have a value of null…

Kemudian video menambahkan:

required

Contoh:

void person({
  required String name,
}) {
  print(name);
}

required berarti:

Parameter tersebut wajib diberikan ketika function dipanggil.

Jadi:

person(name: "Budi");

✅ benar.

Tetapi:

person();

❌ salah, karena name diwajibkan.

14. Kenapa required diperlukan?

Perhatikan:

void person({
  String name,
}) {
  print(name);
}

Dalam null safety Dart, parameter seperti ini pada dasarnya bisa saja tidak diberikan sehingga berpotensi menjadi null.

Sedangkan kita mengatakan:

String name

yang berarti name tidak boleh null.

Ada ketidaksesuaian.

Dengan:

required String name

kita mengatakan kepada Dart:

“Jangan khawatir, saya memastikan name selalu diberikan.”

Contoh:

void person({
  required String name,
}) {
  print(name);
}

Sekarang saat dipanggil:

person(name: "Budi");

Dart tahu name memang tersedia.

15. Named parameter bisa memiliki banyak parameter

Misalnya:

void registerUser({
  required String name,
  required int age,
  required String city,
}) {
  print(name);
  print(age);
  print(city);
}

Kita bisa memanggil:

registerUser(
  name: "Budi",
  age: 23,
  city: "Madiun",
);

Atau:

registerUser(
  city: "Madiun",
  age: 23,
  name: "Budi",
);

Tetap valid karena yang digunakan adalah nama parameter.

16. Optional Parameter

Sekarang kita masuk ke bagian ketiga.

Optional parameter berarti parameter yang tidak wajib diberikan ketika function dipanggil.

Ada beberapa cara untuk membuat parameter menjadi optional.

Dalam materi ini ada dua cara utama yang ditunjukkan:

1. Memberikan default value
2. Menggunakan ? sehingga parameter nullable

Kita bahas satu per satu.

17. Optional dengan default value

Misalnya:

void sayHello({
  String name = "Budi",
}) {
  print(name);
}

Perhatikan:

String name = "Budi"

Artinya jika kita tidak memberikan name, Dart akan menggunakan:

Budi

sebagai nilai default.

Tidak memberikan parameter

Kita bisa:

sayHello();

Output:

Budi

Karena:

name tidak diberikan
        ↓
gunakan default value
        ↓
name = "Budi"

Memberikan parameter

Kita juga bisa:

sayHello(name: "Ali");

Output:

Ali

Karena kita memberikan nilai baru.

name = "Ali"

Nilai "Ali" akan menggantikan default "Budi".

18. Gambaran default value

Misalnya:

void greet({
  String name = "Guest",
}) {
  print("Hello $name");
}

Tanpa argument:

greet();

Hasil:

Hello Guest

Dengan argument:

greet(name: "Budi");

Hasil:

Hello Budi

Jadi:

                     name diberikan?
                         │
                    ┌────┴────┐
                   Tidak      Ya
                    ↓          ↓
             gunakan default  gunakan
                 "Guest"       nilai

19. Optional dengan ?

Cara kedua adalah menggunakan tanda:

?

Misalnya:

void sayHello({
  String? name,
}) {
  print(name);
}

Perhatikan:

String?

Artinya name nullable.

Dengan kata lain:

name boleh memiliki nilai String, tetapi boleh juga null.

20. Apa itu null?

null secara sederhana berarti:

Tidak ada nilai.

Misalnya:

String? name;

name belum memiliki nilai.

Nilainya:

null

Jadi:

void sayHello({
  String? name,
}) {
  print(name);
}

Kita bisa memanggil:

sayHello();

Outputnya:

null

Karena kita tidak memberikan nilai name.

21. Kalau kita memberikan nilai?

Misalnya:

sayHello(name: "Ali");

Sekarang:

name = "Ali"

Maka output:

Ali

Jadi:

sayHello()
     ↓
name = null


sayHello(name: "Ali")
     ↓
name = "Ali"

22. Bedakan default value dan nullable

Ini sangat penting.

Menggunakan default value

void hello({
  String name = "Budi",
}) {
  print(name);
}

Kalau tidak dikirim:

hello();

maka:

name = "Budi"

Menggunakan ?

void hello({
  String? name,
}) {
  print(name);
}

Kalau tidak dikirim:

hello();

maka:

name = null

Jadi:

23. Bisa membuat dua parameter sekaligus optional

Misalnya:

void person({
  String? name,
  int? age,
}) {
  print(name);
  print(age);
}

Kita bisa memanggil tanpa argument:

person();

Output:

null
null

Karena keduanya nullable.

24. Bisa juga memberikan default value untuk keduanya

Contoh:

void person({
  String name = "Budi",
  int age = 23,
}) {
  print(name);
  print(age);
}

Kemudian:

person();

Output:

Budi
23

Karena Dart menggunakan nilai default.

25. Bagaimana kalau hanya ingin mengubah satu?

Misalnya:

void person({
  String name = "Budi",
  int age = 23,
}) {
  print(name);
  print(age);
}

Kita bisa:

person(age: 30);

Hasil:

Budi
30

name tidak diberikan → gunakan "Budi".

age diberikan → gunakan 30.

26. Perhatikan perbedaan tiga bentuk ini

Ini sangat penting untuk dipahami.

A. Required

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

Harus diberikan:

person(name: "Budi"); // ✅
person();             // ❌

B. Optional dengan default value

void person({
  String name = "Budi",
}) {}

Tidak wajib:

person();             // ✅ name = "Budi"
person(name: "Ali");  // ✅ name = "Ali"

C. Optional nullable

void person({
  String? name,
}) {}

Tidak wajib:

person();             // ✅ name = null
person(name: "Ali");  // ✅ name = "Ali"

27. Hubungkan dengan materi sebelumnya

Di materi sebelumnya kita belajar:

int add(int a, int b) {
  return a + b;
}

Itu adalah positional parameter.

Karena pemanggilannya:

add(10, 20);

berdasarkan posisi.

Sekarang kita bisa membuat versi named:

int add({
  required int a,
  required int b,
}) {
  return a + b;
}

Pemanggilannya:

add(a: 10, b: 20);

Bahkan:

add(b: 20, a: 10);

tetap bisa.

28. Contoh yang sangat mudah untuk membandingkan semuanya

Positional

void person(String name, int age) {
  print("$name is $age years old");
}

Panggil:

person("Budi", 23);

Named required

void person({
  required String name,
  required int age,
}) {
  print("$name is $age years old");
}

Panggil:

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

Urutan boleh:

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

Named optional dengan default

void person({
  String name = "Guest",
  int age = 0,
}) {
  print("$name is $age years old");
}

Bisa:

person();

Hasil:

Guest is 0 years old

Atau:

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

Hasil:

Budi is 23 years old

29. Satu hal penting: {} dan []

Di Dart nanti kamu akan sering melihat:

{}

dan:

[]

untuk parameter.

Secara umum:

{}

Digunakan untuk named parameters.

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

Pemanggilan:

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

[]

Digunakan untuk optional positional parameters.

Contohnya:

void person(String name, [int? age]) {
  print(name);
  print(age);
}

Ini juga termasuk konsep optional parameter, tetapi jenis optional positional.

Video yang kamu kirim lebih fokus pada named optional melalui default value dan ?, jadi bagian [] kemungkinan akan lebih jelas kalau dibahas saat kursus masuk ke topik tersebut.

30. Kesalahan yang sering dilakukan pemula

Kesalahan 1 — Salah urutan positional

void person(String name, int age) {}

person(23, "Budi"); // ❌

Karena posisi pertama harus String.

Kesalahan 2 — Lupa required

Misalnya:

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

Kemudian:

person(); // ❌

Karena name wajib diberikan.

Kesalahan 3 — Mengira named parameter harus sesuai urutan

Tidak perlu.

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

Tetap benar.

Kesalahan 4 — Mengira ? berarti default value

Tidak.

String? name

berarti:

name boleh null.

Sedangkan:

String name = "Budi"

berarti:

Jika tidak diberikan, gunakan "Budi".

31. Ringkasan visual

Pahami diagram ini:

PARAMETER
│
├── Positional
│     │
│     └── berdasarkan posisi
│         person("Budi", 23)
│
├── Named
│     │
│     └── berdasarkan nama
│         person(name: "Budi", age: 23)
│
└── Optional
      │
      ├── Default value
      │     └── String name = "Budi"
      │
      └── Nullable
            └── String? name

Dan khusus named parameter:

required
   ↓
wajib diberikan

default value
   ↓
tidak wajib
kalau tidak diberikan → nilai default

?
   ↓
tidak wajib
kalau tidak diberikan → null

32. Contoh lengkap

Coba perhatikan program berikut:

// Positional parameter
void positional(String name, int age) {
  print("$name - $age");
}

// Named parameter
void named({
  required String name,
  required int age,
}) {
  print("$name - $age");
}

// Optional dengan default value
void optionalDefault({
  String name = "Guest",
  int age = 0,
}) {
  print("$name - $age");
}

// Optional nullable
void optionalNullable({
  String? name,
  int? age,
}) {
  print("$name - $age");
}

void main() {
  positional("Budi", 23);

  named(
    name: "Andi",
    age: 25,
  );

  optionalDefault();

  optionalDefault(
    name: "Siti",
    age: 20,
  );

  optionalNullable();

  optionalNullable(
    name: "Doni",
    age: 30,
  );
}

Output kira-kira:

Budi - 23
Andi - 25
Guest - 0
Siti - 20
null - null
Doni - 30

33. Cara paling mudah mengingat materi ini

Jangan hafalkan semua istilah sekaligus. Ingat 3 pertanyaan:

Pertanyaan 1: Apakah parameter berdasarkan posisi?

Kalau iya:

person("Budi", 23);

→ positional parameter

Pertanyaan 2: Apakah parameter dipanggil menggunakan nama?

Kalau iya:

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

→ named parameter

Pertanyaan 3: Apakah parameter wajib atau boleh tidak diberikan?

Kalau:

required String name

→ wajib.

Kalau:

String name = "Budi"

→ tidak wajib, ada nilai default.

Kalau:

String? name

→ tidak wajib, bisa null.

Inti materi hari ini

Kalau dibuat super sederhana:

Parameter adalah pintu masuk data ke function.

Ada tiga konsep utama:

1. POSITIONAL
   "Budi", 23
   ↓
   urutan penting


2. NAMED
   name: "Budi", age: 23
   ↓
   nama parameter penting
   urutan tidak penting


3. OPTIONAL
   ↓
   tidak wajib diberikan

   default:
   String name = "Budi"

   atau nullable:
   String? name

Dan satu kata yang harus benar-benar kamu ingat:

required

artinya:

“Parameter ini wajib diberikan.”

Kalau kamu sudah menguasai positional → named → required → default value → nullable (?), bagian parameter Dart ini sudah punya fondasi yang sangat kuat.