เป็นไปได้มากที่คุณจะได้เห็นข้อยกเว้นของ Ruby เช่น UndefinedConversionError หรือ IncompatibleCharacterEncodings . มีโอกาสน้อยที่คุณจะเข้าใจความหมายของข้อยกเว้น บทความนี้จะช่วย คุณจะได้เรียนรู้วิธีการทำงานของการเข้ารหัสอักขระและการใช้งานใน Ruby ในตอนท้าย คุณจะสามารถเข้าใจและแก้ไขข้อผิดพลาดเหล่านี้ได้ง่ายขึ้น
แล้ว "การเข้ารหัสอักขระ" คืออะไร?
ในทุกภาษาโปรแกรม คุณทำงานกับสตริง บางครั้งคุณประมวลผลเป็นอินพุต บางครั้งคุณแสดงเป็นเอาต์พุต แต่คอมพิวเตอร์ของคุณไม่เข้าใจ "สตริง" มันเข้าใจเฉพาะบิต:1s และ 0s กระบวนการแปลงสตริงเป็นบิตเรียกว่าการเข้ารหัสอักขระ
แต่การเข้ารหัสอักขระไม่ได้เป็นเพียงในยุคของคอมพิวเตอร์เท่านั้น เราสามารถเรียนรู้จากกระบวนการที่ง่ายกว่าก่อนจะมีคอมพิวเตอร์:รหัสมอร์ส
รหัสมอร์ส
รหัสมอร์สนั้นง่ายมากในคำจำกัดความ คุณมีสองสัญลักษณ์หรือวิธีในการสร้างสัญญาณ (สั้นและยาว) ด้วยสัญลักษณ์ทั้งสองนี้ แสดงว่าคุณเป็นตัวแทนของตัวอักษรภาษาอังกฤษอย่างง่าย ตัวอย่างเช่น:
- A คือ .- (หนึ่งเครื่องหมายสั้นและหนึ่งเครื่องหมายยาว)
- E คือ . (หนึ่งเครื่องหมายสั้น)
- O คือ --- (เครื่องหมายยาวสามขีด)
ระบบนี้ถูกประดิษฐ์ขึ้นเมื่อราวปี พ.ศ. 2380 และอนุญาตให้เข้ารหัสทั้งตัวอักษรได้โดยใช้สัญลักษณ์หรือสัญญาณเพียงสองตัว
คุณสามารถเล่นกับนักแปลออนไลน์หนึ่งคนได้ที่นี่
ในภาพ คุณจะเห็น "ตัวเข้ารหัส" ซึ่งเป็นบุคคลที่รับผิดชอบในการเข้ารหัสและถอดรหัสข้อความ สิ่งนี้จะเปลี่ยนแปลงในไม่ช้าเมื่อมีการมาถึงของคอมพิวเตอร์
จากการเข้ารหัสด้วยตนเองเป็นการเข้ารหัสอัตโนมัติ
ในการเข้ารหัสข้อความ คุณต้องให้บุคคลแปลอักขระเป็นสัญลักษณ์ด้วยตนเองตามอัลกอริทึมของรหัสมอร์ส
คล้ายกับรหัสมอร์ส คอมพิวเตอร์ใช้ "สัญลักษณ์" เพียงสองตัวเท่านั้น:1 และ 0 คุณสามารถจัดเก็บลำดับของสิ่งเหล่านี้ในคอมพิวเตอร์เท่านั้น และเมื่ออ่านแล้ว จะต้องตีความในลักษณะที่เหมาะสมกับผู้ใช้
กระบวนการทำงานในลักษณะนี้ในทั้งสองกรณี:
Message -> Encoding -> Store/Send -> Decoding -> Message
SOS ในรหัสมอร์สจะเป็น:
SOS -> Encode('SOS') -> ...---... -> Decode('...---...') -> SOS
----------------------- --------------------------
Sender Receiver
การเปลี่ยนแปลงครั้งใหญ่ของคอมพิวเตอร์และเทคโนโลยีอื่นๆ คือกระบวนการเข้ารหัสและถอดรหัสเป็นแบบอัตโนมัติ เราจึงไม่ต้องการคนในการแปลข้อมูลอีกต่อไป
เมื่อมีการประดิษฐ์คอมพิวเตอร์ มาตรฐานแรกเริ่มที่สร้างขึ้นเพื่อแปลงอักขระเป็น 1 และ 0 โดยอัตโนมัติ (แต่ไม่ใช่มาตรฐานแรก) คือ ASCII
ASCII ย่อมาจาก American Standard Code สำหรับการแลกเปลี่ยนข้อมูล ส่วน "อเมริกัน" มีบทบาทสำคัญในการทำงานของคอมพิวเตอร์กับข้อมูลในบางครั้ง เราจะเห็นเหตุผลในหัวข้อถัดไป
ASCII (1963)
จากความรู้เกี่ยวกับรหัสโทรเลข เช่น รหัสมอร์สและคอมพิวเตอร์ยุคแรกๆ มาตรฐานสำหรับการเข้ารหัสและถอดรหัสอักขระในคอมพิวเตอร์ถูกสร้างขึ้นเมื่อประมาณปี 2506 ระบบนี้ค่อนข้างง่าย เนื่องจากในตอนแรกมีอักขระเพียง 127 ตัว ตัวอักษรภาษาอังกฤษพร้อมสัญลักษณ์พิเศษ
ASCII ทำงานโดยเชื่อมโยงอักขระแต่ละตัวกับตัวเลขทศนิยมที่สามารถแปลเป็นรหัสไบนารีได้ มาดูตัวอย่างกัน:
"A" คือ 65 ใน ASCII ดังนั้นเราจึงต้องแปล 65 เป็นรหัสไบนารี
หากคุณไม่รู้ว่ามันทำงานอย่างไร นี่เป็นวิธีด่วน :เราเริ่มหาร 65 ด้วย 2 และดำเนินต่อไปจนกว่าจะได้ 0 หากการหารไม่แน่นอน เราจะบวก 1 เป็นเศษ:
65 / 2 = 32 + 1
32 / 2 = 16 + 0
16 / 2 = 8 + 0
8 / 2 = 4 + 0
4 / 2 = 2 + 0
2 / 2 = 1 + 0
1 / 2 = 0 + 1
ตอนนี้ เรานำเศษที่เหลือมาเรียงตามลำดับผกผัน:
1000001
ดังนั้น เราจะเก็บ "A" เป็น "1000001" ด้วยการเข้ารหัส ASCII ดั้งเดิม ซึ่งปัจจุบันรู้จักกันในชื่อ US-ASCII ทุกวันนี้ ด้วยคอมพิวเตอร์ 8 บิตทั่วไป มันจะเป็น 01000001 (8 บิต =1 ไบต์)
เราทำตามขั้นตอนเดียวกันสำหรับอักขระแต่ละตัว ดังนั้นด้วย 7 บิต เราจึงสามารถจัดเก็บอักขระได้ถึง 2^7 ตัว =127
นี่คือตารางทั้งหมด:
(จาก https://www.plcdev.com/ascii_chart)
ปัญหาเกี่ยวกับ ASCII
จะเกิดอะไรขึ้นถ้าเราต้องการเพิ่มอักขระอื่น เช่น ภาษาฝรั่งเศส ç หรืออักขระภาษาญี่ปุ่น 大
ใช่ เราจะมีปัญหา
หลังจาก ASCII ผู้คนพยายามแก้ปัญหานี้ด้วยการสร้างระบบเข้ารหัสของตนเอง พวกเขาใช้บิตมากขึ้น แต่ในที่สุดก็ทำให้เกิดปัญหาอื่น
ปัญหาหลักคือเมื่ออ่านไฟล์ คุณไม่รู้ว่าคุณมีระบบเข้ารหัสหรือไม่ ความพยายามที่จะตีความด้วยการเข้ารหัสที่ไม่ถูกต้องส่งผลให้เกิดการพูดพล่อยๆ เช่น "���" หรือ "Ã,ÂÂÃ'Â"
วิวัฒนาการของระบบการเข้ารหัสเหล่านี้มีขนาดใหญ่และกว้าง ขึ้นอยู่กับภาษา คุณมีระบบที่แตกต่างกัน ภาษาที่มีอักขระมากขึ้น เช่น ภาษาจีน ต้องพัฒนาระบบที่ซับซ้อนมากขึ้นเพื่อเข้ารหัสตัวอักษร
หลังจากดิ้นรนกับสิ่งนี้มาหลายปี มาตรฐานใหม่ก็ถูกสร้างขึ้น:Unicode มาตรฐานนี้กำหนดวิธีที่คอมพิวเตอร์สมัยใหม่เข้ารหัสและถอดรหัสข้อมูล
Unicode (1988)
เป้าหมายของ Unicode นั้นง่ายมาก ตามเว็บไซต์อย่างเป็นทางการ:"เพื่อให้หมายเลขเฉพาะสำหรับตัวละครทุกตัว ไม่ว่าจะเป็นแพลตฟอร์ม โปรแกรม หรือภาษาใดก็ตาม"
ดังนั้นอักขระแต่ละตัวในภาษาจึงมีการกำหนดรหัสที่ไม่ซ้ำกัน หรือที่เรียกว่าโค้ดพอยต์ ขณะนี้มีอักขระมากกว่า 137,000 ตัว
ในส่วนหนึ่งของมาตรฐาน Unicode เรามีวิธีต่างๆ ในการเข้ารหัสค่าหรือจุดโค้ดเหล่านั้น แต่ UTF-8 นั้นครอบคลุมมากที่สุด
Rob Pike และ Ken Thompson ผู้สร้างภาษาการเขียนโปรแกรม Go ก็สร้าง UTF-8 เช่นกัน มันประสบความสำเร็จเพราะมันมีประสิทธิภาพและฉลาดในการเข้ารหัสตัวเลขเหล่านั้น มาดูกันว่าทำไมกันชัดๆ
UTF-8:รูปแบบการแปลง Unicode (1993)
UTF-8 เป็นการเข้ารหัสโดยพฤตินัยสำหรับเว็บไซต์แล้ว (มากกว่า 94% ของเว็บไซต์ใช้การเข้ารหัสนั้น) นอกจากนี้ยังเป็นการเข้ารหัสเริ่มต้นสำหรับภาษาการเขียนโปรแกรมและไฟล์ต่างๆ เหตุใดจึงประสบความสำเร็จและทำงานอย่างไร
UTF-8 เช่นเดียวกับระบบการเข้ารหัสอื่นๆ จะเปลี่ยนตัวเลขที่กำหนดใน Unicode เป็นไบนารีเพื่อจัดเก็บไว้ในคอมพิวเตอร์
มีสองแง่มุมที่สำคัญมากของ UTF-8:- มีประสิทธิภาพเมื่อจัดเก็บบิต เนื่องจากอักขระสามารถมีขนาดตั้งแต่ 1 ถึง 4 ไบต์ - โดยใช้ Unicode และจำนวนไบต์แบบไดนามิก จึงเข้ากันได้กับการเข้ารหัส ASCII เนื่องจาก 127 ตัวแรก อักขระใช้เวลา 1 ไบต์ ซึ่งหมายความว่าคุณสามารถเปิดไฟล์ ASCII เป็น UTF-8 ได้
มาดูกันว่า UTF-8 ทำงานอย่างไร
UTF-8 ที่มี 1 ไบต์
ขึ้นอยู่กับค่าในตาราง Unicode UTF-8 ใช้จำนวนอักขระต่างกัน
ด้วย 127 ตัวแรก จะใช้เทมเพลตต่อไปนี้:Rust1
0_______
ดังนั้น 0 จะอยู่ที่นั่นเสมอ ตามด้วยเลขฐานสองที่แสดงค่าใน Unicode (ซึ่งจะเป็น ASCII ด้วย) ตัวอย่างเช่น:A =65 =1000001
ตรวจสอบสิ่งนี้กับ Ruby โดยใช้วิธีการแกะใน String:
'A'.unpack('B*').first
# 01000001
B หมายความว่าเราต้องการรูปแบบไบนารีที่มีบิตที่สำคัญที่สุดก่อน ในบริบทนี้ นั่นหมายถึงบิตที่มีค่าสูงสุด เครื่องหมายดอกจันบอกให้ Ruby ทำต่อไปจนกว่าจะไม่มีบิตเหลือ หากเราใช้ตัวเลขแทน เราจะได้บิตถึงตัวเลขนั้นเท่านั้น:
'A'.unpack('B4').first
# 01000
UTF-8 ที่มี 2 ไบต์
หากเรามีอักขระที่มีค่าหรือจุดโค้ดใน Unicode เกิน 127 ถึง 2047 เราจะใช้สองไบต์กับเทมเพลตต่อไปนี้:
110_____ 10______
ดังนั้นเราจึงมี 11 บิตว่างสำหรับค่าใน Unicode มาดูตัวอย่างกัน:
À คือ 192 ใน Unicode ดังนั้นในไบนารีคือ 11000000 โดยใช้ 8 บิต ไม่พอดีกับเทมเพลตแรก เราจึงใช้เทมเพลตที่สอง:
110_____ 10______
เราเริ่มเติมช่องว่างจากขวาไปซ้าย:
110___11 10000000
จะเกิดอะไรขึ้นกับบิตที่ว่างเปล่าที่นั่น? เราแค่ใส่ 0 ดังนั้นผลลัพธ์สุดท้ายคือ:11000011 10000000
เราสามารถเริ่มเห็นรูปแบบที่นี่ ถ้าเราเริ่มอ่านจากซ้ายไปขวา กลุ่มแรกที่มี 8 บิตจะมีเลข 1 สองตัวที่จุดเริ่มต้น นี่หมายความว่าตัวละครจะใช้ 2 ไบต์:
11000011 10000000
--
อีกครั้งเราสามารถตรวจสอบสิ่งนี้กับ Ruby:
'À'.unpack('B*').first
# 1100001110000000
เคล็ดลับเล็กๆ น้อยๆ ที่นี่คือ เราสามารถจัดรูปแบบผลลัพธ์ได้ดีขึ้นด้วย:
'À'.unpack('B8 B8').join(' ')
# 11000011 10000000
เราได้รับอาร์เรย์จาก 'À'.unpack('B8 B8') จากนั้นเรารวมองค์ประกอบด้วยช่องว่างเพื่อรับสตริง 8s ในพารามิเตอร์ unpack บอกให้ Ruby รับ 8 บิตใน 2 กลุ่ม
UTF-8 ที่มี 3 ไบต์
หากค่าใน Unicode สำหรับอักขระไม่พอดีกับ 11 บิตที่มีอยู่ในเทมเพลตก่อนหน้า เราจำเป็นต้องมีไบต์พิเศษ:
1110____ 10______ 10______
อีกครั้ง 1 สามตัวที่จุดเริ่มต้นของเทมเพลตบอกเราว่าเรากำลังจะอ่านอักขระ 3 ไบต์
กระบวนการเดียวกันนี้จะนำไปใช้กับเทมเพลตนี้ เปลี่ยนค่า Unicode เป็นไบนารีและเริ่มเติมช่องจากขวาไปซ้าย หากเรามีพื้นที่ว่างหลังจากนั้น ให้เติม 0s
UTF-8 ที่มี 4 ไบต์
ค่าบางค่าใช้เวลามากกว่า 11 บิตว่างที่เรามีในเทมเพลตก่อนหน้า มาดูตัวอย่างด้วยอิโมจิ 🙂 ซึ่งสำหรับ Unicode ยังสามารถเห็นเป็นอักขระเช่น "a" หรือ "大" ได้
ค่าหรือจุดโค้ดของ "🙂" ใน Unicode คือ 128578 ตัวเลขที่เป็นเลขฐานสองคือ:11111011001000010 17 บิต ซึ่งหมายความว่าไม่พอดีกับเทมเพลต 3 ไบต์ เนื่องจากเรามีช่องว่างเพียง 16 ช่อง เราจึงต้องใช้เทมเพลตใหม่ที่ใช้หน่วยความจำ 4 ไบต์:
11110___ 10______ 10______ 10______
เราเริ่มต้นอีกครั้งโดยเติมตัวเลขเป็นไบนารี:Rust1
11110___ 10_11111 10011001 10000010
และตอนนี้ เราเติมส่วนที่เหลือด้วย 0s:Rust1
1111000 10011111 10011001 10000010
มาดูกันว่าจะหน้าตาเป็นอย่างไรใน Ruby
เนื่องจากเราทราบแล้วว่าการดำเนินการนี้จะใช้เวลา 4 ไบต์ เราจึงสามารถเพิ่มประสิทธิภาพเพื่อให้อ่านเอาต์พุตได้ดีขึ้น:
'🙂'.unpack('B8 B8 B8 B8').join(' ')
# 11110000 10011111 10011001 10000010
แต่ถ้าไม่ใช่ เราก็สามารถใช้:
'🙂'.unpack('B*')
เราอาจใช้วิธีสตริง "ไบต์" เพื่อแยกไบต์ลงในอาร์เรย์:
"🙂".bytes
# [240, 159, 153, 130]
จากนั้น เราสามารถแมปองค์ประกอบเป็นไบนารีด้วย:
"🙂".bytes.map {|e| e.to_s 2}
# ["11110000", "10011111", "10011001", "10000010"]
และถ้าเราต้องการสตริง เราก็สามารถใช้ join:
"🙂".bytes.map {|e| e.to_s 2}.join(' ')
# 11110000 10011111 10011001 10000010
UTF-8 มีพื้นที่มากกว่าที่จำเป็นสำหรับ Unicode
อีกแง่มุมที่สำคัญของ UTF-8 คือสามารถรวมค่า Unicode ทั้งหมด (หรือจุดโค้ด) ได้ และไม่เพียงแต่ค่าที่มีอยู่ในปัจจุบัน แต่ยังรวมถึงค่าที่จะมีอยู่ในอนาคตด้วย
นี่เป็นเพราะใน UTF-8 ด้วยเทมเพลต 4 ไบต์ เรามี 21 ช่องให้เติม นั่นหมายความว่าเราสามารถจัดเก็บค่าได้ถึง 2^21 (=2,097,152) ค่า ซึ่งมากกว่าค่า Unicode จำนวนมากที่สุดที่เราเคยมีในมาตรฐานนี้ ประมาณ 1.1 ล้านค่า
ซึ่งหมายความว่าเราสามารถใช้ UTF-8 ด้วยความมั่นใจว่าเราไม่ต้องเปลี่ยนไปใช้ระบบเข้ารหัสอื่นในอนาคตเพื่อจัดสรรอักขระหรือภาษาใหม่
การทำงานกับการเข้ารหัสต่างๆ ใน Ruby
ใน Ruby เราสามารถเห็นการเข้ารหัสของสตริงที่กำหนดได้ทันทีโดยทำดังนี้:
'Hello'.encoding.name
# "UTF-8"
เราสามารถเข้ารหัสสตริงด้วยระบบเข้ารหัสอื่นได้ ตัวอย่างเช่น:
encoded_string = 'hello, how are you?'.encode("ISO-8859-1", "UTF-8")
encoded_string.encoding.name
# ISO-8859-1
หากการแปลงไม่เข้ากัน เราได้รับข้อผิดพลาดตามค่าเริ่มต้น สมมติว่าเราต้องการแปลง "สวัสดี 🙂" จาก UTF-8 เป็น ASCII เนื่องจากอิโมจิ "🙂" ไม่เข้ากับ ASCII เราจึงทำไม่ได้ Ruby ทำให้เกิดข้อผิดพลาดในกรณีนั้น:
"hello 🙂".encode("ASCII", "UTF-8")
# Encoding::UndefinedConversionError (U+1F642 from UTF-8 to US-ASCII)
แต่ Ruby อนุญาตให้เรามีข้อยกเว้น ซึ่งหากไม่สามารถเข้ารหัสอักขระได้ เราสามารถแทนที่ด้วย "?"
"hello 🙂".encode("ASCII", "UTF-8", undef: :replace)
# hello ?
นอกจากนี้เรายังมีตัวเลือกในการแทนที่อักขระบางตัวด้วยอักขระที่ถูกต้องในการเข้ารหัสใหม่:
"hello 🙂".encode("ASCII", "UTF-8", fallback: {"🙂" => ":)"})
# hello :)
การตรวจสอบการเข้ารหัสสคริปต์ของสคริปต์ใน Ruby
หากต้องการดูการเข้ารหัสของไฟล์สคริปต์ที่คุณกำลังใช้งาน ไฟล์ ".rb" คุณสามารถทำสิ่งต่อไปนี้:
__ENCODING__
# This will show "#<Encoding:UTF-8>" in my case.
ตั้งแต่ Ruby 2.0 เป็นต้นไป การเข้ารหัสเริ่มต้นสำหรับสคริปต์ Ruby คือ UTF-8 แต่คุณสามารถเปลี่ยนได้โดยใช้ความคิดเห็นในบรรทัดแรก:
# encoding: ASCII
__ENCODING__
# #<Encoding:US-ASCII>
แต่จะดีกว่าถ้าใช้มาตรฐาน UTF-8 เว้นแต่คุณจะมีเหตุผลที่ดีในการเปลี่ยนแปลง
เคล็ดลับบางประการสำหรับการทำงานกับการเข้ารหัสใน Ruby
คุณสามารถดูรายการการเข้ารหัสที่รองรับทั้งหมดใน Ruby ได้ด้วย Encoding.name_list . สิ่งนี้จะส่งคืนอาร์เรย์ขนาดใหญ่:
["ASCII-8BIT", "UTF-8", "US-ASCII", "UTF-16BE", "UTF-16LE", "UTF-32BE", "UTF-32LE", "UTF-16", "UTF-32", "UTF8-MAC"...
สิ่งสำคัญอีกประการหนึ่งเมื่อทำงานกับอักขระนอกภาษาอังกฤษคือก่อน Ruby 2.4 วิธีการบางอย่างเช่น upcase หรือ reverse ไม่ทำงานตามที่คาดไว้ ตัวอย่างเช่น ใน Ruby 2.3 ค่า upcase ไม่ทำงานอย่างที่คุณคิด:
# Ruby 2.3
'öıüëâñà'.upcase
# 'öıüëâñà'
วิธีแก้ปัญหาคือใช้ ActiveSupport จาก Rails หรืออัญมณีภายนอกอื่น แต่เนื่องจาก Ruby 2.4 เราจึงมีการแมปกรณี Unicode แบบเต็ม:
# From Ruby 2.4 and up
'öıüëâñà'.upcase
# 'ÖIÜËÂÑÀ'
สนุกกับอีโมจิ
มาดูกันว่าอิโมจิทำงานอย่างไรใน Unicode และ Ruby:
'🖖'.chars
# ["🖖"]
นี่คือ "มือที่ชูขึ้นโดยมีส่วนระหว่างนิ้วกลางและนิ้วนาง" หรือที่รู้จักในชื่ออิโมจิ "Vulcan Salute" หากเรามีอิโมจิเดียวกันแต่ในโทนสีผิวอื่นที่ไม่ใช่ค่าเริ่มต้น สิ่งที่น่าสนใจจะเกิดขึ้น:
'🖖🏾'.chars
# ["🖖", "🏾"]
ดังนั้น แทนที่จะเป็นแค่ตัวละครตัวเดียว เรามีอีโมจิสองตัวต่อหนึ่งตัว
เกิดอะไรขึ้นที่นั่น?
อักขระบางตัวใน Unicode ถูกกำหนดให้เป็นการรวมกันของอักขระหลายตัว ในกรณีนี้ หากคอมพิวเตอร์เห็นอักขระสองตัวนี้พร้อมกัน จะแสดงเพียงตัวเดียวโดยใช้โทนสีผิว
มีตัวอย่างสนุกๆ อีกตัวอย่างหนึ่งที่เราเห็นได้ด้วยธง
'🇦🇺'.chars
# ["🇦", "🇺"]
ใน Unicode อิโมจิธงจะแสดงภายในด้วยอักขระ Unicode ที่เป็นนามธรรมซึ่งเรียกว่า "สัญลักษณ์ตัวบ่งชี้ระดับภูมิภาค" เช่น 🇦 หรือ 🇿 โดยปกติแล้วจะไม่ใช้ภายนอกแฟล็ก และเมื่อคอมพิวเตอร์เห็นสัญลักษณ์ทั้งสองร่วมกัน ก็จะแสดงแฟล็กหากมีหนึ่งตัวสำหรับชุดค่าผสมนั้น
หากต้องการดูตัวคุณเอง ลองคัดลอกสิ่งนี้และลบเครื่องหมายจุลภาคในโปรแกรมแก้ไขข้อความหรือฟิลด์ใด ๆ:
🇦,🇺
บทสรุป
ฉันหวังว่าการตรวจสอบนี้เกี่ยวกับวิธีการทำงานของ Unicode และ UTF-8 และความเกี่ยวข้องกับ Ruby และข้อผิดพลาดที่อาจเกิดขึ้นจะเป็นประโยชน์กับคุณ
บทเรียนที่สำคัญที่สุดที่ควรจำไว้คือ จำไว้ว่าเมื่อคุณทำงานกับข้อความประเภทใดก็ตาม คุณมีระบบการเข้ารหัสที่เกี่ยวข้องกัน และสิ่งสำคัญคือต้องรักษาไว้เสมอเมื่อจัดเก็บหรือเปลี่ยนแปลงข้อความ หากทำได้ ให้ใช้ระบบการเข้ารหัสที่ทันสมัย เช่น UTF-8 เพื่อที่คุณจะได้ไม่ต้องเปลี่ยนแปลงอีกในอนาคต
หมายเหตุเกี่ยวกับการเปิดตัว Ruby
ฉันเคยใช้ Ruby 2.6.5 สำหรับตัวอย่างทั้งหมดในบทความนี้ คุณสามารถลองใช้ใน REPL ออนไลน์หรือในเครื่องได้โดยไปที่เทอร์มินัลของคุณและดำเนินการ irb หากคุณติดตั้ง Ruby ไว้
เนื่องจากการรองรับ Unicode ได้รับการปรับปรุงในรุ่นล่าสุด ฉันจึงเลือกใช้รุ่นล่าสุดเพื่อให้บทความนี้มีความเกี่ยวข้อง ไม่ว่าในกรณีใด ด้วย Ruby 2.4 ขึ้นไป ตัวอย่างทั้งหมดควรใช้งานได้ดังที่แสดงไว้ที่นี่
