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

การบดบังชื่อ

การผูกตัวแปรใหม่

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

การบังชื่อคืออะไร

การบังชื่อหมายถึงการประกาศตัวแปรใหม่โดยใช้ชื่อเดียวกับตัวแปรก่อนหน้า การผูกชื่อใหม่จะ “บัง” ตัวเก่า

ทำได้โดยเขียน let ซ้ำพร้อมชื่อเดิม

fn main() {
    let x = 5;
    let x = x + 1;
    let x = x * 2;
    println!("x is {}", x);
}

การบังชื่อไม่ใช่การเปลี่ยนค่า

การบังชื่อจะสร้างตัวแปรใหม่ขึ้นมา แตกต่างจาก mut ซึ่งใช้ตัวแปรเดิมซ้ำ

เนื่องจาก let แต่ละครั้งเป็นการผูกชื่อใหม่ ค่าเหล่านั้นจึงสามารถมีชนิดแตกต่างกันได้

fn main() {
    let y = 10;        // immutable
    let y = y + 5;     // new binding, also immutable
    println!("y is {}", y);
}

การเปลี่ยนชนิดด้วยการบังชื่อ

ประโยชน์อย่างหนึ่งของการบังชื่อคือการใช้ชื่อเดิมซ้ำขณะเปลี่ยนชนิดข้อมูล

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

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
    println!("count is {}", spaces);
}

เหตุใด mut จึงเปลี่ยนชนิดไม่ได้

เมื่อใช้ mut คุณสามารถเปลี่ยนค่าได้ แต่เปลี่ยนชนิดข้อมูลไม่ได้

โค้ดนี้จะคอมไพล์ไม่สำเร็จ:

  • let mut spaces = " ";
  • spaces = spaces.len(); — เกิดข้อผิดพลาดชนิดข้อมูลไม่ตรงกัน

การบังชื่อช่วยหลีกเลี่ยงปัญหานี้ เพราะเป็นการสร้างตัวแปรใหม่

fn main() {
    let mut count = 3;
    count = 4; // ok, same type
    println!("{}", count);
}

การบังชื่อในขอบเขตภายใน

ตัวแปรสามารถถูกบังชื่อภายในบล็อกด้านในได้ เมื่อบล็อกสิ้นสุด การผูกชื่อจากภายนอกจะกลับมาใช้ได้อีกครั้ง

fn main() {
    let n = 1;
    {
        let n = n * 10;
        println!("inner {}", n);
    }
    println!("outer {}", n);
}

การแปลงทีละขั้นตอน

การบังชื่อช่วยให้คุณแปลงค่าผ่านหลายขั้นตอน โดยยังคงใช้ชื่อที่สื่อความหมายเพียงชื่อเดียว

fn main() {
    let input = "42";
    let input: i32 = input.trim().parse().unwrap();
    let input = input * 2;
    println!("result {}", input);
}

การบังชื่อยังคงความไม่เปลี่ยนแปลง

การผูกชื่อแต่ละครั้งที่ถูกบังยังคงไม่เปลี่ยนแปลง หลังการแปลง คุณยังได้ความปลอดภัยจากค่าที่ไม่เปลี่ยนแปลง โดยไม่ต้องสร้างชื่อใหม่อย่าง x2 หรือ x_temp

fn main() {
    let price = 100;
    let price = price - 20;   // discount applied
    let price = price + 5;    // shipping added
    println!("final price {}", price);
}

การบังชื่อด้วยตรรกะที่แตกต่างกัน

คุณสามารถคำนวณค่าใหม่ด้วยวิธีใดก็ได้ รวมถึงการเรียกฟังก์ชันหรือใช้นิพจน์

fn main() {
    let text = "hello";
    let text = text.to_uppercase();
    println!("{}", text);
}

หลีกเลี่ยงความสับสน

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

fn main() {
    let raw = "  Rust  ";
    let raw = raw.trim();      // clean version
    println!("[{}]", raw);
}

สรุปการบังชื่อกับการกำหนดค่าใหม่

มีสองวิธีในการกำหนดค่าใหม่ให้ชื่อหนึ่ง:

  • การบังชื่อ: เขียน let x = ...; อีกครั้ง — ได้ตัวแปรใหม่ เปลี่ยนชนิดได้ และยังคงไม่เปลี่ยนแปลง
  • การกำหนดค่าใหม่: เขียน x = ...; โดยใช้ mut — เป็นตัวแปรเดิมและต้องใช้ชนิดเดิม
fn main() {
    let val = "7";
    let val: i32 = val.parse().unwrap(); // shadow + type change
    let mut val = val;
    val += 1;                            // reassign, same type
    println!("{}", val);
}

ตัวอย่างเชิงปฏิบัติ

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

fn main() {
    let age = "25";
    let age: u32 = age.parse().unwrap();
    let age = age + 1; // next birthday
    println!("next year you will be {}", age);
}

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

พิจารณาว่าอะไรทำให้การบังชื่อแตกต่างจากการใช้ mut

สรุปทบทวน

การบังชื่อใน Rust:

  • เขียน let ซ้ำพร้อมชื่อเดิมเพื่อสร้างการผูกชื่อใหม่
  • การผูกชื่อใหม่อาจมีชนิดข้อมูลแตกต่างกัน
  • ค่าที่ถูกบังแต่ละค่ายังคงไม่เปลี่ยนแปลง
  • แตกต่างจาก mut ซึ่งเปลี่ยนค่าของตัวแปรเดิมและคงชนิดข้อมูลเดิม
fn main() {
    let data = "100";
    let data: i32 = data.parse().unwrap();
    let data = data / 4;
    println!("final {}", data);
}

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

บทเรียน “การบดบังชื่อ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การบดบังชื่อ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การบดบังชื่อ” ใช้เวลานานแค่ไหน

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

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

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

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

  1. let และความเปลี่ยนแปลงได้
  2. ชนิดข้อมูลสเกลาร์
  3. ชนิดข้อมูลประกอบ
  4. การบดบังชื่อ
← กลับไปที่ Learn Rust Coding