Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

เก็บข้อความที่เข้ารหัส UTF-8 ด้วยสตริง

เราได้เคยพูดถึงสตริง (strings) กันไปบ้างแล้วในบทที่ 4 แต่ในหัวข้อนี้ เราจะมาเจาะลึกรายละเอียดการทำงานของมันกันอย่างจริงจัง ชาว Rustacean มือใหม่มักจะรู้สึกติดขัดและสับสนกับเรื่องสตริงอยู่บ่อยครั้ง ซึ่งเกิดจากปัจจัย 3 ประการรวมกัน ได้แก่: ความมุ่งมั่นของ Rust ที่พยายามเปิดเผยข้อผิดพลาดที่อาจเกิดขึ้นทั้งหมดออกมาตั้งแต่ต้น, ความจริงที่ว่าสตริงเป็นโครงสร้างข้อมูลที่มีความซับซ้อนมากกว่าที่โปรแกรมเมอร์หลายคนคิด และการเข้ารหัสแบบ UTF-8 ปัจจัยเหล่านี้เมื่อมารวมเข้าด้วยกัน จึงทำให้เรื่องสตริงดูยากขึ้น โดยเฉพาะอย่างยิ่งหากคุณย้ายมาจากภาษาโปรแกรมอื่นๆ

สาเหตุที่เรานำเรื่องสตริงมาพูดคุยในบริบทของคอลเลกชัน ก็เพราะว่าสตริงถูกอิมพลีเมนต์ขึ้นมาในฐานะคอลเลกชันของไบต์ ร่วมกับเมธอดอำนวยความสะดวกต่างๆ เพื่อช่วยจัดการเมื่อไบต์เหล่านั้นถูกนำมาตีความเป็นตัวอักษรหรือข้อความ ในหัวข้อนี้ เราจะมาเรียนรู้การดำเนินการพื้นฐานกับ String ที่พบได้ในคอลเลกชันทุกชนิด เช่น การสร้าง, การอัปเดต และการอ่านค่า นอกจากนี้ เรายังจะได้สำรวจข้อแตกต่างระหว่าง String กับคอลเลกชันอื่นๆ โดยเฉพาะอย่างยิ่ง เหตุใดการเข้าถึงข้อมูลผ่านดัชนี (indexing) ของ String จึงกลายเป็นเรื่องซับซ้อน อันเนื่องมาจากความแตกต่างระหว่างมุมมองของมนุษย์กับคอมพิวเตอร์ในการตีความข้อมูลสตริง

การนิยามสตริง

อันดับแรก เรามานิยามความหมายของคำว่า สตริง (string) ให้ตรงกันก่อน ในแก่นของภาษา Rust (core language) มีชนิดข้อมูลสตริงเพียงชนิดเดียวเท่านั้น นั่นคือสตริงสไลซ์ (string slice) str ซึ่งเรามักจะพบเห็นในรูปแบบที่ถูกยืมมาใช้งานคือ &str โดยในบทที่ 4 เราได้เรียนรู้แล้วว่า สตริงสไลซ์คือการอ้างอิง (reference) ไปยังข้อมูลสตริงที่เข้ารหัสแบบ UTF-8 ซึ่งถูกจัดเก็บไว้ที่อื่น ตัวอย่างเช่น สตริงลิเทอรัล (string literals) จะถูกฝังเก็บไว้ภายในไฟล์ไบนารีของตัวโปรแกรม ดังนั้นพวกมันจึงมีชนิดข้อมูลเป็นสตริงสไลซ์

