Materi kali ini membahas fat arrow notation atau arrow function di Dart. Ini sebenarnya lanjutan yang sangat dekat dengan materi sebelumnya tentang anonymous function.

Kalau sebelumnya kita belajar:

(int n) {
  return n * n * n;
}

sekarang kita akan belajar bagaimana menyingkat penulisan function tersebut menjadi:

(int n) => n * n * n

Konsepnya sederhana, tetapi ada beberapa aturan penting yang perlu benar-benar dipahami.

1. Apa itu Fat Arrow Notation?

Fat arrow notation adalah cara singkat untuk menulis function yang hanya memiliki satu expression.

Bentuk panjang:

int cube(int n) {
  return n * n * n;
}

Bisa ditulis menjadi:

int cube(int n) => n * n * n;

Keduanya memiliki tujuan yang sama:

print(cube(5));

Output:

125

Jadi secara sederhana:

Fat arrow notation = bentuk singkat dari function yang body-nya hanya terdiri dari satu expression.

2. Kenapa Disebut “Fat Arrow”?

Perhatikan simbol ini:

=>

Bentuknya terdiri dari:

= + >

Karena bentuk panahnya terlihat lebih tebal dibanding panah biasa, disebut:

fat arrow

Simbol ini adalah bagian dari syntax Dart.

Contoh:

int cube(int n) => n * n * n;

Bisa dibaca:

“cube menerima n, lalu menghasilkan n * n * n.”

3. Bandingkan Function Biasa dengan Fat Arrow

Misalnya kita mempunyai function:

int cube(int n) {
  return n * n * n;
}

Mari kita lihat bagian-bagiannya:

int       → return type
cube      → nama function
(int n)   → parameter
{ }       → body
return    → mengembalikan hasil

Dengan fat arrow:

int cube(int n) => n * n * n;

Menjadi:

int       → return type
cube      → nama function
(int n)   → parameter
=>        → fat arrow
n*n*n     → expression

Kita menghilangkan:

{
  return
}

dan menggantinya dengan:

=>

4. Bentuk Panjang dan Bentuk Pendek

Ini adalah pola yang paling penting untuk diingat.

Bentuk biasa

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

Fat arrow

int add(int a, int b) => a + b;

Bentuk biasa

String greet(String name) {
  return "Hello $name";
}

Fat arrow

String greet(String name) => "Hello $name";

Bentuk biasa

bool isEven(int number) {
  return number % 2 == 0;
}

Fat arrow

bool isEven(int number) => number % 2 == 0;

Ketiganya menggunakan prinsip yang sama.

5. Apa Itu “Expression”?

Ini bagian yang sangat penting.

Transcript mengatakan:

function hanya boleh mempunyai satu statement/expression.

Untuk pemahaman awal, anggap saja expression adalah sesuatu yang menghasilkan sebuah nilai atau bisa dievaluasi.

Contoh:

a + b

adalah expression.

n * n * n

adalah expression.

number % 2 == 0

juga expression.

"Hello $name"

juga expression.

Karena semuanya dapat menghasilkan suatu nilai.

Contohnya:

n * n * n

kalau:

n = 5

maka:

5 * 5 * 5

menghasilkan:

125

6. => Secara Otomatis Berarti return

Ini adalah salah satu hal paling penting.

Ketika kamu menulis:

int cube(int n) => n * n * n;

Dart memperlakukannya seperti:

int cube(int n) {
  return n * n * n;
}

Jadi:

=> expression

secara konsep berarti:

{
  return expression;
}

Contoh:

int square(int n) => n * n;

sama dengan:

int square(int n) {
  return n * n;
}

7. Jangan Menulis return Setelah =>

Karena => sudah menunjukkan bahwa expression tersebut menjadi hasil function, kita tidak menulis return lagi.

❌ Salah:

int cube(int n) => return n * n * n;

Yang benar:

int cube(int n) => n * n * n;

Kenapa?

Karena:

=>

sudah memiliki makna:

