Struktur Pengontrol Karat dan Cara Menggunakannya

Struktur kontrol adalah konstruksi pemrograman yang memungkinkan Anda untuk mengontrol aliran eksekusi dalam program Anda. Struktur kontrol memungkinkan Anda menentukan instruksi untuk dijalankan hanya jika kondisi tertentu terpenuhi.

Struktur kontrol Rust sangat penting untuk mengelola alur program, memungkinkan eksekusi kode yang efisien sambil menyederhanakan tugas kompleks menjadi komponen yang lebih kecil dan dapat digunakan kembali.

Pernyataan Bersyarat Karat

Pernyataan bersyarat adalah konstruksi yang memungkinkan Anda menjalankan kode berdasarkan kondisi. Pernyataan bersyarat sangat berguna untuk pengambilan keputusan karena eksekusi program bergantung pada apakah kondisi tersebut dievaluasi BENAR atau PALSU. Karat menyediakan jika, kalau tidak, Dan cocok pernyataan untuk pengambilan keputusan.

Dalam program Rust, file jika pernyataan menguji apakah suatu kondisi tertentu bernilai benar. Jika ya, program menjalankan blok kode terkait. Jika kondisi dievaluasi salah, program melewatkan blok kode itu dan beralih ke pernyataan berikutnya atau menjalankan

kalau tidak blok pernyataan jika ada.

Itu cocok pernyataan adalah konstruksi aliran kontrol yang kuat yang memungkinkan program untuk mencocokkan nilai terhadap serangkaian pola dan mengeksekusi kode berdasarkan pola yang cocok.

Pernyataan jika Rust

Anda akan menyatakan jika pernyataan dalam program Rust Anda dengan jika kata kunci diikuti dengan kondisi:

jika kondisi {
// kode yang akan dijalankan jika kondisi benar
}

Berikut adalah contoh bagaimana Anda dapat menggunakan pernyataan if dalam program Rust Anda:

fnutama() {
membiarkan x = 15;
jika x> 10 {
cetak!("x lebih besar dari 10");
 }
}

Itu X variabel menyimpan bilangan bulat 32-bit, dan pernyataan if memeriksa apakah nilai x lebih besar dari sepuluh sebelum menjalankan blok kode yang mencetaknya.

Pernyataan lain dari Rust

Anda akan menggunakan kalau tidak kata kunci untuk mengeksekusi blok kode saat Anda mengantisipasinya jika pernyataan akan dievaluasi sebagai salah.

jika kondisi {
// kode yang akan dijalankan jika kondisi benar
} kalau tidak {
// kode yang akan dijalankan jika kondisi salah
}

Berikut adalah contoh di mana X tidak lebih besar dari 10, itu jika pernyataan mengevaluasi PALSU, dan sebuah kalau tidak pernyataan berjalan.

fnutama(){
membiarkan x = 5;
jika x> 10 {
cetak!("x lebih besar dari 10");
 } kalau tidak {
cetak!("x tidak lebih besar dari 10");
 }
}

Sejak X adalah 5 dan 5 tidak lebih besar dari 10, program melompati jika memblokir dan mengeksekusi kalau tidak memblokir.

Pernyataan pertandingan Rust

Anda akan menggunakan cocok kata kunci untuk pengambilan keputusan yang kompleks untuk memeriksa rangkaian pola dan mengeksekusi kode berdasarkan pencocokan pola. Pernyataan pertandingan mirip dengan beralih pernyataan dalam C #, Go, dan C++.

Berikut struktur dari pernyataan kecocokan Rust:

cocok nilai {
 pola1 => {
// kode yang akan dijalankan jika nilainya cocok dengan pattern1
 },
 pola2 => {
// kode yang akan dijalankan jika nilai cocok dengan pola2
 },
// dll.
}

Inilah cara Anda dapat menggunakan pernyataan kecocokan dalam program Anda:

membiarkan nilai = 'B';
cocok nilai {
'A' => cetak!("Kerja bagus!"),
'B' => cetak!("Kerja bagus."),
'C' => cetak!("Kamu bisa melakukan yang lebih baik."),
 _ => cetak!("Itu bukan nilai yang valid."),
}

Itu nilai variabel adalah karakter, dan cocok pernyataan memeriksa karakter mana yang mengevaluasi nilai variabel kelas sebelum mengeksekusi kode setelah operator =>. Anda dapat menggunakan pola garis bawah (_) untuk mencocokkan nilai yang tidak cocok dengan pola lainnya (pola default).

Loop di Rust