ส่วนชนิดข้อมูล String นั้น เป็นสิ่งที่เตรียมไว้ให้โดยไลบรารีมาตรฐานของ Rust ไม่ได้ถูกฮาร์ดโค้ดไว้ในแก่นของตัวภาษา โดย String จะเป็นสตริงชนิดที่สามารถขยายขนาดได้, แก้ไขเปลี่ยนแปลงข้อมูลได้, เป็นเจ้าของข้อมูลในตัวเอง (owned) และเข้ารหัสด้วย UTF-8 เสมอ เมื่อชาว Rustacean พูดถึงคำว่า “สตริง” ในภาษา Rust จึงอาจหมายถึงชนิดข้อมูล String หรือสตริงสไลซ์ &str ตัวใดตัวหนึ่งก็ได้ และแม้ว่าเนื้อหาในหัวข้อนี้จะเน้นหนักไปที่ String เป็นหลัก แต่ทั้งสองชนิดต่างก็ถูกนำมาใช้งานอย่างหนักหน่วงในไลบรารีมาตรฐานของ Rust และทั้งคู่ต่างก็เข้ารหัสด้วย UTF-8 เหมือนกันทั้งสิ้น

การสร้างสตริงใหม่

การดำเนินการหลายๆ อย่างที่มีให้ใช้งานใน Vec<T> ก็สามารถใช้งานกับ String ได้เช่นเดียวกัน เพราะความจริงแล้ว String ถูกอิมพลีเมนต์ขึ้นมาเป็นตัวห่อหุ้ม (wrapper) ครอบรอบเวกเตอร์ของไบต์ โดยมีการเพิ่มการรับประกันความถูกต้อง (guarantees), ข้อจำกัด และฟังก์ชันการทำงานพิเศษเพิ่มเติมเข้าไป ตัวอย่างของฟังก์ชันที่ทำงานเหมือนกันทุกประการระหว่าง Vec<T> และ String ก็คือฟังก์ชัน new สำหรับสร้างอินสแตนซ์ใหม่ ดังที่แสดงในลิสติ้ง 8-11

fn main() {
    let mut s = String::new();
}

คำสั่งบรรทัดนี้จะสร้างสตริงว่างตัวใหม่ชื่อ s ซึ่งเราสามารถทยอยโหลดข้อมูลใส่เข้าไปในภายหลังได้ แต่บ่อยครั้งเรามักจะมีข้อมูลข้อความเริ่มต้นที่ต้องการนำมาสร้างเป็นสตริงทันที ซึ่งในกรณีนั้น เราสามารถเรียกใช้เมธอด to_string ได้ โดยเมธอดนี้จะพร้อมใช้งานสำหรับทุกชนิดข้อมูลที่อิมพลีเมนต์เทรต Display เช่นเดียวกับสตริงลิเทอรัล ลิสติ้ง 8-12 แสดงตัวอย่างการใช้งาน 2 แบบ

fn main() {
    let data = "initial contents";

    let s = data.to_string();

    // The method also works on a literal directly:
    let s = "initial contents".to_string();
}

โค้ดนี้จะสร้างสตริงที่บรรจุข้อความ initial contents ขึ้นมา

นอกจากนี้ เรายังสามารถใช้ฟังก์ชัน String::from ในการสร้าง String ขึ้นมาจากสตริงลิเทอรัลได้เช่นเดียวกัน โดยโค้ดในลิสติ้ง 8-13 จะให้ผลลัพธ์เทียบเท่ากับโค้ดในลิสติ้ง 8-12 ที่ใช้ to_string ทุกประการ

fn main() {
    let s = String::from("initial contents");
}

และเนื่องจากสตริงถูกนำไปใช้งานในหลากหลายบริบท Rust จึงจัดเตรียม API แบบเจเนอริกไว้ให้เลือกใช้งานมากมาย ซึ่งแม้ว่าบางคำสั่งอาจดูเหมือนทำงานซ้ำซ้อนกัน แต่แต่ละคำสั่งต่างก็มีสถานการณ์ที่เหมาะสมของตนเอง ในกรณีนี้ ทั้ง String::from และ to_string ต่างทำหน้าที่แบบเดียวกันอย่างสมบูรณ์แบบ ดังนั้นการจะเลือกใช้คำสั่งใดจึงขึ้นอยู่กับสไตล์ความชอบและความอ่านง่ายของโค้ดเป็นสำคัญ

และอย่าลืมว่า สตริงใน Rust จะเข้ารหัสด้วย UTF-8 เสมอ ดังนั้นเราจึงสามารถใส่ข้อมูลภาษาใดๆ ที่เข้ารหัสอย่างถูกต้องลงไปได้อย่างอิสระ ดังที่แสดงในลิสติ้ง 8-14

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

ข้อความทั้งหมดนี้ล้วนเป็นค่าของ String ที่ถูกต้องสมบูรณ์

การอัปเดตสตริง

ขนาดของ String สามารถขยายเพิ่มขึ้นได้ และข้อมูลภายในก็สามารถแก้ไขเปลี่ยนแปลงได้ เช่นเดียวกับ Vec<T> เมื่อคุณดันข้อมูลใหม่เข้าไปข้างใน นอกจากนี้ คุณยังสามารถใช้ตัวดำเนินการ + หรือมาโคร format! ในการเชื่อมต่อค่าของ String เข้าด้วยกันได้อย่างสะดวกง่ายดาย

การต่อท้ายด้วย push_str หรือ push

เราสามารถเพิ่มความยาวของ String ได้โดยการใช้เมธอด push_str เพื่อนำสตริงสไลซ์มาต่อท้าย ดังแสดงในลิสติ้ง 8-15

fn main() {
    let mut s = String::from("foo");
    s.push_str("bar");
}

หลังจากโค้ดสองบรรทัดนี้ทำงานเสร็จ ตัวแปร s จะมีข้อความภายในเป็น foobar โดยเมธอด push_str จะรับพารามิเตอร์เป็นสตริงสไลซ์ เพราะเราไม่จำเป็นต้องถ่ายโอนสิทธิ์ความเป็นเจ้าของ (ownership) ของพารามิเตอร์นั้นเข้ามา ตัวอย่างเช่น ในโค้ดของลิสติ้ง 8-16 เรายังต้องการนำตัวแปร s2 ไปใช้งานต่อได้ หลังจากที่นำเนื้อหาของมันไปต่อท้าย s1 แล้ว

fn main() {
    let mut s1 = String::from("foo");
    let s2 = "bar";
    s1.push_str(s2);
    println!("s2 is {s2}");
}

หากเมธอด push_str ยึดสิทธิ์ความเป็นเจ้าของของ s2 ไป เราก็จะไม่สามารถนำค่าของมันมาพิมพ์ในบรรทัดสุดท้ายได้อีก แต่โค้ดนี้สามารถทำงานได้อย่างถูกต้องตามที่เราคาดหวัง!

ส่วนเมธอด push จะรับพารามิเตอร์เป็นตัวอักขระเดี่ยวๆ เพียงหนึ่งตัว (char) แล้วนำไปต่อท้ายสตริง ในลิสติ้ง 8-17 เป็นการนำตัวอักษร l ไปต่อท้าย String โดยใช้เมธอด push

fn main() {
    let mut s = String::from("lo");
    s.push('l');
}

ผลลัพธ์ที่ได้คือตัวแปร s จะมีข้อความเป็น lol

การเชื่อมด้วย + หรือ format!

บ่อยครั้งที่คุณอาจต้องการนำสตริงสองตัวที่มีอยู่แล้วมารวมเข้าด้วยกัน วิธีหนึ่งที่ทำได้คือการใช้ตัวดำเนินการบวก (+) ดังที่แสดงในลิสติ้ง 8-18

fn main() {
    let s1 = String::from("Hello, ");
    let s2 = String::from("world!");
    let s3 = s1 + &s2; // note s1 has been moved here and can no longer be used
}

สตริง s3 จะมีข้อความเป็น Hello, world! สาเหตุที่ทำให้ s1 ไม่สามารถนำมาใช้งานได้อีกต่อไปหลังจากการบวก และสาเหตุที่เราต้องส่งเรเฟอเรนซ์ของ s2 เข้าไปนั้น มีความเกี่ยวข้องโดยตรงกับซิกเนเจอร์ของเมธอดที่ถูกเรียกทำงานเบื้องหลังเมื่อเราใช้ตัวดำเนินการ + โดยตัวดำเนินการ + จะเรียกใช้เมธอด add ซึ่งมีหน้าตาของซิกเนเจอร์ประมาณนี้:

