बहुत संभव है कि आपने रूबी अपवाद देखा हो जैसे UndefinedConversionError या IncompatibleCharacterEncodings . इसकी संभावना कम है कि आप अपवाद का अर्थ समझ गए हैं। यह लेख मदद करेगा। आप सीखेंगे कि चरित्र एन्कोडिंग कैसे काम करती है और रूबी में उन्हें कैसे लागू किया जाता है। अंत तक, आप इन त्रुटियों को अधिक आसानी से समझ और ठीक कर पाएंगे।
तो वैसे भी "कैरेक्टर एन्कोडिंग" क्या है?
हर प्रोग्रामिंग भाषा में, आप स्ट्रिंग्स के साथ काम करते हैं। कभी-कभी आप उन्हें इनपुट के रूप में संसाधित करते हैं, कभी-कभी आप उन्हें आउटपुट के रूप में प्रदर्शित करते हैं। लेकिन आपका कंप्यूटर "स्ट्रिंग्स" को नहीं समझता है। यह केवल बिट्स को समझता है:1s और 0s। स्ट्रिंग्स को बिट्स में बदलने की प्रक्रिया को कैरेक्टर एन्कोडिंग कहा जाता है।
लेकिन कैरेक्टर एन्कोडिंग केवल कंप्यूटर के युग से संबंधित नहीं है। कंप्यूटर होने से पहले हम एक सरल प्रक्रिया से सीख सकते हैं:मोर्स कोड।
मोर्स कोड
इसकी परिभाषा में मोर्स कोड बहुत सरल है। आपके पास एक संकेत उत्पन्न करने के लिए दो प्रतीक या तरीके हैं (लघु और लंबा)। उन दो प्रतीकों के साथ, आप एक साधारण अंग्रेजी वर्णमाला का प्रतिनिधित्व करते हैं। उदाहरण के लिए:
- A है .- (एक छोटा निशान और एक लंबा निशान)
- ई है। (एक छोटा निशान)
- O is --- (तीन लंबे निशान)
इस प्रणाली का आविष्कार 1837 के आसपास हुआ था और इसने केवल दो प्रतीकों या संकेतों के साथ पूरे वर्णमाला को एन्कोड करने की अनुमति दी थी।
आप यहां एक अनुवादक के साथ ऑनलाइन खेल सकते हैं।
छवि में आप एक "एनकोडर" देख सकते हैं, जो संदेशों को एन्कोडिंग और डिकोडिंग के लिए जिम्मेदार है। यह जल्द ही कंप्यूटर के आने के साथ बदल जाएगा।
मैन्युअल से स्वचालित एन्कोडिंग में
किसी संदेश को एन्कोड करने के लिए, आपको मोर्स कोड के एल्गोरिथम का पालन करते हुए वर्णों का मैन्युअल रूप से प्रतीकों में अनुवाद करने के लिए एक व्यक्ति की आवश्यकता होती है।
मोर्स कोड के समान, कंप्यूटर केवल दो "प्रतीकों" का उपयोग करते हैं:1 और 0। आप केवल कंप्यूटर में इनका एक क्रम संग्रहीत कर सकते हैं, और जब उन्हें पढ़ा जाता है, तो उन्हें इस तरह से व्याख्या करने की आवश्यकता होती है जो उपयोगकर्ता के लिए समझ में आता है।
प्रक्रिया दोनों मामलों में इस तरह काम करती है:
Message -> Encoding -> Store/Send -> Decoding -> Message
मोर्स कोड में एसओएस यह होगा:
SOS -> Encode('SOS') -> ...---... -> Decode('...---...') -> SOS
----------------------- --------------------------
Sender Receiver
कंप्यूटर और अन्य तकनीक के साथ एक बड़ा बदलाव यह था कि एन्कोडिंग और डिकोडिंग की प्रक्रिया स्वचालित हो गई थी, इसलिए हमें अब लोगों को जानकारी का अनुवाद करने की आवश्यकता नहीं थी।
जब कंप्यूटर का आविष्कार किया गया था, वर्णों को 1s और 0s में स्वचालित रूप से बदलने के लिए बनाए गए प्रारंभिक मानकों में से एक (हालांकि पहले नहीं) ASCII था।
ASCII का मतलब अमेरिकन स्टैंडर्ड कोड फॉर इंफॉर्मेशन इंटरचेंज है। कंप्यूटर ने कुछ समय के लिए सूचना के साथ कैसे काम किया, इसमें "अमेरिकन" भाग ने महत्वपूर्ण भूमिका निभाई; हम देखेंगे कि अगले भाग में क्यों।
ASCII (1963)
मोर्स कोड और बहुत शुरुआती कंप्यूटर जैसे टेलीग्राफिक कोड के ज्ञान के आधार पर, कंप्यूटर में एन्कोडिंग और डिकोडिंग के लिए एक मानक 1963 के आसपास बनाया गया था। यह प्रणाली अपेक्षाकृत सरल थी क्योंकि इसमें पहले केवल 127 वर्ण शामिल थे, अंग्रेजी वर्णमाला और अतिरिक्त प्रतीक।
एएससीआईआई ने प्रत्येक वर्ण को दशमलव संख्या के साथ जोड़कर काम किया जिसे बाइनरी कोड में अनुवादित किया जा सकता था। आइए एक उदाहरण देखें:
एएससीआईआई में "ए" 65 है, इसलिए हमें 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
इसलिए हम मूल ASCII एन्कोडिंग के साथ "A" को "1000001" के रूप में संग्रहीत करेंगे, जिसे अब US-ASCII के रूप में जाना जाता है। आजकल, 8-बिट कंप्यूटर सामान्य हो गए हैं, यह 01000001 (8 बिट =1 बाइट) होगा।
हम प्रत्येक वर्ण के लिए समान प्रक्रिया का पालन करते हैं, इसलिए 7 बिट्स के साथ, हम 2^7 वर्ण =127 तक संग्रहीत कर सकते हैं।
ये रही पूरी तालिका:
(https://www.plcdev.com/ascii_chart से)
ASCII के साथ समस्या
क्या होगा यदि हम फ्रेंच ç या जापानी वर्ण 大 जैसा कोई अन्य वर्ण जोड़ना चाहते हैं?
हां, हमें एक समस्या होगी।
ASCII के बाद, लोगों ने अपने स्वयं के एन्कोडिंग सिस्टम बनाकर इस समस्या को हल करने का प्रयास किया। उन्होंने अधिक बिट्स का उपयोग किया, लेकिन यह अंततः एक और समस्या का कारण बना।
मुख्य मुद्दा यह था कि फ़ाइल पढ़ते समय, आपको नहीं पता था कि आपके पास एक निश्चित एन्कोडिंग सिस्टम है या नहीं। गलत एन्कोडिंग के साथ इसकी व्याख्या करने का प्रयास करने के परिणामस्वरूप "�" या "Ã,ÂÂÂÂ" जैसे जिबरिश हुए।
उन एन्कोडिंग सिस्टम का विकास बड़ा और व्यापक था। भाषा के आधार पर, आपके पास अलग-अलग सिस्टम थे। चीनी जैसे अधिक वर्णों वाली भाषाओं को अपने अक्षरों को एन्कोड करने के लिए और अधिक जटिल प्रणाली विकसित करनी पड़ी।
कई वर्षों के संघर्ष के बाद, एक नया मानक बनाया गया:यूनिकोड। इस मानक ने उस तरीके को परिभाषित किया जिस तरह से आधुनिक कंप्यूटर सूचनाओं को एन्कोड और डिकोड करते हैं।
यूनिकोड (1988)
यूनिकोड का लक्ष्य बहुत सरल है। इसकी आधिकारिक साइट के अनुसार:"हर चरित्र के लिए एक अद्वितीय संख्या प्रदान करने के लिए, कोई फर्क नहीं पड़ता मंच, कार्यक्रम, या भाषा।"
इसलिए भाषा में प्रत्येक वर्ण का एक विशिष्ट कोड होता है, जिसे कोड बिंदु भी कहा जाता है। वर्तमान में 137,000 से अधिक वर्ण हैं।
यूनिकोड मानक के हिस्से के रूप में, हमारे पास उन मानों या कोड बिंदुओं को एन्कोड करने के अलग-अलग तरीके हैं, लेकिन UTF-8 सबसे व्यापक है।
वही लोग जिन्होंने गो प्रोग्रामिंग भाषा बनाई, रोब पाइक और केन थॉम्पसन ने भी यूटीएफ -8 बनाया। यह सफल हुआ है क्योंकि यह उन नंबरों को एन्कोड करने में कुशल और चालाक है। आइए देखें कि वास्तव में क्यों।
UTF-8:यूनिकोड ट्रांसफ़ॉर्मेशन फ़ॉर्मैट (1993)
UTF-8 अब वेबसाइटों के लिए वास्तविक एन्कोडिंग है (94% से अधिक वेबसाइटें उस एन्कोडिंग का उपयोग करती हैं)। यह कई प्रोग्रामिंग भाषाओं और फ़ाइलों के लिए डिफ़ॉल्ट एन्कोडिंग भी है। तो यह इतना सफल क्यों था और यह कैसे काम करता है?
UTF-8, अन्य एन्कोडिंग सिस्टम की तरह, यूनिकोड में परिभाषित संख्याओं को कंप्यूटर में संग्रहीत करने के लिए बाइनरी में बदल देता है।
यूटीएफ -8 के दो बहुत महत्वपूर्ण पहलू हैं:- बिट्स को स्टोर करते समय यह कुशल है, क्योंकि एक चरित्र 1 से 4 बाइट्स ले सकता है।- यूनिकोड और गतिशील मात्रा में बाइट्स का उपयोग करके, यह एएससीआईआई एन्कोडिंग के साथ संगत है क्योंकि पहले 127 वर्ण 1 बाइट लेते हैं। इसका मतलब है कि आप ASCII फ़ाइल को UTF-8 के रूप में खोल सकते हैं।
आइए जानें कि UTF-8 कैसे काम करता है।
UTF-8 1 बाइट के साथ
यूनिकोड तालिका में मान के आधार पर, UTF-8 वर्णों की एक भिन्न संख्या का उपयोग करता है।
पहले 127 के साथ, यह निम्नलिखित टेम्पलेट का उपयोग करता है:Rust1
0_______
तो 0 हमेशा रहेगा, उसके बाद यूनिकोड में मान का प्रतिनिधित्व करने वाला बाइनरी नंबर (जो एएससीआईआई भी होगा)। उदाहरण के लिए:ए =65 =1000001.
आइए स्ट्रिंग में अनपैक विधि का उपयोग करके रूबी के साथ इसकी जाँच करें:
'A'.unpack('B*').first
# 01000001
बी का मतलब है कि हम पहले सबसे महत्वपूर्ण बिट के साथ बाइनरी प्रारूप चाहते हैं। इस संदर्भ में, इसका अर्थ है उच्चतम मूल्य वाला बिट। तारांकन रूबी को तब तक जारी रखने के लिए कहता है जब तक कि और बिट्स न हों। यदि हम इसके बजाय किसी संख्या का उपयोग करते हैं, तो हमें केवल उस संख्या तक के बिट्स प्राप्त होंगे:
'A'.unpack('B4').first
# 01000
UTF-8 2 बाइट्स के साथ
यदि हमारे पास एक ऐसा वर्ण है जिसका यूनिकोड में मान या कोड बिंदु 127 से अधिक है, तो 2047 तक, हम निम्नलिखित टेम्पलेट के साथ दो बाइट्स का उपयोग करते हैं:
110_____ 10______
तो हमारे पास यूनिकोड में मान के लिए 11 खाली बिट हैं। आइए एक उदाहरण देखें:
यूनिकोड में À 192 है, इसलिए बाइनरी में यह 11000000 है, जिसमें 8 बिट हैं। यह पहले टेम्पलेट में फिट नहीं बैठता है, इसलिए हम दूसरे टेम्पलेट का उपयोग करते हैं:
110_____ 10______
हम दाएं से बाएं रिक्त स्थान भरना शुरू करते हैं:
110___11 10000000
वहां खाली बिट्स के साथ क्या होता है? हम सिर्फ 0s डालते हैं, इसलिए अंतिम परिणाम है:11000011 10000000।
हम यहां एक पैटर्न देखना शुरू कर सकते हैं। यदि हम बाएं से दाएं पढ़ना शुरू करते हैं, तो 8 बिट्स के पहले समूह में शुरुआत में दो 1s होते हैं। इसका मतलब है कि चरित्र 2 बाइट्स लेने वाला है:
11000011 10000000
--
फिर से, हम इसे रूबी के साथ देख सकते हैं:
'À'.unpack('B*').first
# 1100001110000000
यहां एक छोटी सी युक्ति यह है कि हम आउटपुट को बेहतर तरीके से प्रारूपित कर सकते हैं:
'À'.unpack('B8 B8').join(' ')
# 11000011 10000000
हमें 'À'.unpack('B8 B8') . से एक ऐरे मिलता है और फिर हम एक स्ट्रिंग प्राप्त करने के लिए तत्वों को एक स्थान के साथ जोड़ते हैं। अनपैक पैरामीटर में 8s रूबी को 2 समूहों में 8 बिट प्राप्त करने के लिए कहता है।
UTF-8 3 बाइट्स के साथ
यदि किसी वर्ण के लिए यूनिकोड में मान पिछले टेम्पलेट में उपलब्ध 11 बिट्स में फिट नहीं होता है, तो हमें एक अतिरिक्त बाइट की आवश्यकता होती है:
1110____ 10______ 10______
फिर से, टेम्प्लेट की शुरुआत में तीन 1s हमें बताते हैं कि हम एक 3-बाइट वर्ण पढ़ने वाले हैं।
इस टेम्पलेट पर भी यही प्रक्रिया लागू की जाएगी; यूनिकोड मान को बाइनरी में बदलें और दाएं से बाएं स्लॉट भरना शुरू करें। अगर उसके बाद हमारे पास कुछ खाली स्थान हैं, तो उन्हें 0 से भरें।
UTF-8 4 बाइट्स के साथ
कुछ मान पिछले टेम्पलेट में हमारे पास मौजूद 11 खाली बिट्स से भी अधिक लेते हैं। आइए इमोजी 🙂 के साथ एक उदाहरण देखें, जिसे यूनिकोड के लिए "a" या "大" जैसे वर्ण के रूप में भी देखा जा सकता है।
यूनिकोड में "🙂" का मान या कोड बिंदु 128578 है। बाइनरी में वह संख्या है:11111011001000010, 17 बिट्स। इसका मतलब है कि यह 3-बाइट टेम्पलेट में फिट नहीं है क्योंकि हमारे पास केवल 16 खाली स्लॉट थे, इसलिए हमें एक नए टेम्पलेट का उपयोग करने की आवश्यकता है जो मेमोरी में 4 बाइट्स लेता है:
11110___ 10______ 10______ 10______
हम इसे बाइनरी में संख्या से भरकर फिर से शुरू करते हैं:Rust1
11110___ 10_11111 10011001 10000010
और अब, हम शेष को 0 से भरते हैं:Rust1
1111000 10011111 10011001 10000010
आइए देखें कि यह रूबी में कैसा दिखता है।
चूंकि हम पहले से ही जानते हैं कि इसमें 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 में यूनिकोड के लिए आवश्यकता से अधिक स्थान है
UTF-8 का एक अन्य महत्वपूर्ण पहलू यह है कि इसमें सभी यूनिकोड मान (या कोड बिंदु) शामिल हो सकते हैं - और न केवल वे जो आज मौजूद हैं, बल्कि वे भी जो भविष्य में मौजूद रहेंगे।
ऐसा इसलिए है क्योंकि UTF-8 में, 4-बाइट टेम्प्लेट के साथ, हमारे पास भरने के लिए 21 स्लॉट हैं। इसका मतलब है कि हम 2^21 (=2,097,152) मान तक स्टोर कर सकते हैं, जो कि मानक के साथ हमारे पास अब तक के यूनिकोड मानों की सबसे बड़ी मात्रा से कहीं अधिक है, लगभग 1.1 मिलियन।
इसका मतलब है कि हम यूटीएफ -8 का उपयोग इस विश्वास के साथ कर सकते हैं कि हमें भविष्य में नए अक्षर या भाषा आवंटित करने के लिए किसी अन्य एन्कोडिंग सिस्टम पर स्विच करने की आवश्यकता नहीं होगी।
रूबी में विभिन्न एन्कोडिंग के साथ कार्य करना
रूबी में, हम किसी दिए गए स्ट्रिंग के एन्कोडिंग को तुरंत ऐसा करके देख सकते हैं:
'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 में फ़िट नहीं है, इसलिए हम नहीं कर सकते। रूबी उस मामले में एक त्रुटि उठाती है:
"hello 🙂".encode("ASCII", "UTF-8")
# Encoding::UndefinedConversionError (U+1F642 from UTF-8 to US-ASCII)
लेकिन रूबी हमें अपवादों की अनुमति देता है, जहां एक चरित्र को एन्कोड नहीं किया जा सकता है, हम इसे "?" से बदल सकते हैं।
"hello 🙂".encode("ASCII", "UTF-8", undef: :replace)
# hello ?
हमारे पास नए एन्कोडिंग में कुछ वर्णों को मान्य वर्ण से बदलने का विकल्प भी है:
"hello 🙂".encode("ASCII", "UTF-8", fallback: {"🙂" => ":)"})
# hello :)
रूबी में किसी स्क्रिप्ट की स्क्रिप्ट की एन्कोडिंग का निरीक्षण करना
जिस स्क्रिप्ट फ़ाइल पर आप काम कर रहे हैं, उसकी ".rb" फ़ाइल की एन्कोडिंग देखने के लिए, आप निम्न कार्य कर सकते हैं:
__ENCODING__
# This will show "#<Encoding:UTF-8>" in my case.
रूबी 2.0 से, रूबी स्क्रिप्ट के लिए डिफ़ॉल्ट एन्कोडिंग UTF-8 है, लेकिन आप इसे पहली पंक्ति में एक टिप्पणी के साथ बदल सकते हैं:
# encoding: ASCII
__ENCODING__
# #<Encoding:US-ASCII>
लेकिन जब तक आपके पास इसे बदलने का कोई बहुत अच्छा कारण न हो, तब तक UTF-8 मानक से चिपके रहना बेहतर है।
रूबी में एन्कोडिंग के साथ काम करने के लिए कुछ टिप्स
आप रूबी में समर्थित एन्कोडिंग की पूरी सूची Encoding.name_list . के साथ देख सकते हैं . यह एक बड़ी सरणी लौटाएगा:
["ASCII-8BIT", "UTF-8", "US-ASCII", "UTF-16BE", "UTF-16LE", "UTF-32BE", "UTF-32LE", "UTF-16", "UTF-32", "UTF8-MAC"...
अंग्रेजी भाषा के बाहर के पात्रों के साथ काम करते समय दूसरा महत्वपूर्ण पहलू यह है कि रूबी 2.4 से पहले, कुछ विधियाँ जैसे upcase या reverse उम्मीद के मुताबिक काम नहीं किया। उदाहरण के लिए, रूबी 2.3 में, अपकेस काम नहीं करता जैसा आप सोचते हैं:
# Ruby 2.3
'öıüëâñà'.upcase
# 'öıüëâñà'
वर्कअराउंड रेल, या किसी अन्य बाहरी रत्न से ActiveSupport का उपयोग कर रहा था, लेकिन रूबी 2.4 के बाद से हमारे पास पूर्ण यूनिकोड केस मैपिंग है:
# From Ruby 2.4 and up
'öıüëâñà'.upcase
# 'ÖIÜËÂÑÀ'
इमोजी के साथ कुछ मज़ेदार
आइए देखें कि यूनिकोड और रूबी में इमोजी कैसे काम करते हैं:
'🖖'.chars
# ["🖖"]
यह "राइज़ हैंड विथ पार्ट बिटवीन मिडिल एंड रिंग फिंगर्स" है, जिसे "वल्कन सैल्यूट" इमोजी के रूप में भी जाना जाता है। अगर हमारे पास एक ही इमोजी है लेकिन किसी अन्य त्वचा टोन में है जो डिफ़ॉल्ट नहीं है, तो कुछ दिलचस्प होता है:
'🖖🏾'.chars
# ["🖖", "🏾"]
इसलिए हमारे पास केवल एक चरित्र होने के बजाय, एक इमोजी के लिए दो हैं।
वहाँ क्या हुआ?
ठीक है, यूनिकोड में कुछ वर्णों को कई वर्णों के संयोजन के रूप में परिभाषित किया गया है। इस मामले में, यदि कंप्यूटर इन दो वर्णों को एक साथ देखता है, तो यह केवल एक को दिखाता है जिसमें त्वचा की टोन लागू होती है।
एक और मजेदार उदाहरण है जिसे हम झंडों के साथ देख सकते हैं।
'🇦🇺'.chars
# ["🇦", "🇺"]
यूनिकोड में, ध्वज इमोजी आंतरिक रूप से कुछ अमूर्त यूनिकोड वर्णों द्वारा दर्शाए जाते हैं जिन्हें या जैसे "क्षेत्रीय संकेतक प्रतीक" कहा जाता है। वे आम तौर पर झंडे के बाहर उपयोग नहीं किए जाते हैं, और जब कंप्यूटर दो प्रतीकों को एक साथ देखता है, तो यह ध्वज दिखाता है कि क्या उस संयोजन के लिए एक है।
स्वयं देखने के लिए, इसे कॉपी करने का प्रयास करें और किसी भी टेक्स्ट एडिटर या फ़ील्ड में अल्पविराम को हटा दें:
🇦,🇺
निष्कर्ष
मुझे उम्मीद है कि यूनिकोड और यूटीएफ -8 कैसे काम करते हैं और वे रूबी से कैसे संबंधित हैं और संभावित त्रुटियों की यह समीक्षा आपके लिए उपयोगी थी।
दूर करने के लिए सबसे महत्वपूर्ण सबक यह याद रखना है कि जब आप किसी भी प्रकार के पाठ के साथ काम कर रहे होते हैं तो आपके पास एक संबद्ध एन्कोडिंग सिस्टम होता है, और इसे संग्रहीत करते समय या इसे बदलते समय इसे उपस्थित रखना महत्वपूर्ण है। यदि आप कर सकते हैं, तो UTF-8 जैसे आधुनिक एन्कोडिंग सिस्टम का उपयोग करें ताकि भविष्य में आपको इसे बदलने की आवश्यकता न पड़े।
रूबी रिलीज़ के बारे में नोट
मैंने इस आलेख में सभी उदाहरणों के लिए रूबी 2.6.5 का उपयोग किया है। आप अपने टर्मिनल पर जाकर और irb . को क्रियान्वित करके ऑनलाइन REPL या स्थानीय रूप से उन्हें आज़मा सकते हैं यदि आपके पास रूबी स्थापित है।
चूंकि पिछले रिलीज में यूनिकोड समर्थन में सुधार किया गया है, इसलिए मैंने नवीनतम का उपयोग करने का विकल्प चुना है ताकि यह लेख प्रासंगिक बना रहे। किसी भी मामले में, रूबी 2.4 और उच्चतर के साथ, सभी उदाहरणों को यहां दिखाए अनुसार काम करना चाहिए।