Learn Rust Coding · บทเรียน

ตัวปรับและตัวรับผล

การเชื่อมโยงการดำเนินการ

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

เมธอดสองประเภท

เมธอดของ Iterator แบ่งออกเป็นสองกลุ่ม:

อะแดปเตอร์ คืนค่า Iterator ใหม่และทำงานแบบขี้เกียจ (map, filter, take)
ตัวใช้ผลลัพธ์ ทำให้ Iterator ทำงานและสร้างค่าผลลัพธ์สุดท้าย (sum, collect, for_each)

สายการประมวลผลทุกสายประกอบด้วยอะแดปเตอร์ตั้งแต่ศูนย์รายการขึ้นไป ตามด้วยตัวใช้ผลลัพธ์หนึ่งรายการพอดี

take: จำกัดจำนวน

take(n) ให้ผลลัพธ์ไม่เกิน n องค์ประกอบ แล้วหยุดทำงาน เมธอดนี้เป็นอะแดปเตอร์ จึงยังทำงานแบบขี้เกียจ

ใช้ได้แม้กับ Iterator แบบไม่สิ้นสุด โดยจะเลือกมาเฉพาะจำนวนที่คุณร้องขอ

fn main() {
    let first_three: Vec<i32> = (1..).take(3).collect();
    println!("{:?}", first_three);
}

skip: ข้ามองค์ประกอบแรก

skip(n) ตัดองค์ประกอบ n รายการแรกออก แล้วให้ผลลัพธ์เป็นองค์ประกอบที่เหลือ ใช้ร่วมกับ take เพื่อเลือกช่วงข้อมูลจากตรงกลางได้

fn main() {
    let window: Vec<i32> = (1..=10).skip(3).take(4).collect();
    println!("{:?}", window);
}

enumerate: จับคู่กับดัชนี

enumerate ให้ผลลัพธ์เป็นทูเพิล (index, value) โดยเริ่มนับจากศูนย์ เป็นวิธีมาตรฐานในการรับตำแหน่งโดยไม่ต้องสร้างตัวนับเอง

fn main() {
    let letters = vec!['a', 'b', 'c'];
    for (i, c) in letters.iter().enumerate() {
        println!("{} -> {}", i, c);
    }
}

zip: เดินผ่าน Iterator สองตัวพร้อมกัน

zip จับคู่องค์ประกอบจาก Iterator สองตัวเข้าด้วยกัน และจะหยุดเมื่อ Iterator ที่สั้นกว่าหมดองค์ประกอบ

เหมาะสำหรับรวมข้อมูลที่เดินไปคู่ขนานกัน เช่น ชื่อกับคะแนน

fn main() {
    let names = vec!["Ana", "Ben"];
    let ages = vec![30, 25];
    for (name, age) in names.iter().zip(ages.iter()) {
        println!("{} is {}", name, age);
    }
}

rev: ย้อนลำดับ

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

fn main() {
    let backwards: Vec<i32> = (1..=5).rev().collect();
    println!("{:?}", backwards);
}

chain: เชื่อม Iterator สองตัว

chain ทำให้ Iterator แรกทำงานจนเสร็จ แล้วจึงทำงานต่อด้วย Iterator ที่สอง ราวกับว่าทั้งสองเป็นลำดับเดียวกัน

fn main() {
    let joined: Vec<i32> = (1..=3).chain(10..=12).collect();
    println!("{:?}", joined);
}

fold: สร้างค่าเดียว

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

ตัวใช้ผลลัพธ์หลายรายการ เช่น sum เป็นกรณีเฉพาะของ fold

fn main() {
    let product = (1..=5).fold(1, |acc, x| acc * x);
    println!("5! = {}", product);
}

any และ all: ตัวใช้ผลลัพธ์แบบบูลีน

any คืนค่า true หากมีอย่างน้อยหนึ่งองค์ประกอบที่ตรงตามเพรดิเคต ส่วน all จะคืนค่า true ก็ต่อเมื่อทุกองค์ประกอบตรงตามเพรดิเคต

ทั้งสองเมธอดหยุดทำงานล่วงหน้า โดยจะหยุดทันทีที่ทราบคำตอบ

fn main() {
    let nums = vec![2, 4, 6, 7];
    println!("{}", nums.iter().all(|x| x % 2 == 0));
    println!("{}", nums.iter().any(|x| x % 2 != 0));
}

find และ position

find คืนค่าองค์ประกอบแรกที่ตรงตามเพรดิเคตในรูปแบบ Option ส่วน position จะคืนค่าดัชนีขององค์ประกอบแรกที่ตรงกันแทน

ทั้งสองเมธอดหยุดทำงานล่วงหน้าเมื่อพบรายการแรก

fn main() {
    let nums = vec![1, 3, 5, 8, 9];
    println!("{:?}", nums.iter().find(|&&x| x % 2 == 0));
    println!("{:?}", nums.iter().position(|&x| x % 2 == 0));
}

การออกแบบสายการประมวลผล

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

เนื่องจากอะแดปเตอร์ทำงานแบบขี้เกียจ แม้สายการทำงานจะยาว ก็จะวนผ่านข้อมูลเพียงรอบเดียว

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

อะแดปเตอร์กับตัวใช้ผลลัพธ์

สรุปทบทวน

คุณได้ทดลองเชื่อมการดำเนินการเข้าด้วยกัน:

อะแดปเตอร์ (take, skip, enumerate, zip, rev, chain) ยังคงทำงานแบบขี้เกียจ
ตัวใช้ผลลัพธ์ (fold, any, all, find, position) ทำให้งานเสร็จสมบูรณ์
ตัวใช้ผลลัพธ์แบบบูลีนและแบบค้นหาจะหยุดทำงานล่วงหน้า
สายการประมวลผลทุกสายประกอบด้วยอะแดปเตอร์ แล้วตามด้วยตัวใช้ผลลัพธ์หนึ่งรายการ

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

บทเรียน “ตัวปรับและตัวรับผล” ฟรีหรือไม่

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

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

← กลับไปที่ Learn Rust Coding