Printing 'hello, world!'

See this chapter on YouTube: Video 1, Video 2

Apabila kita memulai sebuah program Rust yang baru, maka code awalnya akan selalu terlihat seperti ini:

fn main() {
    println!("Hello, world!");
}

fn artinya adalah function/fungsi,
main adalah function yang memulai sebuah program,
() artinya adalah, kita tidak memberikan variabel apapun ke fungsi untuk memulai program.

{} disebut sebagai code block. Ini adalah tempat dimana code akan ditulis.

println! adalah sebuah macro yang akan melakukan print ke console. Sebuah macro sama seperti sebuah fungsi yang akan menuliskan code untuk kita. Macro memiliki ! setelah nama macronya dituliskan. Kita akan mempelajari tentang membuat macro di beberapa chapter selanjutnya. Tapi untuk sekarang, cukup diingat bahwa ! itu artinya adalah sebuah macro.

Untuk mempelajari tentang ;, terlebih dahulu kita buat fungsi yang lain. Pertama, di dalam main, kita akan mencetak angka 8:

fn main() {
    println!("Hello, world number {}!", 8);
}

{} pada println! artinya "letakkan variabelnya ke dalam sini". Maka dicetaklah Hello, world number 8!.

Kita bisa menggunakan lebih banyak {}, seperti yang kita lakukan sebelumnya:

fn main() {
    println!("Hello, worlds number {} and {}!", 8, 9);
}

Maka tercetak Hello, worlds number 8 and 9!.

Sekarang, kita akan membuat sebuah fungsi.

fn number() -> i32 {
    8
}

fn main() {
    println!("Hello, world number {}!", number());
}

Ini juga akan mencetak Hello, world number 8!. Di saat Rust melihat ke number(), Rust akan melihatnya sebagai sebuah fungsi. Adapun fungsi ini:

Tidak mengambil nilai dari variabel manapun (karena ia memiliki ())
Me-return/mengembalikan i32. Tanda -> (disebut sebagai "skinny arrow") menunjukkan apa yang fungsi akan kembalikan.

Di dalam fungsi tersebut, hanya ada 8. Karena tidak ada ;, maka itu adalah value yang akan di-return. Jika ada ;, maka ia tidak akan me-return apapun (compiler akan me-return ()). Rust tidak akan meng-compile ini jika terdapat sebuah ;, karena returnnya bertype i32 dan ; me-return (), bukan i32:

fn main() {
    println!("Hello, world number {}", number());
}

fn number() -> i32 {
    8;  // ⚠️
}

5 | fn number() -> i32 {
  |    ------      ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
6 |     8;
  |      - help: consider removing this semicolon

Ini artinya "kamu beri tahu saya bahwa number() akan mengembalikan i32, tapi kamu tambahkan ;, sehingga tidak bisa mengembalikan/me-return apapun". Oleh karena itu compiler menyarankan untuk menghapus semicolon/titik koma.

Kita juga bisa menulis return 8; tapi, sangatlah umum di Rust untuk menghapus ; dan juga return.

Apabila Anda ingin memasukkan variabel ke dalam sebuah function, letakkan ia di dalam (). Anda perlu memberi variabel tersebut sebuah nama dan juga menuliskan typenya.

fn multiply(number_one: i32, number_two: i32) { // Dua buah i32 akan dimasukkan ke function. Kita akan menyebutnya sebagai number_one dan number_two.
    let result = number_one * number_two;
    println!("{} times {} is {}", number_one, number_two, result);
}

fn main() {
    multiply(8, 9); // Kita bisa memberikan angkanya secara langsung
    let some_number = 10; // Atau kita bisa mendeklarasikan 2 variabel
    let some_other_number = 2;
    multiply(some_number, some_other_number); // dan kita masukkan keduanya ke dalam function
}

Kita juga bisa me-return i32. Cukup hilangkan semicolon pada bagian akhirnya:

fn multiply(number_one: i32, number_two: i32) -> i32 {
    let result = number_one * number_two;
    println!("{} times {} is {}", number_one, number_two, result);
    result // ini adalah variabel result yang bertype i32, yang akan kita return
}

fn main() {
    let multiply_result = multiply(8, 9); // Kita menggunakam multiply() untuk mencetak dan memberikan hasilnya ke variabel multiply_result
}

Declaring variables and code blocks

Gunakan let untuk mendeklarasikan sebuah variabel (mendeklarasikan sebuah variabel = memberitahu Rust untuk membuat sebuah variabel).

fn main() {
    let my_number = 8;
    println!("Hello, number {}", my_number);
}

Variabel dimulai dan diakhiri di dalam sebuah code block {}. Pada contoh ini, my_number berakhir sebelum kita memanggil println!, karena ia berada di dalam code blocknya sendiri.

fn main() {
    {
        let my_number = 8; // my_number dimulai di sini.
                           // my_number berakhir di sini!
    }

    println!("Hello, number {}", my_number); // ⚠️ di bagian ini tidak ada my_number dan
                                             // println!() tidak bisa menemukannya
}

Anda bisa menggunakan code block untuk me-return sebuah value/nilai:

fn main() {
    let my_number = {
    let second_number = 8;
        second_number + 9 // Tidak ada semicolon, sehingga code block me-return 8 + 9.
                          // Ini bekerja mirip seperti sebuah function
    };

    println!("My number is: {}", my_number);
}

Jika kamu menambahkan sebuah semicolon ke dalam block, maka ia akan mengembalikan () (tidak ada apapun):

fn main() {
    let my_number = {
    let second_number = 8; // deklarasi second_number,
        second_number + 9; // tambah 9 ke second_number
                           // namun kita tidak mengambalikannya!
                           // second_number hangus dibagian ini
    };

    println!("My number is: {:?}", my_number); // my_number menghasilkan ()
}

Lantas, mengapa kita menuliskan {:?} dan bukan {}? Saatnya kita pelajari tentang itu.

Easy Rust

Printing 'hello, world!'

Declaring variables and code blocks