Fungsi
Fungsi sangat lazim di kode Rust. Kamu sudah melihat salah satu fungsi paling
penting dalam bahasa ini: fungsi main, yang menjadi titik masuk banyak program.
Kamu juga sudah melihat keyword fn, yang dipakai untuk mendeklarasikan fungsi
baru.
Kode Rust memakai snake case sebagai gaya baku untuk nama fungsi dan variabel: semua huruf ditulis kecil dan kata-kata dipisahkan oleh garis bawah. Berikut program yang memuat contoh definisi fungsi:
Filename: src/main.rs
fn main() {
println!("Hello, world!");
another_function();
}
fn another_function() {
println!("Another function.");
}
Kita mendefinisikan fungsi di Rust dengan menulis fn, diikuti nama fungsi dan
sepasang tanda kurung. Kurung kurawal memberi tahu compiler di mana badan fungsi
dimulai dan berakhir.
Kita bisa memanggil fungsi apa pun yang sudah kita definisikan dengan menulis
namanya, lalu sepasang tanda kurung. Karena another_function didefinisikan di
dalam program, fungsi itu bisa dipanggil dari dalam fungsi main. Perhatikan
bahwa kita mendefinisikan another_function setelah fungsi main di kode
sumber; kita juga bisa mendefinisikannya sebelumnya. Rust tidak peduli di mana
kamu mendefinisikan fungsi-fungsimu, asalkan fungsi tersebut didefinisikan di
suatu scope yang bisa dilihat oleh pemanggil.
Mari kita mulai proyek biner baru bernama functions untuk mengeksplorasi fungsi
lebih jauh. Letakkan contoh another_function di src/main.rs lalu jalankan.
Kamu akan melihat output berikut:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.28s
Running `target/debug/functions`
Hello, world!
Another function.
Baris-baris dieksekusi sesuai urutan kemunculannya di dalam fungsi main.
Pertama, pesan “Hello, world!” dicetak, lalu another_function dipanggil dan
pesan dari fungsi itu dicetak.
Parameter
Kita bisa mendefinisikan fungsi yang memiliki parameter, yaitu variabel khusus yang menjadi bagian dari signature fungsi. Ketika sebuah fungsi punya parameter, kamu bisa memberinya nilai konkret untuk parameter tersebut. Secara teknis, nilai konkret itu disebut argumen, tapi dalam percakapan sehari-hari orang cenderung memakai kata parameter dan argumen secara bergantian, baik untuk variabel di definisi maupun untuk nilai konkret yang dikirim saat memanggil fungsi.
Pada versi another_function berikut, kita menambahkan satu parameter:
Filename: src/main.rs
fn main() {
another_function(5);
}
fn another_function(x: i32) {
println!("The value of x is: {x}");
}
Coba jalankan program ini; kamu akan mendapatkan output berikut:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.21s
Running `target/debug/functions`
The value of x is: 5
Deklarasi another_function punya satu parameter bernama x. Tipe x
ditentukan sebagai i32. Saat kita mengirim 5 ke another_function, macro
println! menempatkan 5 di tempat pasangan kurung kurawal berisi x pada
format string.
Di dalam signature fungsi, kamu wajib mendeklarasikan tipe setiap parameter. Ini adalah keputusan yang disengaja dalam desain Rust: mewajibkan anotasi tipe di definisi fungsi berarti hampir tidak pernah ada situasi di mana compiler meminta kamu menuliskan anotasi itu di bagian kode lain untuk menentukan tipe yang kamu maksud. Compiler juga bisa memberi pesan error yang lebih membantu jika ia mengetahui tipe apa yang diharapkan sebuah fungsi.
Saat mendefinisikan beberapa parameter, pisahkan deklarasi parameter dengan koma, seperti ini:
Filename: src/main.rs
fn main() {
print_labeled_measurement(5, 'h');
}
fn print_labeled_measurement(value: i32, unit_label: char) {
println!("The measurement is: {value}{unit_label}");
}
Contoh ini membuat fungsi bernama print_labeled_measurement dengan dua
parameter. Parameter pertama bernama value bertipe i32. Parameter kedua
bernama unit_label bertipe char. Fungsi itu lalu mencetak teks yang memuat
baik value maupun unit_label.
Mari kita jalankan kode ini. Ganti isi file src/main.rs di proyek functions
kamu dengan contoh di atas, lalu jalankan dengan cargo run:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
Running `target/debug/functions`
The measurement is: 5h
Karena kita memanggil fungsi tersebut dengan 5 sebagai nilai value dan 'h'
sebagai nilai unit_label, output program memuat kedua nilai itu.
Statement dan Ekspresi
Badan fungsi tersusun dari serangkaian statement yang secara opsional diakhiri sebuah ekspresi. Sejauh ini, fungsi-fungsi yang kita bahas belum memuat ekspresi penutup, tapi kamu sudah melihat ekspresi sebagai bagian dari sebuah statement. Karena Rust adalah bahasa berbasis ekspresi, perbedaan ini penting untuk kamu pahami. Bahasa lain tidak punya pemisahan yang sama, jadi mari kita lihat apa itu statement dan ekspresi, serta bagaimana perbedaan keduanya memengaruhi badan fungsi.
- Statement adalah instruksi yang menjalankan suatu aksi dan tidak mengembalikan nilai.
- Ekspresi dievaluasi menjadi nilai hasil.
Mari kita lihat beberapa contoh.
Sebenarnya kita sudah memakai statement dan ekspresi. Membuat variabel dan
membuatkannya sebuah nilai dengan keyword let adalah sebuah statement. Pada
Listing 3-1, let y = 6; adalah sebuah statement.
fn main() {
let y = 6;
}
main function declaration containing one statementDefinisi fungsi juga merupakan statement; seluruh contoh di atas adalah sebuah statement dengan sendirinya. (Seperti yang akan kita lihat sebentar lagi, memanggil fungsi bukanlah statement, meski begitu.)
Statement tidak mengembalikan nilai. Karena itu, kamu tidak bisa memberikan
sebuah statement let ke variabel lain, seperti yang dicoba kode berikut; kamu
akan mendapatkan error:
Filename: src/main.rs
fn main() {
let x = (let y = 6);
}
Saat kamu menjalankan program ini, error yang muncul akan terlihat seperti ini:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
error: expected expression, found `let` statement
--> src/main.rs:2:14
|
2 | let x = (let y = 6);
| ^^^
|
= note: only supported directly in conditions of `if` and `while` expressions
warning: unnecessary parentheses around assigned value
--> src/main.rs:2:13
|
2 | let x = (let y = 6);
| ^ ^
|
= note: `#[warn(unused_parens)]` (part of `#[warn(unused)]`) on by default
help: remove these parentheses
|
2 - let x = (let y = 6);
2 + let x = let y = 6;
|
warning: `functions` (bin "functions") generated 1 warning
error: could not compile `functions` (bin "functions") due to 1 previous error; 1 warning emitted
Statement let y = 6 tidak mengembalikan nilai, jadi tidak ada apa pun yang
bisa diikat oleh x. Ini berbeda dari yang terjadi di bahasa lain, seperti C
dan Ruby, di mana penugasan mengembalikan nilai yang ditugaskan. Di bahasa-bahasa
itu, kamu bisa menulis x = y = 6 dan membuat x dan y sama-sama bernilai 6; hal
itu tidak berlaku di Rust.
Ekspresi dievaluasi menjadi sebuah nilai dan menyusun sebagian besar sisa kode
yang akan kamu tulis di Rust. Pertimbangkan operasi aritmetika, seperti 5 + 6,
yang merupakan ekspresi yang dievaluasi menjadi nilai 11. Ekspresi bisa menjadi
bagian dari sebuah statement: Pada Listing 3-1, angka 6 pada statement
let y = 6; adalah ekspresi yang dievaluasi menjadi nilai 6. Memanggil sebuah
fungsi adalah ekspresi. Memanggil macro adalah ekspresi. Blok scope baru yang
dibuat dengan kurung kurawal juga merupakan ekspresi, misalnya:
Filename: src/main.rs
fn main() {
let y = {
let x = 3;
x + 1
};
println!("The value of y is: {y}");
}
Ekspresi berikut:
{
let x = 3;
x + 1
}
adalah sebuah blok yang, pada kasus ini, dievaluasi menjadi 4. Nilai itu
diikat ke y sebagai bagian dari statement let. Perhatikan baris x + 1 yang
tidak diakhiri titik koma, berbeda dari kebanyakan baris yang kamu lihat sejauh
ini. Ekspresi tidak diakhiri titik koma. Jika kamu menambahkan titik koma di
akhir sebuah ekspresi, kamu mengubahnya menjadi statement, dan statement itu
tidak akan mengembalikan nilai. Ingat hal ini saat kamu mengeksplorasi nilai
kembalian fungsi dan ekspresi pada bagian berikut.
Fungsi dengan Nilai Kembalian
Fungsi bisa mengembalikan nilai ke kode yang memanggilnya. Kita tidak memberi
nama pada nilai kembalian, tapi kita wajib mendeklarasikan tipenya setelah tanda
panah (->). Di Rust, nilai kembalian sebuah fungsi identik dengan nilai dari
ekspresi terakhir di dalam blok badan fungsi. Kamu bisa keluar lebih awal dari
sebuah fungsi dengan memakai keyword return dan menyebutkan sebuah nilai,
tapi sebagian besar fungsi mengembalikan ekspresi terakhir secara implisit.
Berikut contoh fungsi yang mengembalikan sebuah nilai:
Filename: src/main.rs
fn five() -> i32 {
5
}
fn main() {
let x = five();
println!("The value of x is: {x}");
}
Tidak ada pemanggilan fungsi, macro, atau bahkan statement let di dalam fungsi
five—hanya angka 5 yang berdiri sendiri. Itu adalah fungsi yang sepenuhnya
valid di Rust. Perhatikan bahwa tipe kembalian fungsi juga dideklarasikan, yaitu
-> i32. Coba jalankan kode ini; outputnya akan terlihat seperti ini:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
Running `target/debug/functions`
The value of x is: 5
Angka 5 di dalam five adalah nilai kembalian fungsi tersebut, itulah
mengapa tipe kembaliannya i32. Mari kita bahas ini lebih rinci. Ada dua bagian
penting: Pertama, baris let x = five(); menunjukkan bahwa kita memakai nilai
kembalian sebuah fungsi untuk menginisialisasi sebuah variabel. Karena fungsi
five mengembalikan 5, baris itu sama dengan baris berikut:
#![allow(unused)]
fn main() {
let x = 5;
}
Kedua, fungsi five tidak punya parameter dan mendefinisikan tipe nilai
kembalian, tapi badan fungsi itu hanya berisi angka 5 yang kesepian tanpa
titik koma, karena angka itu adalah ekspresi yang nilainya ingin kita kembalikan.
Mari kita lihat contoh lain:
Filename: src/main.rs
fn main() {
let x = plus_one(5);
println!("The value of x is: {x}");
}
fn plus_one(x: i32) -> i32 {
x + 1
}
Menjalankan kode ini akan mencetak The value of x is: 6. Tapi apa yang terjadi
jika kita menambahkan titik koma di akhir baris yang memuat x + 1, sehingga
baris itu berubah dari ekspresi menjadi statement?
Filename: src/main.rs
fn main() {
let x = plus_one(5);
println!("The value of x is: {x}");
}
fn plus_one(x: i32) -> i32 {
x + 1;
}
Mengompilasi kode ini akan menghasilkan error sebagai berikut:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
error[E0308]: mismatched types
--> src/main.rs:7:24
|
7 | fn plus_one(x: i32) -> i32 {
| -------- ^^^ expected `i32`, found `()`
| |
| implicitly returns `()` as its body has no tail or `return` expression
8 | x + 1;
| - help: remove this semicolon to return this value
For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions` (bin "functions") due to 1 previous error
Pesan error utama, mismatched types, menyingkap inti masalah dari kode ini.
Definisi fungsi plus_one menyatakan bahwa fungsi itu akan mengembalikan sebuah
i32, tapi statement tidak dievaluasi menjadi sebuah nilai, yang dinyatakan oleh
(), tipe unit. Karena itu, tidak ada nilai yang dikembalikan, dan hal itu
bertentangan dengan definisi fungsi sehingga menghasilkan error. Pada output ini,
Rust memberikan pesan yang mungkin bisa membantu memperbaiki masalah tersebut:
Rust menyarankan untuk menghapus titik koma, yang akan memperbaiki error itu.