Output di Rust

Kamu sudah berkali-kali memakai println!. Halaman ini membahas makro-makro lain untuk mencetak yang akan kamu temui, dan kapan sebaiknya memakai masing-masing.

println! dan print!

println! mencetak teks lalu menambahkan baris baru (newline) di akhir. print! melakukan hal yang sama, tapi tidak menambahkan baris baru:

fn main() {
    print!("Halo, ");
    print!("dunia");
    println!("!");
}

Output:

Halo, dunia!

▶ Coba sendiri

Perhatikan bahwa ketiga pemanggilan itu tercetak di baris yang sama. Hanya println! yang pindah ke baris baru. Dalam praktiknya, kamu akan hampir selalu memakai println!; print! terutama berguna saat kamu menyusun satu baris sedikit demi sedikit.

Placeholder: {} dan nama variabel

Kamu sudah melihat {} dipakai sebagai placeholder. Kamu bisa mengisinya dengan memberikan nilai setelah string-nya, atau dengan menaruh nama variabel langsung di dalam kurung kurawal:

fn main() {
    let name = "Ferris";
    let age = 10;

    println!("{} berumur {} tahun", name, age); // berdasarkan posisi
    println!("{name} berumur {age} tahun");     // langsung di dalam teks (hasilnya sama)
}

Output:

Ferris berumur 10 tahun
Ferris berumur 10 tahun

▶ Coba sendiri

Kedua baris mencetak hal yang sama. Gaya inline ({name}) sedikit lebih baru dan biasanya lebih mudah dibaca, jadi pakai gaya ini kalau bisa.

format!: menyusun string tanpa mencetaknya

Kadang kamu ingin teks yang sudah diformat dalam bentuk String, bukan langsung dicetak. Misalnya untuk disimpan atau diberikan ke fungsi lain. Untuk itulah format! ada. Cara kerjanya persis seperti println!, tapi mengembalikan String alih-alih mencetaknya:

fn main() {
    let name = "Ferris";
    let message = format!("Halo, {name}!");
    println!("{message}");
}

Output:

Halo, Ferris!

▶ Coba sendiri

Debug print dengan {:?}

{} biasa hanya bekerja untuk nilai yang tahu cara menampilkan dirinya sebagai teks, seperti angka, string, dan boolean. Untuk nilai yang lebih kompleks seperti tuple atau struct, {} tidak akan bisa di-compile. Pakai {:?} (format “debug”) sebagai gantinya:

fn main() {
    let point = (3, 7);
    println!("{:?}", point);
}

Output:

(3, 7)

▶ Coba sendiri

Untuk tampilan multi-baris yang lebih rapi pada nilai yang lebih besar, pakai {:#?} (pretty-print):

fn main() {
    let point = (3, 7);
    println!("{:#?}", point);
}

Output:

(
    3,
    7,
)

▶ Coba sendiri

Catatan

Kalau Rust memberi tahu bahwa sebuah tipe “doesn’t implement Display” (tidak mengimplementasikan Display), itu tanda kamu sebaiknya mencoba {:?} alih-alih {}. Ini salah satu error paling umum yang dialami pemula saat mencetak sesuatu.

Format angka

Beberapa trik format yang sering dipakai:

fn main() {
    let pi = 3.14159;
    println!("{:.2}", pi);   // 2 angka di belakang koma -> 3.14
    println!("{:5}", 42);    // lebar minimal 5         -> "   42"
    println!("{:08.2}", pi); // diisi angka nol         -> 00003.14
}

Output:

3.14
   42
00003.14

▶ Coba sendiri

Kamu tidak perlu menghafal semuanya. Cukup tahu bahwa trik-trik ini ada, untuk saat kamu perlu meluruskan deretan angka atau membulatkan desimal. Perhatikan juga bahwa Rust selalu memakai titik (.) sebagai pemisah desimal, bukan koma seperti yang biasa kita tulis di Indonesia.

Merapikan teks, dan mencetak kurung kurawal

Lebar juga bisa dipakai untuk teks, dan kamu bisa memilih nilainya menempel ke sisi mana. Setelah :, tulis < (kiri), > (kanan), atau ^ (tengah), lalu lebarnya. Kamu juga bisa menaruh karakter pengisi di depannya, misalnya -:

fn main() {
    let coffee = 3.5;
    let bagel = 2.25;

    println!("{:-^20}", " MENU ");
    println!("{:<12}{:>8}", "Barang", "Harga");
    println!("{:<12}{:>8.2}", "Kopi", coffee);
    println!("{:<12}{:>8.2}", "Bagel", bagel);
    println!("{:<12}{:>8.2}", "Total", coffee + bagel);
}

Output:

------- MENU -------
Barang         Harga
Kopi            3.50
Bagel           2.25
Total           5.75

▶ Coba sendiri

Membaca {:>8.2} bagian demi bagian: > berarti rata kanan, 8 adalah lebarnya, dan .2 berarti dua angka di belakang koma. Angka yang rata kanan membuat titik desimalnya sejajar, itulah sebabnya struk belanja dan tabel memakai cara ini.

Bagaimana kalau kamu ingin mencetak karakter { sungguhan? Karena kurung kurawal berarti “placeholder”, kamu harus menggandakannya: {{ mencetak { dan }} mencetak }.

fn main() {
    println!("Himpunan: {{{}, {}}}", 1, 2);
}

Output:

Himpunan: {1, 2}

▶ Coba sendiri

Mencetak pesan error

Ada juga eprintln! (dan eprint!). Cara kerjanya persis seperti println!, tapi menulis ke output error (stderr), bukan ke output normal. Terminal menampilkan keduanya, tapi kalau seseorang menyimpan output programmu ke sebuah file, pesan error tidak ikut masuk ke file itu. Pakai makro ini untuk peringatan dan pesan error.

Latihan

1. Label harga

Simpan nama barang "Buku tulis" dan harga 2.5, lalu cetak Buku tulis harganya $2.50. Petunjuk: {:.2} membulatkan ke dua angka di belakang koma, dan juga bisa dipakai secara inline: {price:.2}.

Lihat solusi

fn main() {
    let item = "Buku tulis";
    let price = 2.5;
    println!("{item} harganya ${price:.2}");
}

Output:

Buku tulis harganya $2.50

▶ Coba sendiri

2. Susun sebuah label, lalu cetak dengan dua cara

Pakai format! untuk menyusun label ferris-7 dari nama "ferris" dan angka 7. Cetak sekali dengan {} dan sekali dengan {:?}, lalu temukan bedanya. Petunjuk: format! menerima placeholder yang persis sama dengan println!.

Lihat solusi

fn main() {
    let name = "ferris";
    let id = 7;
    let label = format!("{name}-{id}");

    println!("{label}");
    println!("{label:?}");
}

Output:

ferris-7
"ferris-7"

▶ Coba sendiri

Debug print menampilkan teks beserta tanda kutipnya, jadi kamu bisa melihat persis di mana teks itu dimulai dan berakhir. Ini berguna kalau sebuah nilai punya spasi nyasar.

Ringkasan

• println! mencetak dengan baris baru; print! tidak.
• {} dan {name} adalah placeholder untuk nilai yang bisa menampilkan dirinya lewat Display.
• format! bekerja seperti println!, tapi mengembalikan String alih-alih mencetaknya.
• {:?} (dan {:#?}) mencetak nilai untuk keperluan debugging, termasuk nilai yang tidak bisa ditangani {}.
• {:.2} membulatkan desimal; <, >, dan ^ dengan lebar tertentu merapikan teks; {{ dan }} mencetak kurung kurawal apa adanya.

Kuis singkat

Kuis singkat

1. Apa perbedaan println! dan print!?

println! menambahkan baris baru di akhir, print! tidak print! menambahkan baris baru di akhir, println! tidak Tidak ada bedanya

2. Kenapa kamu memakai {:?} alih-alih {} untuk mencetak sebuah tuple?

{:?} berjalan lebih cepat Tuple tidak mengimplementasikan Display, jadi {} tidak bisa di-compile {} hanya bisa dipakai di dalam print!, bukan println!

Skor: 0 / 2

Bacaan lebih lanjut

• std::fmt — standard library docs (bahasa Inggris): daftar lengkap opsi format, termasuk lebar, karakter pengisi, perataan, dan presisi.
• Formatted print — Rust by Example (bahasa Inggris): contoh yang bisa dijalankan untuk argumen berdasarkan posisi dan nama, padding, dan perataan.
• Debug — Rust by Example (bahasa Inggris): cara kerja {:?} dan {:#?}, dan bagaimana tipe buatanmu sendiri bisa memakainya.
• println! — standard library docs (bahasa Inggris): referensi resmi untuk println!, dengan tautan ke print! dan eprintln!.
• format! — standard library docs (bahasa Inggris): menyusun String dengan aturan format yang sama.