fn add(self, s: &str) -> String {

ในไลบรารีมาตรฐานจริงๆ เมธอด add จะถูกนิยามขึ้นโดยใช้เจเนอริกและชนิดข้อมูลร่วม (associated types) แต่ในที่นี้เราแทนที่ด้วยชนิดข้อมูลรูปธรรมเพื่อให้เห็นภาพชัดเจน ซึ่งตรงกับสิ่งที่จะเกิดขึ้นเมื่อเราเรียกใช้เมธอดนี้กับค่าของ String (เราจะได้เรียนรู้เรื่องเจเนอริกในบทที่ 10) ซิกเนเจอร์นี้จะช่วยไขข้อข้องใจว่าเหตุใดตัวดำเนินการ + จึงมีพฤติกรรมเช่นนั้น

ประการแรก พารามิเตอร์ s2 มีเครื่องหมาย & นำหน้า ซึ่งหมายความว่าเรากำลังนำเรเฟอเรนซ์ของสตริงตัวที่สองไปบวกเข้ากับสตริงตัวแรก นั่นเป็นไปตามที่กำหนดไว้ในพารามิเตอร์ s ของฟังก์ชัน add: นั่นคือเราสามารถนำสตริงสไลซ์มาบวกต่อท้าย String ได้เท่านั้น แต่ไม่สามารถนำค่า String สองตัวมาบวกกันตรงๆ ได้ ทว่าคุณอาจสังเกตว่าชนิดข้อมูลของ &s2 จริงๆ แล้วคือ &String ไม่ใช่ &str ตามที่ระบุไว้ในพารามิเตอร์ตัวที่สองของ add แล้วเหตุใดโค้ดในลิสติ้ง 8-18 จึงคอมไพล์ผ่านได้ล่ะ?

สาเหตุที่เราสามารถส่ง &s2 เข้าไปในการเรียก add ได้ เป็นเพราะคอมไพเลอร์สามารถแปลงค่าอาร์กิวเมนต์จาก &String ให้กลายเป็น &str ได้โดยอัตโนมัติ เมื่อเราเรียกเมธอด add ทาง Rust จะใช้กลไกที่เรียกว่า deref coercion ซึ่งในกรณีนี้จะช่วยแปลง &s2 ให้กลายเป็น &s2[..] (เราจะได้พูดคุยเกี่ยวกับ deref coercion อย่างละเอียดในบทที่ 15) และเนื่องจาก add ไม่ได้ยึดสิทธิ์ความเป็นเจ้าของของพารามิเตอร์ s ไป ตัวแปร s2 จึงยังคงเป็น String ที่สามารถนำไปใช้งานต่อได้ตามปกติหลังจากการบวกนี้

ประการที่สอง เมื่อสังเกตในซิกเนเจอร์ของฟังก์ชัน จะเห็นว่า add รับความเป็นเจ้าของของ self ไป เนื่องจากตัวแปร self ไม่มี เครื่องหมาย & กำกับอยู่ ซึ่งหมายความว่าตัวแปร s1 ในลิสติ้ง 8-18 จะถูกย้ายกรรมสิทธิ์ (moved) เข้าไปในฟังก์ชัน add และจะไม่สามารถนำมาใช้งานได้อีกต่อไปหลังจากนั้น ดังนั้น แม้ว่าคำสั่ง let s3 = s1 + &s2; จะดูเหมือนการคัดลอกสตริงทั้งสองตัวเพื่อสร้างสตริงตัวที่สามขึ้นมาใหม่ แต่ในความเป็นจริงแล้ว สเตตเมนต์นี้จะยึดเอา s1 เข้าไป แล้วนำสำเนาของข้อความใน s2 มาต่อท้าย จากนั้นจึงส่งมอบกรรมสิทธิ์ของผลลัพธ์กลับออกมา ซึ่งการทำเช่นนี้มีประสิทธิภาพในการทำงานสูงกว่าการสร้างและคัดลอกข้อมูลใหม่ทั้งหมดหลายเท่า

อย่างไรก็ตาม หากเราจำเป็นต้องเชื่อมต่อสตริงหลายๆ ตัวเข้าด้วยกัน พฤติกรรมของตัวดำเนินการ + ก็จะเริ่มดูเกะกะและอ่านยาก:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = s1 + "-" + &s2 + "-" + &s3;
}

ณ จุดนี้ ตัวแปร s จะมีค่าเป็น tic-tac-toe แต่ด้วยเครื่องหมาย + และเครื่องหมายคำพูด " ที่กระจายอยู่เต็มไปหมด จึงทำให้ไล่อ่านและทำความเข้าใจได้ยากว่าเกิดอะไรขึ้น สำหรับการนำสตริงหลายตัวมารวมกันในลักษณะนี้ เราสามารถเปลี่ยนมาใช้มาโคร format! แทนได้อย่างสวยงาม:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = format!("{s1}-{s2}-{s3}");
}

โค้ดนี้ก็กำหนดค่าให้ s เป็น tic-tac-toe เช่นเดียวกัน โดยมาโคร format! จะทำงานคล้ายกับ println! ทุกประการ เพียงแต่แทนที่จะพิมพ์ข้อความออกทางหน้าจอ มันจะสร้างและส่งค่า String ที่บรรจุข้อความดังกล่าวกลับออกมาแทน โค้ดเวอร์ชันที่ใช้ format! จะอ่านทำความเข้าใจได้ง่ายกว่ามากอย่างเห็นได้ชัด และโค้ดที่มาโคร format! สร้างขึ้นจะทำงานผ่านเรเฟอเรนซ์ทั้งหมด การเรียกคำสั่งนี้จึงไม่มีการยึดสิทธิ์ความเป็นเจ้าของของพารามิเตอร์ตัวใดไปเลย

การจัดดัชนีสตริง

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

fn main() {
    let s1 = String::from("hi");
    let h = s1[0];
}

โค้ดนี้จะส่งผลให้คอมไพเลอร์แจ้งข้อผิดพลาดดังต่อไปนี้:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0277]: the type `str` cannot be indexed by `{integer}`
 --> src/main.rs:3:16
  |
3 |     let h = s1[0];
  |                ^ string indices are ranges of `usize`
  |
  = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
  = note: you can use `.chars().nth()` or `.bytes().nth()`
          for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
