0Pricing
Learn Rust Coding · บทเรียน

การแยกโครงสร้าง

สตรักต์ enum และทูเพิล

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

การแยกโครงสร้างคืออะไร

การแยกโครงสร้าง คือการแยกค่าประกอบออกเป็นส่วนย่อยโดยใช้รูปแบบ ใช้ได้กับทูเพิล โครงสร้าง enum อาร์เรย์ และอื่น ๆ

การแยกโครงสร้างทูเพิล

ผูกแต่ละองค์ประกอบของทูเพิลไว้กับตัวแปรของตนเองภายใน let เดียว

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

การละเว้นส่วนของทูเพิล

ใช้ _ เพื่อข้ามค่าเดียว และใช้ .. เพื่อข้ามหลายค่า

fn main() {
    let data = (1, 2, 3, 4);
    let (first, .., last) = data;
    println!("{first} ... {last}");
}

การแยกโครงสร้าง

ดึงฟิลด์ออกจากโครงสร้างตามชื่อ ตัวแปรที่ผูกอาจใช้ชื่อเดียวกับฟิลด์หรือเปลี่ยนชื่อใหม่ก็ได้

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };
    let Point { x, y } = p;
    println!("{x}, {y}");
}

การเปลี่ยนชื่อฟิลด์

ใช้ field: new_name เพื่อผูกฟิลด์ของโครงสร้างไว้กับชื่อตัวแปรอื่น

struct Config {
    width: u32,
    height: u32,
}

fn main() {
    let c = Config { width: 800, height: 600 };
    let Config { width: w, height: h } = c;
    println!("{w} x {h}");
}

การละเว้นฟิลด์ของโครงสร้าง

.. ใช้ละเว้นฟิลด์ที่เหลือซึ่งคุณไม่ต้องการ

struct User {
    name: String,
    age: u32,
    active: bool,
}

fn main() {
    let u = User { name: "Ada".into(), age: 36, active: true };
    let User { name, .. } = u;
    println!("{name}");
}

การแยกโครงสร้าง enum

ภายใน match ให้แยกรูปแบบย่อยของ enum เพื่อดึงข้อมูลภายในออกมา

enum Event {
    Click { x: i32, y: i32 },
    Key(char),
}

fn main() {
    let e = Event::Click { x: 5, y: 8 };
    match e {
        Event::Click { x, y } => println!("click at {x},{y}"),
        Event::Key(c) => println!("key {c}"),
    }
}

การแยกโครงสร้างในพารามิเตอร์

พารามิเตอร์ของฟังก์ชันสามารถแยกโครงสร้างได้โดยตรง ซึ่งสะดวกสำหรับทูเพิลและโครงสร้างขนาดเล็ก

fn distance((x1, y1): (f64, f64), (x2, y2): (f64, f64)) -> f64 {
    ((x2 - x1).powi(2) + (y2 - y1).powi(2)).sqrt()
}

fn main() {
    println!("{}", distance((0.0, 0.0), (3.0, 4.0)));
}

การแยกโครงสร้างแบบซ้อน

รูปแบบสามารถซ้อนกันได้อย่างอิสระ คุณจึงเข้าถึงข้อมูลที่อยู่ลึกในโครงสร้างได้ในขั้นตอนเดียว

struct Line {
    start: (i32, i32),
    end: (i32, i32),
}

fn main() {
    let line = Line { start: (0, 0), end: (4, 5) };
    let Line { start: (sx, sy), end: (ex, ey) } = line;
    println!("from {sx},{sy} to {ex},{ey}");
}

การแยกโครงสร้างอาร์เรย์และสไลซ์

สามารถแยกโครงสร้างอาร์เรย์และสไลซ์ได้ รวมถึงการเก็บส่วนตรงกลางด้วย ..

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let [first, .., last] = arr;
    println!("first {first}, last {last}");
}

การแยกโครงสร้างในลูป for

การแยกโครงสร้างใช้ในลูป for ได้เช่นกัน เหมาะอย่างยิ่งสำหรับวนซ้ำผ่านคู่ของค่า

fn main() {
    let pairs = [("a", 1), ("b", 2), ("c", 3)];
    for (label, value) in pairs {
        println!("{label} = {value}");
    }
}

ตรวจสอบอย่างรวดเร็ว

ขณะแยกโครงสร้าง คุณจะละเว้นฟิลด์ที่เหลือของโครงสร้างได้อย่างไร

สรุปทบทวน

คุณได้เรียนรู้การแยกโครงสร้าง:

  • แยกทูเพิล โครงสร้าง enum อาร์เรย์ และสไลซ์ออกเป็นส่วนย่อย
  • เปลี่ยนชื่อฟิลด์ด้วย field: name
  • ละเว้นบางส่วนด้วย _ และ ..
  • แยกโครงสร้างใน let, match และพารามิเตอร์ของฟังก์ชัน
  • รูปแบบซ้อนกันได้เพื่อดึงข้อมูลที่อยู่ลึก

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

บทเรียน “การแยกโครงสร้าง” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การแยกโครงสร้าง”

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

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

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

บทเรียน “การแยกโครงสร้าง” ใช้เวลานานแค่ไหน

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

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

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

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

  1. เจาะลึก match
  2. if let และ while let
  3. การผูกค่าด้วย @
  4. การแยกโครงสร้าง
← กลับไปที่ Learn Rust Coding