Learn Rust Coding · บทเรียน

ชนิดข้อมูลสเกลาร์

จำนวนเต็ม จำนวนทศนิยม ค่าแบบบูลีน และอักขระ

บทเรียน 2 จาก 413 ขั้นตอน

ชนิดข้อมูลสเกลาร์ เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

ชนิดข้อมูลสเกลาร์คืออะไร

ชนิดข้อมูลสเกลาร์ใช้แทนค่าหนึ่งค่า Rust มีชนิดข้อมูลสเกลาร์หลักสี่ชนิด:

จำนวนเต็ม
จำนวนทศนิยม
ค่าบูลีน
อักขระ

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

ชนิดข้อมูลจำนวนเต็ม

จำนวนเต็มมีทั้งชนิดมีเครื่องหมาย (i) และไม่มีเครื่องหมาย (u) โดยมีขนาดคงที่ ได้แก่ i8, i16, i32, i64, i128 และชนิด u ที่มีขนาดเดียวกัน

ชนิดจำนวนเต็มเริ่มต้นคือ i32

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

มีเครื่องหมายเทียบกับไม่มีเครื่องหมาย

จำนวนเต็มแบบมีเครื่องหมายสามารถเป็นค่าลบได้ ส่วนแบบไม่มีเครื่องหมายไม่สามารถเป็นค่าลบได้

i8 มีค่าตั้งแต่ -128 ถึง 127
u8 มีค่าตั้งแต่ 0 ถึง 255

เลือกใช้ชนิดไม่มีเครื่องหมายเมื่อค่าไม่สามารถเป็นลบได้ เช่น ค่าจำนวน

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

ค่าจำนวนเต็มแบบเขียนตรง

คุณสามารถเขียนจำนวนเต็มในฐานต่าง ๆ และใช้ขีดล่างเพื่อให้อ่านง่ายขึ้น

ฐานสิบ: 1_000_000
ฐานสิบหก: 0xff
ฐานแปด: 0o77
ฐานสอง: 0b1010

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

ชนิดข้อมูลจำนวนทศนิยม

Rust มีชนิดข้อมูลทศนิยมสองชนิด ได้แก่ f32 และ f64 โดยค่าเริ่มต้นคือ f64 เพราะให้ความแม่นยำสูงกว่า

จำนวนทศนิยมเป็นไปตามมาตรฐาน IEEE-754

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

การดำเนินการทางตัวเลข

Rust รองรับตัวดำเนินการทางคณิตศาสตร์ทั่วไป ได้แก่ +, -, *, / และ % (เศษเหลือ)

การหารจำนวนเต็มจะตัดส่วนทศนิยมเข้าหาศูนย์

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);
}

ชนิดข้อมูลบูลีน

ชนิดข้อมูล bool มีค่าได้เพียงสองค่า ได้แก่ true และ false

ค่าบูลีนเกิดจากการเปรียบเทียบและใช้ในเงื่อนไขของ if

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

ชนิดข้อมูลอักขระ

char แทนค่า Unicode สเกลาร์หนึ่งค่า และเขียนด้วยเครื่องหมายอัญประกาศเดี่ยว

char ของ Rust ใช้พื้นที่ 4 ไบต์ และเก็บค่าได้มากกว่า ASCII อย่างมาก รวมถึงอีโมจิและตัวอักษรที่มีเครื่องหมายกำกับเสียง

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

char กับ String

เครื่องหมายอัญประกาศเดี่ยวสร้าง char ส่วนเครื่องหมายอัญประกาศคู่สร้างสไลซ์สตริง (&str)

'a' เป็นอักขระหนึ่งตัว
"a" เป็นสตริงที่มีอักขระหนึ่งตัว

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

การแปลงชนิดข้อมูลด้วย as

Rust ไม่แปลงชนิดข้อมูลตัวเลขโดยอัตโนมัติ ให้ใช้คีย์เวิร์ด as เพื่อแปลงชนิดข้อมูลอย่างชัดเจน

โปรดระวัง การแปลงเป็นชนิดข้อมูลที่มีขนาดเล็กกว่าอาจทำให้ข้อมูลสูญหาย

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

การนำชนิดข้อมูลสเกลาร์มารวมกัน

โปรแกรมมักนำชนิดข้อมูลสเกลาร์มารวมกันอยู่เสมอ ในที่นี้เราจะผสมจำนวนเต็ม จำนวนทศนิยม และค่าบูลีนเพื่อใช้ตัดสินใจ

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);
}

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความรู้เกี่ยวกับค่าลิเทอรัลชนิดสเกลาร์ของ Rust

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

ชนิดข้อมูลสเกลาร์สี่ชนิดของ Rust:

จำนวนเต็ม — มีเครื่องหมาย (i32) และไม่มีเครื่องหมาย (u32) พร้อมขนาดที่หลากหลาย
จำนวนทศนิยม — f32 และ f64 โดยค่าเริ่มต้นคือ f64
bool — true หรือ false
char — ค่า Unicode หนึ่งค่าในเครื่องหมายอัญประกาศเดี่ยว

ใช้ as เพื่อแปลงชนิดข้อมูลตัวเลขอย่างชัดเจน

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);
}

เริ่มต้นได้ฟรี

เรียนรู้ Rust ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 39
บทเรียน: 144

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “ชนิดข้อมูลสเกลาร์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ชนิดข้อมูลสเกลาร์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ชนิดข้อมูลสเกลาร์”

จำนวนเต็ม จำนวนทศนิยม ค่าแบบบูลีน และอักขระ คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “ชนิดข้อมูลสเกลาร์” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn Rust Coding