help: `usize` implements trait `SliceIndex<T>`
 --> /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/slice/index.rs:179:0
  |
  = note: `SliceIndex<[T]>`
 --> /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/bstr/traits.rs:197:0
  |
  = note: `SliceIndex<ByteStr>`
  = note: required for `String` to implement `Index<{integer}>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `collections` (bin "collections") due to 1 previous error

ข้อความผิดพลาดนี้บอกเรื่องราวไว้อย่างชัดเจนว่า: สตริงในภาษา Rust ไม่รองรับการเข้าถึงผ่านดัชนี แต่ทำไมถึงเป็นเช่นนั้นล่ะ? ในการตอบคำถามนี้ เราจำเป็นต้องทำความเข้าใจวิธีการที่ Rust จัดเก็บสตริงไว้ในหน่วยความจำเสียก่อน

การแทนข้อมูลภายใน

แท้จริงแล้ว String คือตัวห่อหุ้มที่ครอบอยู่เหนือ Vec<u8> ลองมาดูตัวอย่างข้อความที่เข้ารหัส UTF-8 อย่างถูกต้องจากลิสติ้ง 8-14 กัน เริ่มจากข้อความนี้:

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

ในกรณีนี้ ค่า len จะมีค่าเท่ากับ 4 ซึ่งหมายความว่าเวกเตอร์ที่จัดเก็บสตริง "Hola" มีความยาวเท่ากับ 4 ไบต์ เนื่องจากตัวอักษรละตินแต่ละตัวจะใช้พื้นที่จัดเก็บ 1 ไบต์พอดีเมื่อเข้ารหัสด้วย UTF-8 แต่บรรทัดถัดไปนี้อาจทำให้คุณประหลาดใจ (โปรดสังเกตว่าสตริงนี้เริ่มต้นด้วยตัวอักษรซีริลลิกตัวพิมพ์ใหญ่ Ze ไม่ใช่เลข 3):

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

หากมีคนถามคุณว่าข้อความนี้มีความยาวกี่ตัวอักษร คุณอาจตอบว่า 12 ตัว แต่ในความเป็นจริงแล้ว คำตอบของ Rust คือ 24 ไบต์: นั่นคือจำนวนไบต์ที่ต้องใช้ในการเข้ารหัสคำว่า “Здравствуйте” ในแบบ UTF-8 เนื่องจากค่าสเกลาร์ยูนิโคดแต่ละตัวในข้อความนี้ ต้องใช้พื้นที่จัดเก็บถึง 2 ไบต์ ดังนั้น ตำแหน่งดัชนีไบต์ในสตริงจึงไม่ได้ตรงกับตัวอักษรยูนิโคดที่สมบูรณ์เสมอไป เพื่อสาธิตให้เห็นภาพ ลองพิจารณาโค้ดที่ไม่ถูกต้องด้านล่างนี้:

let hello = "Здравствуйте";
let answer = &hello[0];

คุณคงพอเดาได้แล้วว่า answer จะไม่ได้เป็นตัวอักษร З อย่างแน่นอน เพราะเมื่อเข้ารหัสเป็น UTF-8 ไบต์แรกของ З คือ 208 และไบต์ที่สองคือ 151 ดังนั้นหากดึงค่าออกมาได้ answer ก็ควรจะเป็นตัวเลข 208 แต่ 208 เพียงโดดๆ นั้นไม่ใช่ตัวอักษรที่สมบูรณ์และถูกต้องในตัวเองเลย การส่งค่า 208 กลับออกมาย่อมไม่ใช่สิ่งที่ผู้ใช้ต้องการเมื่อพวกเขาต้องการตัวอักษรตัวแรกของข้อความนี้อย่างแน่นอน แต่ทว่านั่นคือข้อมูลเพียงสิ่งเดียวที่ Rust มีอยู่ที่ตำแหน่งไบต์ดัชนีที่ 0 โดยทั่วไปแล้วผู้ใช้ย่อมไม่ต้องการให้โปรแกรมส่งค่าไบต์ดิบกลับออกมา แม้ว่าข้อความนั้นจะมีแต่ตัวอักษรภาษาอังกฤษก็ตาม: เพราะหากคำสั่งอย่าง &"hi"[0] ใช้งานได้จริงและคืนค่าไบต์ออกมา มันก็จะได้ค่าเป็น 104 ไม่ใช่ตัวอักษร h

ดังนั้น คำตอบก็คือ เพื่อหลีกเลี่ยงการส่งค่าที่ไม่ตรงกับความคาดหวังกลับออกมา ซึ่งอาจกลายเป็นบั๊กที่ตรวจพบได้ยากในภายหลัง Rust จึงเลือกที่จะไม่อนุญาตให้คอมไพล์โค้ดประเภทนี้ผ่านเลยตั้งแต่แรก เพื่อช่วยตัดไฟแต่ต้นลมตั้งแต่ในขั้นตอนการพัฒนา

ไบต์ ค่าสเกลาร์ และกลุ่มกราฟีม

อีกประเด็นหนึ่งที่สำคัญเกี่ยวกับ UTF-8 ก็คือ ในมุมมองของภาษา Rust นั้น มีวิธีการมองข้อมูลสตริงที่เกี่ยวข้องอยู่ 3 มุมมองด้วยกัน: นั่นคือมองเป็น ไบต์ (bytes), มองเป็น ค่าสเกลาร์ (scalar values) และมองเป็น กลุ่มกราฟีม (grapheme clusters - ซึ่งเป็นสิ่งที่ใกล้เคียงกับคำว่า ตัวอักษร ในสายตามนุษย์มากที่สุด)

หากเราลองดูคำในภาษาฮินดีว่า “नमस्ते” ซึ่งเขียนด้วยอักษรเทวนาครี มันจะถูกจัดเก็บไว้ในหน่วยความจำเป็นเวกเตอร์ของค่า u8 ดังนี้:

[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]

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

['न', 'म', 'स', '्', 'त', 'े']

ตรงนี้จะมีค่า char ทั้งหมด 6 ตัว แต่ตัวที่ 4 และตัวที่ 6 ไม่ใช่ตัวพยัญชนะเดี่ยวๆ: หากแต่เป็นเครื่องหมายวรรณยุกต์หรือสระผสม (diacritics) ที่ไม่สามารถสื่อความหมายได้ด้วยตัวเอง และสุดท้าย หากเรามองพวกมันในฐานะกลุ่มกราฟีม (grapheme clusters) เราก็จะได้สิ่งที่มนุษย์ทั่วไปมองเห็นเป็นตัวอักษร 4 ตัวที่ประกอบกันเป็นคำภาษาฮินดีนี้:

["न", "म", "स्", "ते"]

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

และเหตุผลประการสุดท้ายที่ Rust ไม่อนุญาตให้เราเข้าถึงตัวอักษรใน String ผ่านดัชนีได้ ก็คือ โดยทั่วไปแล้วการเข้าถึงผ่านดัชนีจะถูกคาดหวังว่าต้องใช้เวลาคงที่ระดับ O(1) เสมอ แต่สำหรับ String นั้น Rust ไม่สามารถการันตีประสิทธิภาพระดับดังกล่าวได้เลย เพราะ Rust จะต้องคอยไล่อ่านข้อมูลตั้งแต่ต้นข้อความไปจนถึงตำแหน่งดัชนี เพื่อตรวจสอบว่ามีตัวอักษรที่สมบูรณ์อยู่กี่ตัว

การสไลซ์สตริง

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

แทนที่จะใช้เครื่องหมายก้ามปู [] กับตัวเลขเดี่ยวๆ คุณสามารถใช้ [] ร่วมกับช่วง (range) เพื่อตัดแบ่งสตริงสไลซ์ที่ครอบคลุมช่วงของไบต์ที่ต้องการออกมาได้:

#![allow(unused)]
fn main() {
let hello = "Здравствуйте";

let s = &hello[0..4];
}

ในตัวอย่างนี้ s จะมีชนิดข้อมูลเป็น &str ที่บรรจุข้อมูล 4 ไบต์แรกของข้อความ และเนื่องจากเราทราบมาก่อนหน้านี้แล้วว่าอักษรแต่ละตัวในข้อความนี้ใช้พื้นที่ 2 ไบต์ นั่นหมายความว่าค่าของ s ก็คือ Зд

แต่หากเราพยายามตัดแบ่งสตริงเพียงแค่บางส่วนของไบต์ที่ประกอบเป็นตัวอักษร เช่น เขียนว่า &hello[0..1] ตัว Rust จะเกิดการแพนิก (panic) ในตอนรันไทม์ทันที ในลักษณะเดียวกับเมื่อมีการเข้าถึงดัชนีที่อยู่นอกช่วงในเวกเตอร์:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/collections`

