การบดบังชื่อ
การผูกตัวแปรใหม่
การบดบังชื่อ เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