Catatan Tutorials

Fungsi: input, output, side effect

Apa yang masuk ke sebuah fungsi, apa yang keluar, dan apa lagi yang ia ubah di sepanjang jalan. Parameter, nilai kembalian, cara argumen dioper di Python, JavaScript, PHP, dan Go, dan kenapa fungsi murni lebih mudah dipercaya.

5 menit bacaTersedia juga dalam bahasa Inggris →

Di bagian 0 kita berkenalan dengan tiga langkah dasar pemrograman: primitif, kombinasi, dan abstraksi, yaitu memberi nama pada sebuah pekerjaan. Fungsi adalah cara utama melakukannya. Bagian ini memandang fungsi sebagai mesin kecil dengan tiga hal yang perlu diperhatikan: apa yang masuk, apa yang keluar, dan apa lagi yang ia ubah di sepanjang jalan. Yang ketiga, side effect, adalah tempat kebanyakan bug menarik bersembunyi.

Input dan output

Fungsi punya parameter (nama-nama di definisinya) dan menerima argumen (nilai sebenarnya yang dioper saat dipanggil). Ia mengembalikan nilai kembalian (return value).

def with_tax(price):        # price adalah parameter
    return round(price * 1.11)

total = with_tax(100)        # 100 adalah argumen; total bernilai 111

Kalau sebuah fungsi tidak mengembalikan apa pun secara eksplisit, kebanyakan bahasa tetap memberi sesuatu. Tutorial Python menyebut “even functions without a return statement do return a value, albeit a rather boring one. This value is called None”: fungsi tanpa return tetap mengembalikan nilai, yaitu None.

def greet(name):
    print("Hello,", name)

result = greet("Rama")
print(result)
Hello, Rama
None

Ini bug pemula yang umum: fungsi yang mencetak hasil alih-alih mengembalikannya. Di terminal terlihat benar, tapi pemanggilnya tidak dapat apa-apa untuk diolah. Aturannya: kembalikan nilai, biarkan pemanggil yang memutuskan mau dicetak atau tidak.

Mengembalikan lebih dari satu hal

Kadang fungsi perlu menyampaikan dua hal: hasilnya, dan apakah berhasil. Go menyediakannya langsung di bahasanya. Effective Go: “One of Go’s unusual features is that functions and methods can return multiple values.” Fungsi di Go bisa mengembalikan beberapa nilai. Polanya yang umum adalah nilai plus error:

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

result, err := divide(10, 4)   // 2.5, nil
_, err = divide(1, 0)          // error: division by zero

Python dan JavaScript bisa mengembalikan tuple atau objek dengan efek yang sama, dan PHP bisa mengembalikan array. Penanganan error akan dapat bagian tersendiri nanti di seri ini.

Bagaimana argumen dioper

Saat sebuah variabel dioper ke fungsi, apakah fungsi menerima variabel itu sendiri, atau salinannya? Di sinilah bagian 3 tentang nilai dan referensi terasa gunanya, karena tiap bahasa menjawab sedikit berbeda.

Python. Kata tutorialnya: “arguments are passed using call by value (where the value is always an object reference, not the value of the object).” Argumen dioper sebagai nilai, dan nilainya selalu berupa referensi ke objek. Dalam praktiknya: fungsi bisa mengubah objek mutable yang Anda oper, tapi tidak bisa membuat variabel Anda menunjuk ke objek lain.

def rename(user):
    user["name"] = "Budi"        # mengubah objek yang dipakai bersama

def replace(user):
    user = {"name": "Sari"}      # hanya mengganti nama lokal

u = {"name": "Rama"}
rename(u);  print(u)             # {'name': 'Budi'}
replace(u); print(u)             # {'name': 'Budi'}  ← tidak berubah

JavaScript berperilaku sama. MDN: “Parameters are essentially passed to functions by value”, tapi “When you pass an object as a parameter, if the function changes the object’s properties, that change is visible outside the function.” Perubahan properti objek terlihat di luar fungsi. Pasangan rename/replace yang sama di JavaScript mencetak Budi dua kali.

PHP berbeda untuk array, karena array adalah nilai. “By default, function arguments are passed by value”, jadi fungsi mendapat salinannya sendiri:

function addItem(array $items, string $item): array {
    $items[] = $item;
    return $items;
}
$list = ["a"];
$new = addItem($list, "b");
echo json_encode($list), " ", json_encode($new);   // ["a"] ["a","b"]

“To allow a function to modify its arguments, they must be passed by reference”: supaya fungsi bisa mengubah argumennya, oper dengan referensi, yaitu menaruh & di depan nama parameter:

function addItemRef(array &$items, string $item): void {
    $items[] = $item;
}
addItemRef($list, "c");
echo json_encode($list);   // ["a","c"]

Go juga menyalin nilai, tapi slice adalah deskriptor kecil yang menunjuk ke data bersama, jadi fungsi bisa mengubah elemennya:

func double(nums []int) {
    for i := range nums {
        nums[i] *= 2
    }
}
nums := []int{1, 2, 3}
double(nums)
fmt.Println(nums)   // [2 4 6]

Tidak perlu menghafal keempatnya. Kebiasaan yang penting: saat mengoper sesuatu ke fungsi, ketahui apakah fungsi itu bisa mengubahnya, dan nyatakan itu lewat nama atau dokumentasinya.

Side effect

