Rust:
การปรับโครงสร้างโค้ด

วิธีการ:

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

fn sum(vec: &Vec<i32>) -> i32 {
    let mut sum = 0;
    for i in vec {
        sum += i;
    }
    sum
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    println!("The sum is {}", sum(&numbers));
}

ผลลัพธ์:

The sum is 15

ตอนนี้, มา refactor ให้ใช้ Rust ที่เข้าถึงทางนิยมมากขึ้นโดยใช้ iterators และเมธอด fold:

fn sum(vec: &[i32]) -> i32 {
    vec.iter().fold(0, |acc, &x| acc + x)
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    println!("The sum is {}", sum(&numbers));
}

ไม่มีการเปลี่ยนแปลงในผลลัพธ์—ยังคงเป็น 15—แต่เวอร์ชันที่ถูก refactor นี้เรียบง่ายขึ้นและใช้จุดแข็งของ Rust เช่น borrowing และเมธอดของ iterator

การศึกษาลึก

Refactoring มีรากฐานมาจากชุมชนของ Smalltalk และได้รับความนิยมในโลกของ Java โดยหนังสือของ Martin Fowler ที่มีชื่อว่า “Refactoring: Improving the Design of Existing Code” หลักการของมันคือสิ่งทั่วไปและใช้ได้กับ Rust เช่นกัน ซึ่งความปลอดภัยและความพร้อมเพรียงเป็นสิ่งที่สำคัญที่สุด Rust สนับสนุนการเขียนโค้ดที่เข้มแข็งโดยการจับปัญหาในเวลา compile ดังนั้นในระหว่างการ refactor, คอมไพเลอร์ของ Rust ทำหน้าที่เป็นตาข่ายความปลอดภัย

ทางเลือกในการ refactor ด้วยตนเองรวมถึงการใช้เครื่องมืออัตโนมัติ เช่น ‘rustfmt’ สำหรับการจัดรูปแบบโค้ดและ ‘clippy’ สำหรับการ lint ซึ่งสามารถแนะนำวิธีการเขียนโค้ดที่เข้าถึงทางนิยมมากขึ้น อย่างไรก็ตาม, การ refactor อย่างลึกซึ้งมักต้องการความเข้าใจที่พิจารณาถึงออกแบบของโค้ด ซึ่งเครื่องมือเหล่านี้ไม่สามารถทำแบบอัตโนมัติได้อย่างเต็มที่

ใน Rust, การ refactor อาจมุ่งเน้นไปที่การปรับปรุงการใช้ประเภทข้อมูล, การใช้ชีวิตของตัวแปรอย่างมีประสิทธิภาพ, การลดการจัดสรรที่ไม่จำเป็น, หรือการใช้แบบแผนความพร้อมเพรียง เช่นการใช้ Arc<Mutex<T>> เมื่อจำเป็น มันยังเป็นสิ่งทั่วไปในการเปลี่ยนจาก unwrap() ไปสู่การจัดการข้อผิดพลาดที่แสดงออกมาได้ดีขึ้นด้วย Result<T, E>

ดูเพิ่มเติม

เพื่อการศึกษาเพิ่มเติมเกี่ยวกับการ refactor ใน Rust: