เก็บข้อความที่เข้ารหัส 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)!