Learn Rust Coding · บทเรียน

ชนิดข้อมูลพื้นฐานและตัวดำเนินการ

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

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

บทนำสู่ชนิดข้อมูลพื้นฐาน

ยินดีต้อนรับสู่บทเรียนพื้นฐานของ Rust! วันนี้เราจะสำรวจชนิดข้อมูลพื้นฐานและตัวดำเนินการเบื้องต้น

ชนิดข้อมูลพื้นฐานเป็นองค์ประกอบสำคัญที่สุดสำหรับจัดเก็บข้อมูล ใช้แทนค่าที่เรียบง่าย เช่น ตัวเลข ค่าจริง/เท็จ หรืออักขระเดี่ยว

การทำความเข้าใจชนิดข้อมูลเหล่านี้มีความสำคัญอย่างยิ่งต่อการเขียนโค้ด Rust ที่มีประสิทธิภาพและถูกต้อง

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

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

จำนวนเต็มมีเครื่องหมาย (คำนำหน้า i): เก็บได้ทั้งจำนวนบวกและจำนวนลบ (เช่น i8, i32, i64)
จำนวนเต็มไม่มีเครื่องหมาย (คำนำหน้า u): เก็บได้เฉพาะจำนวนบวกหรือศูนย์ (เช่น u8, u32, u64)

ตัวเลขระบุจำนวนบิตที่ใช้จัดเก็บ เช่น i32 คือจำนวนเต็มมีเครื่องหมายขนาด 32 บิต ส่วน isize และ usize เป็นจำนวนเต็มขนาดเท่าตัวชี้ ซึ่งปรับตามสถาปัตยกรรมของระบบ (32 บิตหรือ 64 บิต)

ประกาศตัวแปรจำนวนเต็ม

มาดูวิธีประกาศและใช้งานชนิดข้อมูลจำนวนเต็มใน Rust กัน สังเกตว่าเราสามารถเพิ่มคำกำกับชนิดข้อมูลอย่างชัดเจน หรือให้ Rust อนุมานชนิดข้อมูลเองได้

ลองเรียกใช้ตัวอย่างนี้

fn main() {
  let signed_val: i32 = -100;
  let unsigned_val: u32 = 250;
  let inferred_int = 500; // Rust infers i32 by default
  let big_unsigned: u64 = 1_000_000_000;

  println!("Signed: {}", signed_val);
  println!("Unsigned: {}", unsigned_val);
  println!("Inferred: {}", inferred_int);
  println!("Big Unsigned: {}", big_unsigned);
}

จำนวนจุดลอยตัว

สำหรับตัวเลขที่มีจุดทศนิยม Rust มีชนิดข้อมูลเลขทศนิยมให้ใช้:

f32: เลขทศนิยมความแม่นยำเดี่ยว (32 บิต)
f64: เลขทศนิยมความแม่นยำสองเท่า (64 บิต) ซึ่งเป็นชนิดข้อมูลเลขทศนิยมเริ่มต้นใน Rust

โดยทั่วไป f64 เป็นตัวเลือกที่เหมาะสมกว่าสำหรับแอปพลิเคชันส่วนใหญ่ เนื่องจากมีความแม่นยำสูงกว่า เว้นแต่คุณจะมีข้อจำกัดเฉพาะด้านหน่วยความจำหรือประสิทธิภาพ

การประกาศตัวแปรเลขทศนิยม

ต่อไปนี้คือวิธีประกาศตัวเลขทศนิยม โปรดสังเกตว่า Rust จะใช้ f64 เป็นค่าเริ่มต้น หากคุณไม่ระบุชนิดข้อมูล

ลองเรียกใช้ตัวอย่างนี้:

fn main() {
  let pi: f32 = 3.14159;
  let e = 2.718281828; // Inferred as f64
  let temperature: f64 = 98.6;

  println!("Pi (f32): {}", pi);
  println!("E (f64 inferred): {}", e);
  println!("Temperature (f64): {}", temperature);
}

ค่าบูลีนและอักขระ

นอกจากตัวเลขแล้ว Rust ยังมีชนิดข้อมูลสำหรับค่าทางตรรกะและตัวอักษรเดี่ยว:

