BAB 1: Program Pertama: Hello Rust
Program Rust pertama: fungsi main sebagai titik masuk, macro println!, menulis ke stderr, dan pesan kompilator saat format atau fungsi utama salah.
Program Rust pertama hanya 3 baris, tetapi di dalamnya ada 4 hal yang berbeda dari bahasa yang memakai interpreter: fungsi main sebagai titik masuk, makro println! dengan tanda seru, argumen format di dalam string, dan langkah kompilasi yang menghasilkan berkas biner sebelum program bisa dijalankan.
Bab ini menulis program itu, menjalankannya, lalu membongkar tiap bagian dengan bukti dari kompilator. Semua contoh dikompilasi dengan rustc 1.100.0, dan pesan kesalahan yang dikutip adalah keluaran asli kompilator, bukan ringkasan.
Program pertama
fn main() {
println!("Hello, Rust!");
}
Simpan sebagai hello.rs, lalu kompilasi:
rustc hello.rs
./hello
Baris pertama menghasilkan berkas hello yang bisa dijalankan langsung. Baris kedua menjalankannya dan mencetak:
Hello, Rust!
Berkas hello itu bukan skrip yang dibaca ulang setiap kali dijalankan. Ukurannya 4.493.168 byte, dan isinya sudah berupa kode mesin untuk sistem tempat kompilasi dilakukan.
fn main adalah titik masuk
Program Rust selalu dimulai dari fungsi bernama main. Tanpa fungsi itu, kompilasi gagal sebelum program sempat dijalankan:
fn utama() {
println!("tanpa main");
}
error[E0601]: `main` function not found in crate `tanpa_main`
--> tanpa_main.rs:3:2
|
3 | }
| ^ consider adding a `main` function to `tanpa_main.rs`
Nama main tidak bisa diganti, dan posisinya boleh di mana saja di dalam berkas. Yang penting, hanya ada 1 fungsi main pada setiap program yang bisa dijalankan.
Tanda kurung kurawal {} setelah main() menandai blok kode milik fungsi itu. Semua perintah yang ingin dijalankan ditulis di dalamnya.
println! adalah makro, bukan fungsi
Tanda seru setelah println bukan hiasan. Tanda itu menandakan bahwa println! adalah makro, yaitu kode yang diperluas menjadi kode lain saat kompilasi. Salah satu akibatnya, println! bisa memeriksa jumlah dan tipe argumen pada saat kompilasi, sebelum program berjalan.
fn main() {
println!("Hello, Rust!");
}
Kalau tanda seru dihilangkan, kompilator akan mengeluh karena tidak ada fungsi bernama println. Untuk sementara, aturan yang perlu diingat: semua pencetakan di bab ini memakai tanda seru, karena println! dan eprintln! keduanya makro.
Argumen format di dalam string
println! menerima string format dan daftar nilai. Tanda {} di dalam string digantikan nilai sesuai urutan, sedangkan {nama} mengambil variabel dengan nama tersebut.
fn main() {
println!("Nama saya {}, umur saya {} tahun", "Aziz", 30);
let angka = 7;
println!("angka = {angka}, kuadrat = {}", angka * angka);
}
Nama saya Aziz, umur saya 30 tahun
angka = 7, kuadrat = 49
Bentuk {angka} lebih ringkas dan lebih aman daripada {}, karena nama variabelnya terlihat di dalam string. Kalau variabel itu nanti diubah namanya, kompilator akan menolak kode yang masih memakai nama lama.
Kalau jumlah argumen tidak cocok dengan tanda {}, kompilasi berhenti:
fn main() {
println!("{} dan {}", 1);
}
error: 2 positional arguments in format string, but there is 1 argument
--> format_salah.rs:2:15
|
2 | println!("{} dan {}", 1);
| ^^ ^^ -
Kesalahan seperti ini tidak mungkin lolos ke pengguna, karena kompilator menghitungnya sebelum program dibuat.
Kurung kurawal yang ingin dicetak
Kurung kurawal dipakai penanda format, sehingga kurung kurawal yang ingin tampil apa adanya harus ditulis 2 kali:
fn main() {
println!("kurung kurawal ditulis {{seperti ini}}");
}
kurung kurawal ditulis {seperti ini}
Mencetak ke stderr
println! menulis ke stdout, sedangkan eprintln! menulis ke stderr. Pada program yang dijalankan di terminal, keduanya terlihat sama. Perbedaannya terlihat saat keluarannya dipisah, misalnya dengan pengalihan:
fn main() {
println!("baris ini keluar lewat stdout");
eprintln!("baris ini keluar lewat stderr");
}
./program 2>/dev/null
baris ini keluar lewat stdout
./program 1>/dev/null
baris ini keluar lewat stderr
Pemisahan ini berguna untuk pesan kesalahan dan log, karena keduanya bisa disimpan di berkas berbeda dari hasil program. Untuk sementara, cukup ingat bahwa println! untuk hasil, eprintln! untuk pesan diagnostik.
Membaca susunan program
Kembali ke program pertama, tiap bagiannya punya tugas:
| Bagian | Tugas |
|---|---|
fn | menandai deklarasi fungsi |
main() | nama fungsi yang dijadikan titik masuk |
{ } | blok kode yang dijalankan |
println! | makro pencetak ke stdout |
"Hello, Rust!" | string format tanpa penanda |
; | penutup pernyataan |
Titik koma di akhir baris println! wajib ditulis, karena baris itu adalah pernyataan. Aturan ini akan terasa berbeda saat masuk ke bab tentang block expression, karena tidak semua baris di Rust diakhiri titik koma.
Titik koma yang hilang
Titik koma di akhir println! mudah terlupa, terutama bagi yang terbiasa dengan bahasa tanpa titik koma. Kalau baris itu bukan baris terakhir di dalam blok, kompilator menolaknya:
fn main() {
println!("satu")
println!("dua");
}
error: expected `;`, found `println`
--> tanpa_titikkoma.rs:2:21
|
2 | println!("satu")
| ^ help: add `;` here
3 | println!("dua");
| ------- unexpected token
Perhatikan bahwa baris terakhir di dalam blok justru tidak wajib berakhir titik koma, karena baris itu dibaca sebagai nilai kembalian blok. Aturan ini yang membuat contoh 1 baris seperti fn main() { println!("hai") } tetap sah.
Kompilasi sekali, jalankan berkali-kali
Biner hasil kompilasi bisa dijalankan tanpa kompiler. Saya menjalankan hello dengan PATH yang tidak memuat folder cargo, dan programnya tetap mencetak Hello, Rust! dengan kode keluar 0.
env -i PATH=/usr/bin:/bin ./hello
Hello, Rust!
Sifat ini yang membedakan alur kerja Rust dari bahasa ber-interpreter. Kompilasi memakan waktu di awal, tetapi menjalankan program sesudahnya tidak memerlukan apa pun selain berkas biner itu, dan mesin tujuan tidak perlu memasang Rust.
Nama berkas menentukan nama biner
rustc memakai nama berkas sumber sebagai nama biner, tanpa ekstensi .rs. Berkas nama-berkas.rs menghasilkan biner nama-berkas sebesar 4.493.232 byte, lengkap dengan tanda hubung di namanya.
rustc nama-berkas.rs
./nama-berkas
Kalau nama biner ingin berbeda, tulis dengan -o:
rustc nama-berkas.rs -o program_saya
Nama berkas sumber tidak berpengaruh pada isi program. Yang berpengaruh hanya nama biner yang dihasilkan, dan itulah yang dipakai saat program dijalankan.
Eksperimen pertama
5 hal yang bisa dicoba setelah program pertama berjalan:
- Ganti teks di dalam string, kompilasi ulang, lalu jalankan. Berkas biner lama akan tertimpa, jadi tidak perlu menghapusnya lebih dulu.
- Hapus fungsi
maindan lihat pesanE0601muncul. - Tambah 1 argumen pada string format yang hanya punya 1 penanda, lalu baca pesan kesalahannya.
- Hapus titik koma pada baris pertama di dalam blok dan lihat pesan
expected ;muncul. - Ganti
println!menjadieprintln!, lalu jalankan dengan2>/dev/nulluntuk melihat keluarannya hilang dari layar.
Kelima percobaan itu memakai perintah yang sama, dan itu inti alur kerja Rust: ubah kode, kompilasi, jalankan. Tidak ada langkah tambahan seperti memasang runtime atau menjalankan server, dan tidak ada berkas perantara yang perlu diurus sendiri.
Ringkasan
Program Rust dijalankan dari fungsi main, dan kompilasi dengan rustc menghasilkan berkas biner yang bisa dijalankan langsung. println! adalah makro, bukan fungsi, sehingga pemanggilannya memakai tanda seru.
String format memakai {} untuk nilai berurutan dan {nama} untuk variabel tertentu, sedangkan kurung kurawal yang ingin dicetak ditulis 2 kali. Keluaran hasil memakai println! ke stdout, pesan diagnostik memakai eprintln! ke stderr, dan kesalahan format maupun fungsi main yang hilang ditolak saat kompilasi.
Referensi
- The Rust Programming Language. Hello, World!.
- The Rust Programming Language. Hello, Cargo!.
- Standard library. Macro println.
- Standard library. Macro eprintln.