Fungsi di Rust

Fungsi adalah blok kode bernama yang bisa dipakai ulang. Daripada menulis langkah yang sama berulang-ulang, kamu menaruhnya di dalam sebuah fungsi sekali saja, lalu memanggilnya kapan pun kamu butuh. Sebenarnya kamu sudah memakai satu fungsi sejak awal: main.

Membuat dan memanggil fungsi

Kamu membuat fungsi dengan fn, dan memanggilnya dengan menulis namanya diikuti ():

fn greet() {
    println!("Halo dari sebuah fungsi!");
}

fn main() {
    greet(); // panggil
    greet(); // panggil lagi
}

Output:

Halo dari sebuah fungsi!
Halo dari sebuah fungsi!

▶ Coba sendiri

Catatan

Rust tidak peduli apakah kamu menulis greet di atas atau di bawah main. Selama fungsinya ada di suatu tempat di dalam file, kamu bisa memanggilnya.

Parameter: memberi input ke fungsi

Fungsi jadi berguna ketika kamu memberinya data untuk diolah. Input ini disebut parameter. Di Rust, kamu wajib menulis tipe setiap parameter:

fn greet(name: &str) {
    println!("Halo, {name}!");
}

fn main() {
    greet("Alice");
    greet("Bob");
}

Output:

Halo, Alice!
Halo, Bob!

▶ Coba sendiri

Kamu boleh punya parameter sebanyak yang kamu butuhkan, dipisahkan dengan koma:

fn describe(name: &str, age: u32) {
    println!("{name} berumur {age} tahun");
}

fn main() {
    describe("Ferris", 10);
}

Output:

Ferris berumur 10 tahun

▶ Coba sendiri

Nilai yang kamu kirim dicocokkan dengan parameternya berdasarkan posisi: nilai pertama masuk ke name, yang kedua ke age. Kalau urutannya tertukar, seperti describe(10, "Ferris"), hasilnya error saat kompilasi, karena tipenya tidak cocok.

Mengembalikan nilai

Sebuah fungsi bisa memberikan nilai kembali ke pemanggilnya. Kamu menuliskan tipe kembalian (return type) setelah tanda panah ->:

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let sum = add(3, 4);
    println!("3 + 4 = {sum}");
}

Output:

3 + 4 = 7

▶ Coba sendiri

Aturan titik koma (penting!)

Perhatikan bahwa a + b pada contoh di atas tidak memakai titik koma. Ini salah satu ide kunci di Rust:

• Ekspresi tanpa titik koma adalah nilai yang dikembalikan.
• Menambahkan titik koma mengubahnya menjadi pernyataan (statement) yang tidak mengembalikan apa-apa.

Jadi kode ini rusak:

fn add(a: i32, b: i32) -> i32 {
    a + b; // ❌ titik koma berarti "tidak mengembalikan apa-apa", padahal kita janji mengembalikan i32
}

Compiler akan protes bahwa fungsi ini seharusnya mengembalikan i32, tapi ternyata tidak. Cukup hapus titik koma di baris terakhir.

Tips

Kalau kamu lebih suka menulis secara eksplisit, kamu bisa memakai kata kunci return: return a + b; (dengan titik koma) juga jalan. Programmer Rust biasanya tidak menulis return di baris terakhir, tapi keduanya benar.

Menggabungkan semuanya

fn square(n: i32) -> i32 {
    n * n
}

fn main() {
    let result = square(5);
    println!("5 kuadrat adalah {result}");
}

Output:

5 kuadrat adalah 25

▶ Coba sendiri

Latihan

1. Celsius ke Fahrenheit

Tulis fungsi to_fahrenheit yang menerima suhu dalam Celsius sebagai f64 dan mengembalikannya dalam Fahrenheit. Rumusnya c * 9.0 / 5.0 + 32.0. Panggil fungsinya untuk 0, 100, dan 37 derajat. Petunjuk: signature-nya fn to_fahrenheit(c: f64) -> f64, dan isinya cukup satu ekspresi tanpa titik koma.

Lihat solusi

fn to_fahrenheit(c: f64) -> f64 {
    c * 9.0 / 5.0 + 32.0
}

