Learn Rust Coding · Pelajaran

Tipe Skalar

Bilangan bulat, pecahan, bool, char

Tipe Skalar adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 2 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 Skalar?

Tipe skalar mewakili satu nilai. Rust memiliki empat tipe skalar utama:

Bilangan bulat
Bilangan pecahan
Boolean
Karakter

fn main() {
    let i = 10;       // integer
    let f = 2.5;      // float
    let b = true;     // bool
    let c = 'R';      // char
    println!("{} {} {} {}", i, f, b, c);
}

Tipe Bilangan Bulat

Bilangan bulat tersedia dalam varian bertanda (i) dan tak bertanda (u) dengan ukuran tetap: i8, i16, i32, i64, i128, dan padanan yang sama untuk u.

Tipe bilangan bulat bawaan adalah i32.

fn main() {
    let small: i8 = -120;
    let big: u64 = 18_000_000_000;
    println!("{} {}", small, big);
}

Bertanda vs Tak Bertanda

Bilangan bulat bertanda dapat bernilai negatif; bilangan bulat tak bertanda tidak dapat.

i8 memiliki rentang dari -128 hingga 127.
u8 memiliki rentang dari 0 hingga 255.

Pilih tipe tak bertanda jika suatu nilai tidak mungkin negatif, seperti jumlah.

fn main() {
    let temperature: i32 = -15;
    let people: u32 = 250;
    println!("temp {} people {}", temperature, people);
}

Literal Bilangan Bulat

Anda dapat menulis bilangan bulat dalam berbagai basis dan menggunakan garis bawah agar lebih mudah dibaca.

Desimal: 1_000_000
Heksadesimal: 0xff
Oktal: 0o77
Biner: 0b1010

fn main() {
    let dec = 1_000;
    let hex = 0xff;
    let bin = 0b1010;
    println!("{} {} {}", dec, hex, bin);
}

Tipe Bilangan Pecahan

Rust memiliki dua tipe float: f32 dan f64. Nilai default-nya adalah f64 karena menawarkan presisi yang lebih tinggi.

Float mengikuti standar IEEE-754.

fn main() {
    let pi: f64 = 3.141592;
    let e: f32 = 2.718;
    println!("pi {} e {}", pi, e);
}

Operasi Numerik

Rust mendukung operator matematika umum: +, -, *, /, dan % (sisa bagi).

Pembagian bilangan bulat dipotong mendekati nol.

fn main() {
    let sum = 5 + 10;
    let quotient = 7 / 2;     // 3 (integer)
    let remainder = 7 % 2;    // 1
    let float_div = 7.0 / 2.0; // 3.5
    println!("{} {} {} {}", sum, quotient, remainder, float_div);
}

Tipe Boolean

Tipe bool memiliki tepat dua nilai: true dan false.

Boolean dihasilkan oleh perbandingan dan digunakan dalam kondisi if.

fn main() {
    let is_active = true;
    let is_bigger = 10 > 3;
    println!("{} {}", is_active, is_bigger);
}

Tipe Karakter

char merepresentasikan satu nilai skalar Unicode dan ditulis dengan tanda kutip tunggal.

char Rust berukuran 4 byte dan dapat memuat jauh lebih banyak daripada ASCII — termasuk emoji dan huruf beraksen.

fn main() {
    let letter = 'A';
    let symbol = '@';
    let heart = '\u{2764}';
    println!("{} {} {}", letter, symbol, heart);
}

char vs String

Tanda kutip tunggal menghasilkan char; tanda kutip ganda menghasilkan irisan string (&str).

'a' adalah satu karakter.
"a" adalah string yang terdiri dari satu karakter.

fn main() {
    let c = 'x';
    let s = "x";
    println!("char {} string {}", c, s);
}

Konversi Tipe dengan as

Rust tidak mengonversi tipe numerik secara otomatis. Gunakan kata kunci as untuk melakukan cast secara eksplisit.

Berhati-hatilah: melakukan cast ke tipe yang lebih kecil dapat menyebabkan data hilang.

fn main() {
    let x: i32 = 65;
    let y: f64 = x as f64;
    let c = x as u8 as char;
    println!("{} {} {}", x, y, c);
}

Menggabungkan Tipe Skalar

Program terus-menerus menggabungkan tipe skalar. Di sini kita mencampurkan bilangan bulat, float, dan boolean untuk membuat keputusan.

fn main() {
    let price: f64 = 19.99;
    let quantity: u32 = 3;
    let total = price * quantity as f64;
    let is_expensive = total > 50.0;
    println!("total {} expensive {}", total, is_expensive);
}

Pemeriksaan Singkat

Uji pengetahuan Anda tentang literal skalar Rust.

Ringkasan

Empat tipe skalar Rust:

Bilangan bulat — bertanda (i32) dan tidak bertanda (u32), dengan berbagai ukuran.
Float — f32 dan f64, dengan default f64.
bool — true atau false.
char — satu nilai Unicode dalam tanda kutip tunggal.

Gunakan as untuk konversi numerik secara eksplisit.

fn main() {
    let count: u32 = 42;
    let ratio: f64 = count as f64 / 7.0;
    let ok: bool = ratio > 5.0;
    let grade: char = 'B';
    println!("{} {} {} {}", count, ratio, ok, grade);
}

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Tipe Skalar” gratis?

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

Bilangan bulat, pecahan, bool, char 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 2 dari 4.

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