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

คลอเชอร์

ฟังก์ชันนิรนาม

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

Closure คืออะไร

Closure คือฟังก์ชันนิรนามที่คุณเก็บไว้ในตัวแปรและเรียกใช้ภายหลังได้ โดยเขียนพารามิเตอร์ไว้ระหว่างเครื่องหมายขีดตั้ง

fn main() {
    let add_one = |x| x + 1;
    println!("{}", add_one(4));
}

ไวยากรณ์ของ Closure

พารามิเตอร์จะอยู่ระหว่าง |...| ตามด้วยส่วนเนื้อหา หากมีเพียงนิพจน์เดียวก็ไม่จำเป็นต้องใช้วงเล็บปีกกา

  • |x| x + 1 — มีพารามิเตอร์หนึ่งตัว
  • |a, b| a + b — มีพารามิเตอร์สองตัว
fn main() {
    let multiply = |a, b| a * b;
    println!("{}", multiply(3, 5));
}

Closure หลายบรรทัด

หากมีคำสั่งมากกว่าหนึ่งคำสั่ง ให้ครอบส่วนเนื้อหาด้วยวงเล็บปีกกา เช่นเดียวกับฟังก์ชัน

fn main() {
    let describe = |n: i32| {
        let doubled = n * 2;
        println!("{} doubled is {}", n, doubled);
    };
    describe(7);
}

การจับสภาพแวดล้อม

ต่างจากฟังก์ชันทั่วไป closure สามารถ จับค่า ตัวแปรจากขอบเขตโดยรอบและนำมาใช้ภายในได้

fn main() {
    let factor = 10;
    let scale = |x| x * factor;
    println!("{}", scale(5));
}

การอนุมานประเภทใน Closure

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

คุณสามารถเพิ่มประเภทเพื่อให้โค้ดชัดเจนขึ้นได้เมื่อจำเป็น

fn main() {
    let greet = |name: &str| -> String {
        format!("Hello, {}!", name)
    };
    println!("{}", greet("Rust"));
}

การใช้ Closure เป็นอาร์กิวเมนต์

เมธอดมาตรฐานจำนวนมากรับ closure ตัวอย่างเช่น map จะนำ closure ไปใช้กับแต่ละรายการ

fn main() {
    let nums = vec![1, 2, 3];
    let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
    println!("{:?}", doubled);
}

การกรองด้วย Closure

เมธอด filter จะเก็บไว้เฉพาะรายการที่ closure ส่งค่า true กลับมา

fn main() {
    let nums = vec![1, 2, 3, 4, 5, 6];
    let evens: Vec<i32> = nums.into_iter().filter(|x| x % 2 == 0).collect();
    println!("{:?}", evens);
}

การจัดเก็บ Closure

Closure มีประเภทนิรนามเฉพาะตัว แต่คุณสามารถจัดเก็บไว้ในตัวแปรและนำกลับมาใช้ซ้ำได้

fn main() {
    let is_even = |n: i32| n % 2 == 0;
    println!("{} {}", is_even(4), is_even(7));
}

Closure เทียบกับฟังก์ชัน

ข้อแตกต่าง:

  • ฟังก์ชันไม่สามารถจับค่าตัวแปรจากขอบเขตโดยรอบได้ แต่ closure ทำได้
  • Closure ไม่มีชื่อและมักมีขนาดสั้น
  • โดยทั่วไปประเภทของ closure จะถูกอนุมาน
fn main() {
    let base = 100;
    let bonus = |earned: i32| earned + base;
    println!("{}", bonus(25));
}

การส่งค่าที่คำนวณแล้วกลับ

ใช้ closure ร่วมกับตัววนซ้ำเพื่อคำนวณผลลัพธ์ผ่านกระบวนการแบบต่อเนื่องที่อ่านง่ายและสื่อความหมาย

fn main() {
    let nums = vec![10, 20, 30];
    let total: i32 = nums.iter().map(|x| x + 1).sum();
    println!("total {}", total);
}

Closure จับค่าโดยการยืมอ้างอิง

ตามค่าเริ่มต้น closure จะยืมตัวแปรที่จับค่าไว้ คุณยังสามารถอ่านตัวแปรเหล่านั้นภายนอกได้ภายหลัง (เมื่อมีการยืมเพียงอย่างเดียว)

fn main() {
    let name = String::from("Ada");
    let printer = || println!("Name: {}", name);
    printer();
    println!("still usable: {}", name);
}

ตรวจสอบความเข้าใจ

ทบทวนความสามารถสำคัญประการหนึ่งของ closure

สรุปทบทวน

Closure ใน Rust:

  • ฟังก์ชันนิรนามที่เขียนในรูป |params| body
  • สามารถจับค่าตัวแปรจากสภาพแวดล้อมได้
  • โดยทั่วไปประเภทจะถูกอนุมาน
  • ใช้กันอย่างแพร่หลายร่วมกับเมธอดของตัววนซ้ำ เช่น map และ filter
fn main() {
    let tax = 0.2;
    let with_tax = |price: f64| price * (1.0 + tax);
    println!("{}", with_tax(50.0));
}

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

บทเรียน “คลอเชอร์” ฟรีหรือไม่

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

บทเรียน “คลอเชอร์” ใช้เวลานานแค่ไหน

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

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

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

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

  1. การกำหนดฟังก์ชัน
  2. นิพจน์และคำสั่ง
  3. คลอเชอร์
  4. Fn, FnMut, FnOnce
← กลับไปที่ Learn Rust Coding