thread 'main' (6017738) panicked at src/main.rs:4:19:
end byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2 of string)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

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

การวนซ้ำบนสตริง

วิธีที่ดีที่สุดในการจัดการกับส่วนประกอบย่อยๆ ของสตริง คือการระบุอย่างชัดเจนว่าคุณต้องการแยกเป็นรายตัวอักษรหรือแยกเป็นรายไบต์ หากคุณต้องการทำงานกับค่าสเกลาร์ยูนิโคดแต่ละตัว ให้เรียกใช้เมธอด chars โดยการเรียก chars บนข้อความ “Зд” จะแยกและส่งค่าชนิด char 2 ตัวกลับออกมา ซึ่งคุณสามารถวนลูปเพื่อเข้าถึงสมาชิกแต่ละตัวได้ดังนี้:

#![allow(unused)]
fn main() {
for c in "Зд".chars() {
    println!("{c}");
}
}

โค้ดนี้จะพิมพ์ผลลัพธ์ออกมาดังนี้:

З
д

หรืออีกทางเลือกหนึ่ง หากงานของคุณต้องการข้อมูลในระดับไบต์ดิบ เมธอด bytes ก็จะส่งแต่ละไบต์กลับออกมา ซึ่งอาจเหมาะสมกับโดเมนงานของคุณมากกว่า:

#![allow(unused)]
fn main() {
for b in "Зд".bytes() {
    println!("{b}");
}
}

โค้ดนี้จะพิมพ์ค่าทั้ง 4 ไบต์ที่ประกอบกันเป็นข้อความนี้ออกมา:

208
151
208
180

แต่โปรดจำไว้เสมอว่า ค่าสเกลาร์ยูนิโคดที่ถูกต้องหนึ่งตัว อาจประกอบขึ้นจากข้อมูลมากกว่า 1 ไบต์

ส่วนการดึงข้อมูลออกมาเป็นกลุ่มกราฟีม (grapheme clusters) จากสตริง เช่น ในกรณีของอักษรเทวนาครีนั้น มีความซับซ้อนอย่างมาก ไลบรารีมาตรฐานของ Rust จึงไม่ได้รวมฟังก์ชันการทำงานนี้ไว้ในตัว แต่คุณสามารถค้นหาเครตที่มีฟังก์ชันดังกล่าวมาใช้งานได้จาก crates.io หากโปรเจกต์ของคุณต้องการความสามารถนี้

การจัดการความซับซ้อนของสตริง

โดยสรุปแล้ว เรื่องของสตริงนั้นมีความซับซ้อนอย่างยิ่ง ภาษาโปรแกรมแต่ละภาษาต่างก็เลือกแนวทางในการนำเสนอความซับซ้อนนี้แก่โปรแกรมเมอร์แตกต่างกันไป แต่สำหรับภาษา Rust นั้น ได้เลือกที่จะให้ความถูกต้องแม่นยำในการจัดการข้อมูล String เป็นพฤติกรรมเริ่มต้นของโปรแกรมทุกโปรแกรม ซึ่งหมายความว่าโปรแกรมเมอร์จะต้องใส่ใจและคิดทบทวนเกี่ยวกับการจัดการข้อมูล UTF-8 อย่างรอบคอบตั้งแต่ขั้นตอนแรก แม้ว่าการแลกเปลี่ยนนี้จะทำให้เราต้องเผชิญกับความซับซ้อนของสตริงอย่างตรงไปตรงมามากกว่าภาษาอื่นๆ แต่ก็ช่วยป้องกันไม่ให้คุณต้องไปปวดหัวกับข้อผิดพลาดที่เกี่ยวกับอักขระที่ไม่ใช่ ASCII ในช่วงท้ายของการพัฒนาซอฟต์แวร์

และข่าวดีก็คือ ไลบรารีมาตรฐานของ Rust ได้จัดเตรียมฟังก์ชันและเมธอดที่มีประโยชน์มากมายที่สร้างขึ้นบนชนิดข้อมูล String และ &str เพื่อช่วยให้คุณสามารถจัดการกับสถานการณ์ที่ซับซ้อนเหล่านี้ได้อย่างถูกต้องและปลอดภัย อย่าลืมศึกษาเอกสารประกอบเพื่อค้นหาเมธอดดีๆ เช่น contains สำหรับค้นหาข้อความภายในสตริง หรือ replace สำหรับแทนที่ข้อความบางส่วนด้วยข้อความอื่น

คราวนี้ เราลองมาดูคอลเลกชันอีกตัวที่มีความซับซ้อนน้อยกว่ากันดีกว่า: นั่นคือ แฮชแมป (hash maps)!