“Expression setelah saya adalah hasil yang dikembalikan.”

Jadi return tidak diperlukan.

8. Bagaimana Kalau Function-nya void?

Nah, ini menarik.

Function void berarti kita tidak mengembalikan nilai yang digunakan oleh caller.

Contoh biasa:

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

Bisa ditulis:

void sayHello() => print("Hello");

Perhatikan:

void sayHello() => print("Hello");

Tidak ada:

return

Karena kita hanya menjalankan expression:

print("Hello")

9. Contoh void dengan Parameter

Misalnya:

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

Bisa disingkat:

void greet(String name) => print("Hello $name");

Kemudian:

greet("Budi");

Output:

Hello Budi

Jadi fat arrow tidak hanya untuk function yang menghasilkan nilai.

Bisa juga digunakan untuk function void, selama body-nya cukup direpresentasikan oleh satu expression.

10. Kenapa Tidak Boleh Ada Banyak Statement?

Ini adalah aturan utama fat arrow.

Misalnya kamu mempunyai:

int cube(int n) {
  int result = n * n * n;
  print(result);
  return result;
}

Di sini ada beberapa statement:

int result = ...

kemudian:

print(result);

kemudian:

return result;

Tidak bisa diubah menjadi:

int cube(int n) => 
  int result = n * n * n;
  print(result);
  return result;

❌ Ini tidak valid.

Kenapa?

Karena fat arrow hanya menyediakan tempat untuk satu expression:

=> expression;

Bukan untuk kumpulan statement.

11. if dan Loop Tidak Bisa Langsung Dipakai seperti Body Biasa

Transcript memberikan contoh if dan loop.

Misalnya function:

String checkNumber(int n) {
  if (n > 0) {
    return "Positif";
  } else {
    return "Bukan positif";
  }
}

Tidak bisa begitu saja ditulis:

String checkNumber(int n) => if (n > 0) {
  return "Positif";
}

❌ Tidak valid.

Tetapi ada hal penting:

Dart modern mempunyai conditional expression berupa ternary operator.

Jadi kita bisa menulis:

String checkNumber(int n) =>
    n > 0 ? "Positif" : "Bukan positif";

Ini valid karena:

n > 0 ? "Positif" : "Bukan positif"

adalah satu expression.

12. Jadi if Tidak Selalu Berarti Tidak Bisa?

Kita harus membedakan:

if statement

if (condition) {
  ...
}

Ini statement.

Tidak bisa langsung menjadi body fat arrow.

Ternary expression

condition ? value1 : value2

Ini expression.

Bisa digunakan dengan fat arrow.

Contoh:

String status(int age) =>
    age >= 18 ? "Dewasa" : "Belum dewasa";

13. Contoh Function dengan Ternary

Bentuk biasa:

String getStatus(int age) {
  if (age >= 18) {
    return "Dewasa";
  } else {
    return "Anak-anak";
  }
}

Fat arrow:

String getStatus(int age) =>
    age >= 18 ? "Dewasa" : "Anak-anak";

Keduanya menghasilkan hasil yang sama.

14. Bagaimana dengan Loop?

Misalnya:

void printNumbers() {
  for (int i = 1; i <= 5; i++) {
    print(i);
  }
}

Tidak bisa diubah langsung menjadi:

void printNumbers() => for (...) ...

❌ Tidak valid.

Karena for adalah statement, sedangkan fat arrow membutuhkan satu expression.

Kalau membutuhkan beberapa statement, gunakan function biasa:

void printNumbers() {
  for (int i = 1; i <= 5; i++) {
    print(i);
  }
}

15. Fat Arrow Tidak Berarti Harus Satu Baris Secara Fisik

Ini juga penting.

Fat arrow memang sering ditulis satu baris:

int cube(int n) => n * n * n;

Tetapi sebenarnya yang menjadi aturan adalah satu expression, bukan “harus satu baris”.

Misalnya:

int calculateSomething(
  int a,
  int b,
) =>
    a + b;

Masih valid.

Jadi jangan menghafal:

