Learn Rust Coding · Pelajaran

Mendefinisikan Fungsi

Parameter dan nilai kembalian

Pelajaran 1 dari 413 langkah

Mendefinisikan Fungsi adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Mendeklarasikan Fungsi

Anda mendefinisikan fungsi dengan kata kunci fn, nama, tanda kurung, dan badan di dalam kurung kurawal.

Menurut konvensi, Rust menggunakan snake_case untuk nama fungsi.

fn main() {
    greet();
}

fn greet() {
    println!("Hello from a function!");
}

Fungsi main

Setiap program Rust yang dapat dijalankan dimulai dari fn main(). Fungsi ini adalah titik masuk yang pertama kali dipanggil oleh runtime.

fn main() {
    println!("Program starts here");
}

Parameter

Fungsi dapat menerima parameter. Setiap parameter harus menyatakan tipenya setelah tanda titik dua.

fn main() {
    print_number(7);
}

fn print_number(x: i32) {
    println!("The number is {}", x);
}

Beberapa Parameter

Pisahkan beberapa parameter dengan koma. Masing-masing memerlukan anotasi tipe sendiri.

fn main() {
    describe("Rust", 2010);
}

fn describe(name: &str, year: i32) {
    println!("{} was released in {}", name, year);
}

Nilai Kembalian

Deklarasikan tipe kembalian setelah panah ->. Fungsi tersebut mengembalikan nilai dengan tipe itu.

Ekspresi terakhir, tanpa titik koma, menjadi nilai kembalian.

fn main() {
    let result = square(5);
    println!("square is {}", result);
}

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

Kata Kunci return

Anda juga dapat mengembalikan nilai lebih awal dengan kata kunci return. Ini berguna untuk kondisi penjaga.

fn main() {
    println!("{}", abs_value(-8));
}

fn abs_value(n: i32) -> i32 {
    if n < 0 {
        return -n;
    }
    n
}

Menggabungkan Parameter dan Nilai Kembalian

Fungsi biasanya menerima input dan menghasilkan output. Di sini kita menjumlahkan dua angka.

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

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

Fungsi Memanggil Fungsi

Fungsi dapat memanggil fungsi lain, sehingga Anda dapat membangun perilaku yang lebih besar dari bagian-bagian kecil yang dapat digunakan kembali.

fn main() {
    println!("{}", double_then_add(5));
}

fn double(n: i32) -> i32 { n * 2 }

fn double_then_add(n: i32) -> i32 {
    double(n) + 1
}

Mengembalikan Tipe Lain

Fungsi dapat mengembalikan tipe apa pun: string, boolean, tuple, dan lainnya.

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

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

Fungsi Tanpa Nilai Kembalian

Fungsi tanpa panah mengembalikan tipe unit (). Fungsi tersebut bekerja melalui efek samping seperti mencetak.

fn main() {
    log_message("saving file");
}

fn log_message(msg: &str) {
    println!("[LOG] {}", msg);
}

Urutan Tidak Berpengaruh

Berbeda dari beberapa bahasa lain, di Rust Anda dapat memanggil fungsi yang didefinisikan setelahnya di dalam file. Kompilator melihat semua fungsi sebelum menjalankan program.

fn main() {
    println!("{}", helper());
}

fn helper() -> i32 {
    99
}

Pemeriksaan Singkat

Ingat kembali cara fungsi Rust mengembalikan nilai.

Jawab di pelajaran interaktif

Ringkasan

Fungsi dalam Rust:

Didefinisikan dengan fn name(params) -> ReturnType { ... }.
Parameter memerlukan tipe eksplisit.
Ekspresi terakhir tanpa titik koma adalah nilai kembalian, atau gunakan return untuk mengembalikan nilai lebih awal.
Tidak adanya tipe kembalian berarti fungsi mengembalikan ().

fn main() {
    let area = rectangle_area(4, 6);
    println!("area {}", area);
}

fn rectangle_area(w: i32, h: i32) -> i32 {
    w * h
}

Gratis untuk memulai

Belajar Rust dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 39
Pelajaran: 144

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mendefinisikan Fungsi” gratis?

Ya — teks lengkap “Mendefinisikan Fungsi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mendefinisikan Fungsi”?

Parameter dan nilai kembalian Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Mendefinisikan Fungsi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding