Learn Rust Coding · Pelajaran

Tipe Majemuk

Tuple dan array

Tipe Majemuk adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 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.

Apa Itu Tipe Kompon?

Tipe kompon mengelompokkan beberapa nilai menjadi satu. Rust memiliki dua tipe kompon primitif:

Tuple — kelompok berukuran tetap yang dapat memiliki tipe berbeda.
Array — kelompok berukuran tetap yang memiliki tipe sama.

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

Membuat Tuple

Sebuah tuple menggabungkan nilai di dalam tanda kurung. Setiap elemennya dapat memiliki tipe berbeda.

Tipe tuple merupakan gabungan dari tipe-tipe 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 berdasarkan indeks menggunakan titik, dimulai dari 0.

tup.0 adalah elemen pertama.
tup.1 adalah elemen kedua.

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

Destrukturisasi Tuple

Anda dapat memecah tuple menjadi beberapa variabel dalam satu langkah. Ini disebut destrukturisasi.

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

Tipe Unit

Tuple kosong () disebut tipe unit. Tipe ini merepresentasikan "tidak ada nilai yang bermakna".

Fungsi yang tidak mengembalikan apa pun sebenarnya mengembalikan ().

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

Membuat Array

Sebuah array menyimpan beberapa nilai dengan tipe yang sama dan panjang tetap, yang ditulis di dalam tanda kurung siku.

Tipe array adalah [type; length].

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

Pengindeksan Array

Akses elemen array menggunakan tanda kurung siku dan indeks yang dimulai dari nol.

Mengakses indeks di luar batas menyebabkan kepanikan saat runtime — Rust memeriksa batas demi keamanan.

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

Nilai Awal Berulang

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

Ini membuat array berisi count elemen yang semuanya sama dengan value.

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

Panjang Array

Metode .len() mengembalikan jumlah elemen dalam array. Panjangnya ditetapkan saat kompilasi.

Jika Anda memerlukan daftar yang dapat bertambah, gunakan Vec.

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

Melakukan Iterasi pada Array

Gunakan perulangan for untuk mengunjungi setiap elemen array secara berurutan.

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

Tuple vs Array

Kapan menggunakan masing-masing tipe:

Gunakan tuple untuk kelompok tetap dengan tipe yang berbeda, seperti koordinat dan label.
Gunakan array untuk kelompok tetap dengan tipe yang sama, seperti daftar skor.

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

Pemeriksaan Singkat

Pilih pernyataan yang benar tentang tipe kompon Rust.

Ringkasan

Tipe kompon Rust:

Tuple — (a, b, c), tipe campuran, diakses dengan .0, dan dapat didestrukturisasi.
Array — [a, b, c], tipe sama, panjang tetap, diakses dengan [index].
() adalah tipe unit.

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

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Tipe Majemuk” gratis?

Ya — teks lengkap “Tipe Majemuk” 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 “Tipe Majemuk”?

Tuple dan array 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 3 dari 4.

Berapa lama pelajaran “Tipe Majemuk” 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