“Fat arrow harus satu baris.”

Lebih tepat:

Fat arrow digunakan ketika function body dapat direpresentasikan dengan satu expression.

16. Return Type Tidak Wajib Ditulis?

Transcript mengatakan return type tidak perlu ditulis.

Ini perlu sedikit diluruskan.

Dart memang memiliki type inference, jadi return type bisa diinfer oleh Dart.

Contohnya:

cube(int n) => n * n * n;

Dart dapat mengetahui bahwa hasilnya adalah int.

Namun untuk pembelajaran dan keterbacaan, kita sering menulis:

int cube(int n) => n * n * n;

Jadi ada dua konsep berbeda:

Explicit return type

int cube(int n) => n * n * n;

Return type diinfer

cube(int n) => n * n * n;

Yang kedua bukan berarti fat arrow tidak boleh memiliki return type.

Return type tetap boleh ditulis.

17. Fat Arrow pada Anonymous Function

Nah, ini menghubungkan materi sebelumnya dengan materi sekarang.

Sebelumnya kita belajar anonymous function:

var cube = (int n) {
  return n * n * n;
};

Bisa disingkat menjadi:

var cube = (int n) => n * n * n;

Jadi:

Anonymous function
+
Fat arrow notation
=
Anonymous arrow function

Contoh:

var cube = (int n) => n * n * n;

print(cube(5));

Output:

125

18. Fat Arrow pada forEach()

Ini sangat sering kamu lihat.

Sebelumnya:

List<String> names = [
  "Andi",
  "Budi",
  "Citra",
];

names.forEach((name) {
  print(name);
});

Karena body anonymous function hanya mempunyai satu expression:

print(name);

kita bisa menyingkatnya:

names.forEach((name) => print(name));

Hasilnya sama:

Andi
Budi
Citra

Ini adalah contoh yang sangat bagus untuk memahami hubungan:

anonymous function
        +
   fat arrow
        ↓
(name) => print(name)

19. Contoh di Flutter

Di Flutter kamu akan sering melihat:

onPressed: () {
  print("Button ditekan");
},

Karena body-nya hanya satu expression:

print("Button ditekan");

bisa ditulis:

onPressed: () => print("Button ditekan"),

Misalnya:

ElevatedButton(
  onPressed: () => print("Button ditekan"),
  child: Text("Klik"),
)

Ini sangat umum dalam kode Flutter.

20. Contoh onTap

Misalnya:

onTap: () {
  print("Container ditekan");
}

Bisa menjadi:

onTap: () => print("Container ditekan");

Keduanya sama-sama menggunakan:

• anonymous function
• arrow notation
• callback

21. Perbedaan => dengan >=

Untuk pemula, hati-hati jangan sampai tertukar.

Fat arrow

=>

Contoh:

int square(int n) => n * n;

Greater than or equal

>=

Contoh:

if (age >= 18) {
  print("Dewasa");
}

Simbolnya mirip karena sama-sama menggunakan > dan =, tetapi fungsinya berbeda.

22. Fat Arrow vs Ternary

Jangan sampai mengira => sama dengan ? :.

Fat arrow

int square(int n) => n * n;

Artinya:

Function ini menghasilkan expression n * n.

Ternary

String status(int age) =>
    age >= 18 ? "Dewasa" : "Anak-anak";

Di sini ada dua syntax berbeda:

=>   → fat arrow function
?:   → ternary expression

Mereka bisa digunakan bersama.

23. Contoh Lebih Banyak

Penjumlahan

int add(int a, int b) => a + b;

Perkalian

int multiply(int a, int b) => a * b;

Kuadrat

int square(int n) => n * n;

Cek genap

bool isEven(int n) => n % 2 == 0;

Cek positif

bool isPositive(int n) => n > 0;

Greeting

String greet(String name) => "Hello $name";

Semua cocok menggunakan fat arrow karena masing-masing hanya mempunyai satu expression.

24. Contoh yang Tidak Cocok

Misalnya:

void process(int number) {
  print("Memproses...");
  int result = number * 2;
  print(result);
}

Ada beberapa statement.

Lebih baik gunakan:

void process(int number) {
  print("Memproses...");
  int result = number * 2;
  print(result);
}

Jangan memaksakan semuanya menjadi fat arrow hanya supaya kode terlihat pendek.

Fat arrow adalah alat untuk membuat kode lebih ringkas, bukan aturan bahwa semua function harus ditulis dengan =>.

25. Analogi Sederhana

Bayangkan function seperti mesin.

Function biasa:

Input
 ↓
┌─────────────────┐
│ beberapa proses │
│ beberapa proses │
│ beberapa proses │
└─────────────────┘
 ↓
Output

Karena prosesnya banyak, kita gunakan {}:

int calculate(int x) {
  int a = x * 2;
  int b = a + 10;
  return b;
}

Sedangkan kalau prosesnya sangat sederhana:

Input
 ↓
[ satu proses ]
 ↓
Output

kita bisa menggunakan fat arrow:

int calculate(int x) => x * 2 + 10;

26. Cara Menentukan Apakah Bisa Menggunakan =>

Kalau kamu menemukan function:

int something(int x) {
  ...
}

tanyakan:

“Apakah seluruh isi function ini bisa direpresentasikan sebagai satu expression?”

Kalau iya, kemungkinan besar bisa menggunakan =>.

Misalnya:

int square(int x) {
  return x * x;
}

Body-nya cuma:

return x * x;

Maka:

int square(int x) => x * x;

Tetapi:

int calculate(int x) {
  int result = x * 2;
  print(result);
  return result;
}

Ada beberapa statement.

Maka gunakan:

int calculate(int x) {
  int result = x * 2;
  print(result);
  return result;
}

27. Hubungannya dengan Materi Sebelumnya

Sekarang coba hubungkan tiga konsep yang sudah kamu pelajari.

Function biasa

int cube(int n) {
  return n * n * n;
}

Anonymous function

(int n) {
  return n * n * n;
}

Anonymous + fat arrow

(int n) => n * n * n

Dan jika disimpan ke variable:

var cube = (int n) => n * n * n;

Jadi fat arrow bukan jenis function yang benar-benar terpisah.

Lebih tepatnya, => adalah syntax singkat untuk menulis function dengan satu expression.

28. Hal yang Sering Membingungkan

Ada tiga istilah yang perlu kamu pisahkan:

Anonymous function

Function tanpa nama:

(int x) {
  return x * 2;
}

Arrow function

Function yang menggunakan:

=>

Contoh:

(int x) => x * 2

Callback

Function yang diberikan kepada function/API lain.

Contoh:

numbers.forEach((number) => print(number));

Di sini:

(number) => print(number)

adalah anonymous arrow function yang digunakan sebagai callback.

Jadi satu kode bisa mempunyai ketiga konsep tersebut sekaligus.

29. Cheat Sheet

30. Kesimpulan

Inti materi ini sebenarnya sederhana:

Function biasa:

int cube(int n) {
  return n * n * n;
}

Dipersingkat dengan fat arrow:

int cube(int n) => n * n * n;

Karena:

n * n * n

adalah satu expression.

=> secara konsep sudah berarti:

return

sehingga jangan menulis return lagi.

❌ Salah:

int cube(int n) => return n * n * n;

✅ Benar:

int cube(int n) => n * n * n;

Dan fat arrow juga bisa digunakan pada anonymous function:

var cube = (int n) => n * n * n;

serta callback:

names.forEach((name) => print(name));

dan ini akan sangat sering kamu temui di Flutter:

onPressed: () => print("Button ditekan"),

Kalimat paling penting untuk diingat:

=> adalah cara singkat untuk function yang body-nya hanya terdiri dari satu expression; expression tersebut otomatis menjadi hasil/return function.

Jangan memaksakan => untuk function yang membutuhkan banyak statement. Kalau function sudah memiliki banyak proses, gunakan { ... } seperti biasa.