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

สไลซ์

มุมมองที่ยืมมา

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

สไลซ์คืออะไร

สไลซ์คือมุมมองที่ยืมมาจากส่วนที่ต่อเนื่องกันของคอลเลกชัน สไลซ์ไม่ได้เป็นเจ้าของข้อมูล แต่ชี้เข้าไปยังข้อมูลที่มีอยู่

สไลซ์เขียนด้วยช่วงดัชนีภายในวงเล็บเหลี่ยม

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let part = &arr[1..4];
    println!("{:?}", part);
}

ไวยากรณ์ช่วงของสไลซ์

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

  • &v[1..4] — ดัชนี 1, 2, 3
  • &v[..3] — ตั้งแต่ต้นจนถึง 3
  • &v[2..] — ตั้งแต่ 2 จนถึงท้ายสุด
fn main() {
    let v = vec![10, 20, 30, 40];
    println!("{:?}", &v[..2]);
    println!("{:?}", &v[2..]);
}

สไลซ์สตริง

สไลซ์สตริง &str คือมุมมองของส่วนหนึ่งใน String ช่วงดัชนีจะอ้างอิงตามตำแหน่งไบต์

fn main() {
    let s = String::from("hello world");
    let hello = &s[0..5];
    let world = &s[6..11];
    println!("{} {}", hello, world);
}

สไลซ์ทั้งคอลเลกชัน

ใช้ &v[..] เพื่อสไลซ์คอลเลกชันทั้งหมด นี่คือวิธีที่ Vec ถูกยืมเป็นสไลซ์

fn main() {
    let v = vec![1, 2, 3];
    let whole = &v[..];
    println!("{:?}", whole);
}

สไลซ์เป็นพารามิเตอร์

ฟังก์ชันที่รับค่า &[T] สามารถรับทั้งอาร์เรย์และเวกเตอร์ได้ ทำให้ฟังก์ชันมีความยืดหยุ่น

fn sum(items: &[i32]) -> i32 {
    let mut total = 0;
    for x in items {
        total += x;
    }
    total
}

fn main() {
    let v = vec![1, 2, 3];
    let a = [4, 5, 6];
    println!("{} {}", sum(&v), sum(&a));
}

สไลซ์ยืม ไม่ได้เป็นเจ้าของ

เนื่องจากสไลซ์เป็นการยืม คอลเลกชันเดิมจึงต้องยังมีชีวิตอยู่ขณะที่ใช้งานสไลซ์ ตัวตรวจสอบของคอมไพเลอร์จะบังคับใช้กฎนี้

fn main() {
    let v = vec![100, 200, 300];
    let s = &v[0..2];
    println!("slice {:?}, original {:?}", s, v);
}

ความยาวของสไลซ์

เช่นเดียวกับคอลเลกชันอื่น ๆ สไลซ์มีเมธอด len() ที่บอกจำนวนองค์ประกอบที่สไลซ์ครอบคลุม

fn main() {
    let v = vec![5, 6, 7, 8, 9];
    let middle = &v[1..4];
    println!("length {}", middle.len());
}

first และ last

สไลซ์มี first() และ last() ซึ่งคืนค่าเป็น Options เพื่อจัดการสไลซ์ว่างได้อย่างปลอดภัย

fn main() {
    let data = [10, 20, 30];
    let s = &data[..];
    println!("{:?} {:?}", s.first(), s.last());
}

การวนซ้ำสไลซ์

คุณสามารถวนซ้ำสไลซ์ได้เช่นเดียวกับคอลเลกชันทุกชนิด

fn main() {
    let v = vec![1, 2, 3, 4];
    for x in &v[1..3] {
        println!("{}", x);
    }
}

ฟังก์ชันหาคำแรก

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

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &b) in bytes.iter().enumerate() {
        if b == b' ' {
            return &s[0..i];
        }
    }
    s
}

fn main() {
    println!("{}", first_word("hello there"));
}

เหตุใดสไลซ์จึงปลอดภัย

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

fn main() {
    let words = vec!["a", "b", "c", "d"];
    let pair = &words[1..3];
    println!("{:?}", pair);
}

ตรวจสอบอย่างรวดเร็ว

ทบทวนว่าสไลซ์แทนอะไร

สรุปทบทวน

สไลซ์ใน Rust:

  • มุมมองที่ยืมมา: &v[start..end] โดยตำแหน่งสิ้นสุดไม่รวมอยู่ในช่วง
  • &str คือสไลซ์สตริง ส่วน &[T] คือสไลซ์ของอาร์เรย์หรือเวกเตอร์
  • พารามิเตอร์แบบสไลซ์รับได้ทั้งอาร์เรย์และเวกเตอร์
  • ตัวตรวจสอบการยืมช่วยให้สไลซ์ปลอดภัย
fn average(nums: &[i32]) -> i32 {
    nums.iter().sum::<i32>() / nums.len() as i32
}

fn main() {
    let v = vec![4, 8, 12];
    println!("{}", average(&v[..]));
}

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

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

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

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

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

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

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

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

  1. String เทียบกับ &str
  2. สไลซ์
  3. เมธอดของสตริง
  4. UTF-8 และอักขระ
← กลับไปที่ Learn Rust Coding