Belajar Pengaturcaraan Rust · Pelajaran

Jenis Gubahan

Tuple dan tatasusunan

Pelajaran 3 daripada 413 langkah

Jenis Gubahan ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. 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 4 pelajaran.

Apakah Jenis Kompaun?

Jenis kompaun mengumpulkan beberapa nilai menjadi satu. Rust mempunyai dua jenis kompaun primitif:

Tuple — kumpulan bersaiz tetap yang mungkin terdiri daripada jenis berbeza.
Tatasusunan — kumpulan bersaiz tetap yang terdiri daripada jenis yang sama.

fn main() {
    let tup = (1, 2.0, 'c');
    let arr = [10, 20, 30];
    println!("{} {}", tup.0, arr[0]);
}

Mencipta Tuple

Satu tuple menggabungkan nilai di dalam tanda kurung. Setiap elemen boleh mempunyai jenis yang berbeza.

Jenis tuple ialah gabungan jenis elemennya.

fn main() {
    let person: (&str, u32, f64) = ("Alice", 30, 5.6);
    println!("{} is {} years old", person.0, person.1);
}

Mengakses Elemen Tuple

Akses elemen tuple menggunakan indeks dengan noktah, bermula pada 0.

tup.0 ialah elemen pertama.
tup.1 ialah elemen kedua.

fn main() {
    let point = (3, 7);
    let x = point.0;
    let y = point.1;
    println!("x={} y={}", x, y);
}

Memecahkan Tuple

Anda boleh memecahkan tuple kepada pemboleh ubah berasingan dalam satu langkah. Ini dipanggil pemecahan struktur.

fn main() {
    let coords = (1.5, 2.5, 3.5);
    let (a, b, c) = coords;
    println!("{} {} {}", a, b, c);
}

Jenis Unit

Tuple kosong () dipanggil jenis unit. Ia mewakili 'tiada nilai yang bermakna'.

Fungsi yang tidak memulangkan apa-apa sebenarnya memulangkan ().

fn main() {
    let nothing = ();
    println!("unit value is {:?}", nothing);
}

Mencipta Tatasusunan

Satu tatasusunan menyimpan berbilang nilai daripada jenis yang sama dengan panjang tetap, dan ditulis dalam kurungan siku.

Jenisnya ialah [type; length].

fn main() {
    let days: [&str; 3] = ["Mon", "Tue", "Wed"];
    let numbers = [1, 2, 3, 4, 5];
    println!("{} {}", days[1], numbers[4]);
}

Pengindeksan Tatasusunan

Akses elemen tatasusunan dengan kurungan siku dan indeks bermula daripada sifar.

Mengakses indeks di luar sempadan menyebabkan panik semasa masa jalan — Rust menyemak sempadan demi keselamatan.

fn main() {
    let colors = ["red", "green", "blue"];
    println!("first {}", colors[0]);
    println!("last {}", colors[2]);
}

Nilai Awal Berulang

Untuk mengisi tatasusunan dengan nilai yang sama, gunakan [value; count].

Ini mencipta tatasusunan yang mempunyai count elemen, semuanya sama dengan value.

fn main() {
    let zeros = [0; 5];
    println!("{:?}", zeros);
    println!("length is {}", zeros.len());
}

Panjang Tatasusunan

Kaedah .len() memulangkan bilangan elemen dalam tatasusunan. Panjang ditetapkan semasa penyusunan.

Jika anda memerlukan senarai yang boleh berkembang, gunakan Vec.

fn main() {
    let scores = [88, 92, 75, 100];
    println!("there are {} scores", scores.len());
}

Mengulangi Tatasusunan

Gunakan gelung for untuk melawati setiap elemen tatasusunan mengikut turutan.

fn main() {
    let nums = [2, 4, 6, 8];
    let mut sum = 0;
    for n in nums {
        sum += n;
    }
    println!("sum = {}", sum);
}

Tuple berbanding Tatasusunan

Bila hendak menggunakan setiap satu:

Gunakan tuple untuk kumpulan tetap yang terdiri daripada jenis berbeza, seperti koordinat dan label.
Gunakan tatasusunan untuk kumpulan tetap yang terdiri daripada jenis yang sama, seperti senarai skor.

fn main() {
    let record = ("Bob", [90, 85, 95]);
    println!("{} first score {}", record.0, (record.1)[0]);
}

Semakan Pantas

Pilih pernyataan yang betul tentang jenis kompaun Rust.

Jawab dalam pelajaran interaktif

Ulang Kaji

Jenis kompaun Rust:

Tuple — (a, b, c), jenis bercampur, diakses melalui .0, dan boleh dipecahkan strukturnya.
Tatasusunan — [a, b, c], jenis yang sama, panjang tetap, dan diakses melalui [index].
() ialah jenis unit.

fn main() {
    let (name, scores) = ("Cara", [70, 80, 90]);
    let mut total = 0;
    for s in scores {
        total += s;
    }
    println!("{} total {}", name, total);
}

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 “Jenis Gubahan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Jenis Gubahan”, 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 4 pelajaran.

Apakah yang akan saya pelajari dalam “Jenis Gubahan”?

Tuple dan tatasusunan 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 4.

Berapa lamakah pelajaran “Jenis Gubahan” 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

← Kembali ke Belajar Pengaturcaraan Rust