Belajar Pengaturcaraan Rust · Pelajaran

Fungsi dan Aliran Kawalan

Pelajari cara mentakrifkan fungsi serta menggunakan ungkapan `if`/`else`, `loop`, `while` dan `for` untuk mengawal aliran pelaksanaan program.

Pelajaran 3 daripada 311 langkah

Fungsi dan Aliran Kawalan ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah Fungsi?

Fungsi ialah blok kod bernama yang melaksanakan tugas tertentu. Fungsi penting untuk menyusun kod anda dan menjadikannya boleh digunakan semula.

Kebolehgunaan Semula Kod: Tulis sesuatu logik sekali dan gunakannya berulang kali.
Modulariti: Pecahkan masalah kompleks kepada bahagian yang lebih kecil dan mudah diurus.
Kebolehbacaan: Berikan nama yang bermakna kepada blok kod untuk memudahkan pemahaman.

Fungsi Rust Pertama Anda

Dalam Rust, anda mentakrifkan fungsi menggunakan kata kunci fn. Fungsi main ialah titik permulaan bagi setiap program Rust.

Begini cara mengisytiharkan dan memanggil fungsi mudah:

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

fn main() {
    say_hello(); // Call the function
    println!("Back in main.");
}

Fungsi dengan Parameter

Fungsi boleh menerima nilai input yang dipanggil parameter. Parameter membolehkan fungsi anda beroperasi pada data yang berbeza setiap kali ia dipanggil.

Parameter ditakrifkan dengan nama dan jenis, yang dipisahkan oleh tanda titik bertindih.

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
    greet("Bob");
}

Fungsi dengan Nilai Pulangan

Fungsi juga boleh mengembalikan nilai kepada pemanggil. Anda menetapkan jenis pulangan selepas anak panah (->).

Ungkapan terakhir dalam badan fungsi dikembalikan secara tersirat. Tiada tanda koma bernoktah diperlukan untuk ungkapan pulangan!

fn add_numbers(x: i32, y: i32) -> i32 {
    x + y // No semicolon: this expression is returned
}

fn main() {
    let sum = add_numbers(5, 7);
    println!("The sum is: {}", sum);
}

Membuat Keputusan: `if`/`else`

Ungkapan if membolehkan program anda melaksanakan blok kod yang berbeza berdasarkan suatu syarat. Syarat mestilah sentiasa berupa bool (true/false).

Gunakan if untuk syarat pertama.
Gunakan else if untuk syarat tambahan.
Gunakan else sebagai pilihan sandaran jika tiada syarat lain dipenuhi.

if dalam Rust ialah ungkapan, jadi ia boleh mengembalikan nilai!

Ungkapan If-Else dalam Tindakan

Begini cara anda boleh menggunakan if dan else untuk menetapkan nilai berdasarkan suatu syarat. Perhatikan bahawa ia berfungsi seperti operator ternari dalam bahasa lain.

fn main() {
    let number = 7;

    let message = if number < 10 {
        "Small number"
    } else {
        "Large number"
    };

    println!("The number is: {}", message);

    let other_num = 15;
    if other_num % 2 == 0 {
        println!("{} is even", other_num);
    } else {
        println!("{} is odd", other_num);
    }
}

Mengulangi Kod: `loop`

Kata kunci loop mencipta gelung tanpa henti. Ini berguna apabila anda perlu mengulangi sesuatu tindakan sehingga anda memutuskan untuk menghentikannya secara jelas.

Gunakan break untuk keluar daripada gelung. Anda juga boleh mengembalikan nilai daripada ungkapan loop menggunakan break.

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // Break and return a value
        }
    };

    println!("The result is {}", result);
}

Pengulangan Bersyarat: `while`

Gelung while melaksanakan satu blok kod selagi syarat yang ditetapkan kekal benar. Gelung ini sesuai apabila anda tidak mengetahui dengan tepat berapa kali pengulangan diperlukan.

fn main() {
    let mut count = 3;

    while count != 0 {
        println!("{}!", count);
        count -= 1;
    }

    println!("LIFTOFF!!!");
}

Melakukan Lelaran dengan Gelung `for`

Gelung for digunakan untuk melakukan lelaran terhadap koleksi item atau julat nombor. Gelung ini ialah binaan gelung yang paling biasa dalam Rust, menjadikan kod anda selamat dan ringkas.

Gelung ini sering digunakan dengan julat (contohnya, 1..4 untuk 1, 2, 3 atau 1..=4 untuk 1, 2, 3, 4).
Gelung ini berfungsi dengan apa-apa jenis yang melaksanakan trait Iterator.

fn main() {
    // Loop through a range
    for number in 1..4 { // 1, 2, 3
        println!("Number: {}", number);
    }

    // Loop through an array
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("The value is: {}", element);
    }
}

Cabaran Aliran Kawalan

Teliti kod Rust berikut. Apakah nilai akhir result?

fn calculate_value(input: i32) -> i32 {
    if input > 10 {
        input * 2
    } else if input == 5 {
        input + 5
    } else {
        input
    }
}

fn main() {
    let result = calculate_value(5);
    // What is result?
}

Jawab dalam pelajaran interaktif

Ulang Kaji Fungsi dan Aliran Kawalan

Anda telah menguasai asas untuk membina program dinamik!

Fungsi: Susun dan gunakan semula kod menggunakan fn, parameter dan nilai pulangan.
if/else: Buat keputusan dan laksanakan kod secara bersyarat. Ingat bahawa ia ialah ungkapan!
loop: Cipta gelung tanpa henti, keluar dengan break dan kembalikan nilai.
while: Ulangi gelung selagi syarat adalah benar.
for: Lakukan lelaran dengan selamat terhadap koleksi dan julat.

Alat ini penting untuk menulis program Rust yang tersusun dan cekap!

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 144

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Fungsi dan Aliran Kawalan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Fungsi dan Aliran Kawalan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Fungsi dan Aliran Kawalan”?

Pelajari cara mentakrifkan fungsi serta menggunakan ungkapan `if`/`else`, `loop`, `while` dan `for` untuk mengawal aliran pelaksanaan program. Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.

Berapa lamakah pelajaran “Fungsi dan Aliran Kawalan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Pemboleh Ubah, Kebolehubahan dan Pembayangan
Jenis Data Primitif dan Operator
Fungsi dan Aliran Kawalan

← Kembali ke Belajar Pengaturcaraan Rust