Sebuah fungsi punya side effect “if it has any observable effect other than its primary effect”, yaitu efek apa pun yang terlihat selain menghitung dan mengembalikan hasilnya. Side effect yang umum:

  • mencetak atau menulis log
  • menulis ke file, database, atau API
  • mengubah argumen yang dioper ke dalamnya
  • mengubah variabel global atau variabel di level modul
  • membaca sesuatu yang berubah sendiri: waktu sekarang, angka acak, input pengguna

Side effect bukan hal buruk. Program tanpa side effect tidak bisa menyimpan maupun menampilkan apa pun. Masalahnya adalah side effect yang tidak disangka. Contoh kecil dengan akibat besar:

def add_tax_in_place(cart):
    for item in cart:
        item["price"] = round(item["price"] * 1.11)
    return cart

cart = [{"name": "book", "price": 100}]
add_tax_in_place(cart)
add_tax_in_place(cart)     # dipanggil lagi di tempat lain...
print(cart)
[{'name': 'book', 'price': 123}]

Pajaknya terhitung dua kali, karena fungsinya mengubah keranjang alih-alih mengembalikan keranjang baru. Setiap pemanggilan baik-baik saja kalau berdiri sendiri; bug-nya baru muncul saat dua bagian program sama-sama memanggilnya.

Fungsi murni (pure function)

Fungsi murni punya dua sifat: “the function return values are identical for identical arguments” (input yang sama selalu menghasilkan output yang sama), dan “the function has no side effects” (tidak punya side effect). Fungsi pajak yang ditulis dengan cara itu:

def with_tax(cart):
    return [{**item, "price": round(item["price"] * 1.11)} for item in cart]

cart = [{"name": "book", "price": 100}]
print(with_tax(cart), cart)
[{'name': 'book', 'price': 111}] [{'name': 'book', 'price': 100}]

Keranjang aslinya tidak tersentuh, dan dipanggil dua kali tetap memberi jawaban yang sama. Fungsi murni itu:

  • Mudah dites: beri input, cek output. Tidak perlu database atau persiapan.
  • Mudah dipakai ulang: tidak bergantung pada sekitarnya dan tidak mengganggunya.
  • Aman di-cache: memoization dari bagian 6 hanya bisa bekerja karena fib adalah fungsi murni.

Cara praktis menggabungkan keduanya: simpan keputusan dan perhitungan di fungsi murni, lalu dorong side effect (membaca request, menulis ke database, mengirim email) ke lapisan tipis di tepi program.

Kebiasaan menulis fungsi yang baik

  • Satu tugas. Kalau butuh kata “dan” untuk menjelaskan apa yang dilakukan sebuah fungsi, kemungkinan itu dua fungsi.
  • Nama yang menjelaskan isinya. Kata kerja untuk aksi (send_invoice), kata benda atau pertanyaan untuk nilai (total_price, is_overdue).
  • Sedikit parameter. Lebih dari tiga atau empat biasanya berarti sebagian sebenarnya satu kelompok dan lebih cocok jadi satu objek.
  • Tanpa flag boolean yang mengubah perilaku. save(user, True) tidak menjelaskan apa-apa ke pembaca. Dua fungsi dengan nama jelas lebih baik.
  • Kembalikan, jangan cetak. Biarkan pemanggil yang memutuskan mau diapakan hasilnya.
  • Buat side effect terlihat jelas. Fungsi bernama calculate_total tidak seharusnya ikut mengirim email.

Kenapa ini penting sehari-hari

  • Perubahan yang terjadi dua kali. Diskon, pajak, dan penyesuaian stok yang diterapkan dua kali adalah bug production klasik, dan hampir selalu berasal dari fungsi yang mengubah inputnya.
  • Testing. Kode yang penuh side effect butuh database dan mock untuk dites. Fungsi murni cukup dua baris.
  • Pindah bahasa. “Oper array ini ke fungsi” berarti salinan di PHP, tapi objek bersama di Python dan JavaScript. Tahu bedanya menghemat berjam-jam.
  • Membaca kode. Nama fungsi yang baik ditambah tanpa side effect tersembunyi berarti kita bisa memahami sebuah pemanggilan tanpa membuka fungsinya.

Coba sendiri

  1. Tulis fungsi yang mencetak total, lalu ubah supaya mengembalikan total. Pakai di dua tempat.
  2. Di PHP, tulis fungsi yang menambahkan item ke array, sekali tanpa & dan sekali dengan &. Cetak array aslinya setelah tiap pemanggilan.
  3. Ambil contoh add_tax_in_place dan tulis ulang sebagai fungsi murni. Panggil dua kali dan bandingkan.
  4. Cari fungsi di kode Anda sendiri yang mengerjakan lebih dari satu tugas. Pecah jadi dua.

Ringkasan

  • Fungsi punya input (parameter), output (nilai kembalian), dan mungkin side effect.
  • Fungsi tanpa return tetap mengembalikan sesuatu (None di Python). Kembalikan nilai, jangan dicetak.
  • Go bisa mengembalikan beberapa nilai, biasanya hasil plus error.
  • Python dan JavaScript mengoper referensi objek sebagai nilai; PHP menyalin array kecuali memakai &; Go menyalin nilai tapi slice berbagi data.
  • Side effect adalah efek apa pun yang terlihat selain nilai kembalian; yang tidak terduga memicu bug paling parah.
  • Fungsi murni selalu memberi output sama untuk input sama dan tidak mengubah apa pun, jadi mudah dites, dipakai ulang, dan di-cache.

Referensi