fn main() {
    println!("0°C sama dengan {}°F", to_fahrenheit(0.0));
    println!("100°C sama dengan {}°F", to_fahrenheit(100.0));
    println!("37°C sama dengan {}°F", to_fahrenheit(37.0));
}

Output:

0°C sama dengan 32°F
100°C sama dengan 212°F
37°C sama dengan 98.6°F

▶ Coba sendiri

Perhatikan bahwa kita mengirim 0.0, bukan 0. Parameternya bertipe f64, dan Rust tidak akan diam-diam mengubah bilangan bulat menjadi float untukmu. Kalau sebuah f64 tidak punya bagian pecahan, {} mencetaknya tanpa .0, makanya kamu melihat 32, bukan 32.0.

2. Yang terbesar dari tiga

Tulis fungsi largest(a: i32, b: i32, c: i32) -> i32 yang mengembalikan angka terbesar dari ketiga inputnya. Uji dengan (3, 9, 4) dan (-2, -8, -5). Petunjuk: if adalah ekspresi di Rust (lihat If…Else), jadi rangkaian if / else if / else bisa menjadi baris terakhir fungsi.

Lihat solusi

fn largest(a: i32, b: i32, c: i32) -> i32 {
    if a >= b && a >= c {
        a
    } else if b >= c {
        b
    } else {
        c
    }
}

fn main() {
    println!("{}", largest(3, 9, 4));
    println!("{}", largest(-2, -8, -5));
}

Output:

9
-2

▶ Coba sendiri

Tidak ada satu pun cabang yang diakhiri titik koma. Masing-masing adalah ekspresi, seluruh rangkaian if menghasilkan salah satunya, dan nilai itulah yang menjadi nilai kembalian. Memakai >= alih-alih > memastikan fungsi tetap mengembalikan nilai kalau ada angka yang sama besar.

Ringkasan

• Buat fungsi dengan fn, panggil dengan name().
• Parameter adalah input; masing-masing butuh tipe: fn greet(name: &str).
• Tulis tipe kembalian dengan -> Type.
• Ekspresi terakhir tanpa titik koma adalah nilai kembaliannya.
• return value; juga bisa, tapi biasanya hanya dipakai untuk keluar lebih awal (early return).

Kuis singkat

Kuis singkat

1. Di Rust, apakah kamu perlu menulis tipe setiap parameter fungsi?

Tidak, tidak pernah Hanya untuk nilai kembalian Ya, wajib

2. Bagaimana cara menuliskan tipe kembalian sebuah fungsi?

Dengan titik dua sebelum isi fungsi Dengan tanda panah -> diikuti tipenya Rust menebaknya secara otomatis

3. Apa yang membuat a + b (tanpa titik koma) di akhir fungsi menjadi nilai kembaliannya?

Ekspresi tanpa titik koma menghasilkan nilainya, dan nilai itu menjadi nilai kembalian Kamu butuh kata kunci return supaya dihitung Tidak ada — kamu harus selalu memakai return

4. Apakah penting fungsi ditulis di atas atau di bawah tempat ia dipanggil (misalnya di atas atau di bawah main)?

Ya, harus ditulis di atas tempat pemanggilannya Tidak — Rust tidak peduli urutan penulisan di dalam file Hanya kalau fungsinya punya parameter

Skor: 0 / 4

Bacaan lebih lanjut

• Functions — The Rust Book (bahasa Inggris): bab resmi tentang parameter, nilai kembalian, serta pernyataan (statement) dan ekspresi.
• Statements and Expressions — The Rust Book (bahasa Inggris): pembahasan lebih dalam tentang ide di balik aturan titik koma.
• Functions — Rust by Example (bahasa Inggris): contoh yang bisa dijalankan, termasuk return lebih awal dan fungsi yang tidak mengembalikan apa-apa.
• Functions — The Rust Reference (bahasa Inggris): aturan persis tentang cara mendefinisikan fungsi, kalau kamu ingin detail lengkapnya.
• Keyword fn — dokumentasi standard library (bahasa Inggris): ringkasan singkat sintaks fungsi dengan contoh.