Loop adalah konstruksi dasar yang digunakan untuk tugas berulang seperti pengikisan web dan tindakan otomatis lainnya. Rust menyediakan berbagai jenis loop, termasuk ketika loop, untuk loop, dan lingkaran lingkaran.

Rust sementara Loops

While loop mengulang blok kode selama kondisi yang ditentukan bernilai true. Sebelum menentukan kondisi, Anda akan menentukan while loop di Rust dengan ketika kata kunci.

ketika kondisi {
// kode untuk dieksekusi
}

Kondisinya harus berupa ekspresi boolean yang menentukan kelanjutan perulangan. Ketika kondisi bernilai salah, loop keluar.

Berikut adalah contoh dari Rust while loop yang mencetak angka dari satu sampai lima.

fnutama() {
membiarkanmut saya = 1;
ketika saya <= 5 {
cetak!("{}", Saya);
 saya += 1;
 }
}

Perulangan while di utama fungsi melintasi angka satu sampai lima sambil menambah Saya variabel satu sampai Saya variabel lebih besar dari lima, di mana loop berakhir.

Lingkaran Lingkaran

Itu lingkaran kata kunci membuat loop tak terbatas sampai Anda menyatakan keluar dengan merusak kata kunci.

lingkaran {
// kode untuk dieksekusi
jika kondisi {
merusak;
 }
}

Kode di lingkaran blok akan terus dijalankan sampai loop menemukan a merusak kata kunci.

Berikut adalah contoh penggunaan the lingkaran loop untuk mencetak angka satu sampai lima sebelum menentukan merusak kata kunci untuk keluar.

fnutama() {
membiarkanmut saya = 1;
lingkaran {
cetak!("{}", Saya);
 saya += 1;
jika saya > 5 {
merusak;
 }
 }
}

Itu utama fungsi mengeksekusi loop, dan jika pernyataan menambah Saya variabel. Itu jika pernyataan menentukan penghentian loop ketika Saya variabel melebihi lima.

Karat untuk Loop

Di Rust, for loop beralih melalui rentang atau kumpulan nilai. Anda akan menggunakan untuk kata kunci untuk memulai perulangan for, sebelum menentukan rentang atau kumpulan yang digunakannya.

untuk variabel di dalam jangkauan {
// kode untuk dieksekusi
}

Itu jangkauan adalah ekspresi yang mengevaluasi urutan nilai, dan variabel adalah variabel yang mengambil setiap nilai dalam urutan secara bergantian. Blok kode akan dieksekusi sekali untuk setiap nilai dalam urutan.

Berikut adalah contoh perulangan for yang mencetak nilai mulai dari satu hingga sepuluh.

fnutama() {
untuk Saya di dalam1..=10 {
cetak!("{}", Saya);
 }
}

Loop berulang melalui nilai dari 1 hingga 10. Pada setiap iterasi, variabel (i) memegang nilai berikutnya, yaitu cetak! makro kemudian mencetak.

Anda dapat menggunakan melanjutkan kata kunci untuk melewati nilai dalam for-loop. Inilah cara Anda melewatkan angka genap saat mengoperasikan rentang:

fnutama() {
untuk nomor di dalam1..=10 {
jika jumlah % 2 == 0 {
melanjutkan; // lewati angka genap
 }
cetak!("{}", bil); // cetak angka ganjil
 }
}

Itu jika pernyataan menggunakan melanjutkan kata kunci untuk menentukan bahwa loop harus melewati angka yang habis dibagi dua.

Selain itu, Anda dapat keluar dari for-loop dengan merusak kata kunci. Loop berakhir saat bertemu dengan merusak kata kunci.

fnutama() {
untuk nomor di dalam1..=10 {
jika jumlah == 5 {
merusak; // keluar dari loop ketika angka sama dengan 5
 }
cetak!("{}", bil); // cetak angka 1 sampai 4
 }
}

Itu jika pernyataan menetapkan bahwa loop harus berakhir ketika Saya variabel sama dengan lima.

Gunakan Struktur Kontrol Rust Dengan Tipe Data untuk Menguasai Bahasa

Rust menyediakan struktur kontrol fleksibel ini untuk operasi pada tipe data bawaan dan khusus. Anda dapat menggunakan struktur kontrol ini untuk beroperasi pada struktur data gabungan dan komposit seperti array, vektor, struct, dan enum.

Rust juga menyediakan struct. Struct adalah struktur data yang mengelompokkan nilai terkait ke dalam satu objek. Mereka mirip dengan kelas dalam bahasa berorientasi objek, dan Anda bahkan dapat menentukan metode pada mereka.