bool: แทนค่าความจริง ซึ่งมีค่าเป็น true หรือ false
char: แทนค่าระดับสเกลาร์ของ Unicode หนึ่งค่า ซึ่งหมายความว่า char ไม่ได้จำกัดอยู่เพียง ASCII เท่านั้น แต่สามารถเป็นตัวอักษร อีโมจิ หรือสัญลักษณ์ใดก็ได้

char ใช้หน่วยความจำ 4 ไบต์ จึงสามารถจัดเก็บอักขระ Unicode ได้ทุกตัว

ค่าบูลและอักขระในการใช้งานจริง

ลองประกาศตัวแปรค่าบูลีนและอักขระกัน โปรดสังเกตเครื่องหมายอัญประกาศเดี่ยวสำหรับค่า char

ลองเรียกใช้ตัวอย่างนี้:

fn main() {
  let is_rust_fun: bool = true;
  let has_errors = false; // Inferred as bool
  let first_letter: char = 'R';
  let emoji_char: char = '🚀';

  println!("Is Rust fun? {}", is_rust_fun);
  println!("Has errors? {}", has_errors);
  println!("First letter: {}", first_letter);
  println!("Emoji: {}", emoji_char);
}

ตัวดำเนินการเลขคณิตพื้นฐาน

เช่นเดียวกับคณิตศาสตร์ Rust ใช้ตัวดำเนินการเพื่อคำนวณ ต่อไปนี้คือตัวดำเนินการเลขคณิตที่ใช้บ่อย:

+: การบวก
-: การลบ
*: การคูณ
/: การหาร
%: เศษเหลือ (มอดูโล)

โปรดจำไว้ว่าการหารจำนวนเต็ม (เช่น 10 / 3) จะตัดส่วนทศนิยมออก ทำให้ได้ผลลัพธ์เป็นจำนวนเต็ม (3 ไม่ใช่ 3.33)

การใช้ตัวดำเนินการเลขคณิต

ลองนำตัวดำเนินการเหล่านี้มาใช้กับตัวเลข โปรดสังเกตการทำงานของการหารจำนวนเต็มให้ดี

ลองเรียกใช้ตัวอย่างนี้:

fn main() {
  let a = 15;
  let b = 4;

  println!("Addition: 15 + 4 = {}", a + b);
  println!("Subtraction: 15 - 4 = {}", a - b);
  println!("Multiplication: 15 * 4 = {}", a * b);
  println!("Integer Division: 15 / 4 = {}", a / b);
  println!("Remainder: 15 % 4 = {}", a % b);

  let x = 15.0;
  let y = 4.0;
  println!("Float Division: 15.0 / 4.0 = {}", x / y);
}

แบบทดสอบชนิดข้อมูลพื้นฐาน

ทดสอบความเข้าใจของคุณเกี่ยวกับชนิดข้อมูลพื้นฐานและตัวดำเนินการพื้นฐานของ Rust

ทบทวน: ชนิดข้อมูลพื้นฐานและตัวดำเนินการ

ทำได้ดีมาก คุณได้เรียนรู้เกี่ยวกับชนิดข้อมูลพื้นฐานของ Rust แล้ว:

จำนวนเต็ม: i8, u8, i32, u32 และอื่น ๆ สำหรับจำนวนเต็ม
เลขทศนิยม: f32 และ f64 สำหรับตัวเลขทศนิยม
ค่าบูลีน: bool สำหรับค่า true หรือ false
อักขระ: char สำหรับค่า Unicode เดี่ยว

คุณยังได้ทดลองใช้ตัวดำเนินการเลขคณิตพื้นฐาน เช่น +, -, *, / และ % ซึ่งเป็นพื้นฐานสำหรับตรรกะที่ซับซ้อนยิ่งขึ้นในโปรแกรมของคุณ

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

บทเรียน “ชนิดข้อมูลพื้นฐานและตัวดำเนินการ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ชนิดข้อมูลพื้นฐานและตัวดำเนินการ”

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

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

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

บทเรียน “ชนิดข้อมูลพื้นฐานและตัวดำเนินการ” ใช้เวลานานแค่ไหน

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

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

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

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

ตัวแปร การเปลี่ยนแปลงค่าได้ และการบดบังชื่อ
ชนิดข้อมูลพื้นฐานและตัวดำเนินการ
ฟังก์ชันและลำดับการควบคุม

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