Go में rune टाइप int32 का एलियस है। इसका आधार int32 टाइप होने के कारण rune टाइप एक 32-बिट साइनयुक्त पूर्णांक मान रखता है। लेकिन int32 टाइप की तरह नहीं, rune टाइप में संग्रहीत पूर्णांक मान एक अकेले Unicode अक्षर को दर्शाता है।
Unicode और Unicode कोड पॉइंट
Unicode, ASCII का सुपरसेट है और हर अक्षर को एक अलग संख्या देकर उन्हें दर्शाता है। इस अलग संख्या को Unicode कोड पॉइंट कहा जाता है। Unicode का उद्देश्य दुनिया के सभी अक्षरों को Unicode कोड पॉइंट के रूप में दर्शाना है, जिनमें अलग-अलग वर्णमालाएँ, संख्याएँ, प्रतीक और यहाँ तक कि इमोजी भी शामिल हैं।
Go में rune टाइप एक अकेले Unicode कोड पॉइंट को दर्शाता है।
नीचे दी गई तालिका में कुछ उदाहरण Unicode अक्षर, उनके Unicode कोड पॉइंट और दशमलव मान दिए गए हैं:
| Unicode अक्षर |
Unicode कोड पॉइंट |
दशमलव मान |
| 0 |
U+0030 |
48 |
| A |
U+0041 |
65 |
| a |
U+0061 |
97 |
| ¿ |
U+00BF |
191 |
| π |
U+03C0 |
960 |
| 🧠 |
U+1F9E0 |
129504 |
UTF-8
UTF-8 एक ऐसी अक्षर एन्कोडिंग है जिसकी चौड़ाई बदलती है और जिसका उपयोग हर Unicode कोड पॉइंट को 1, 2, 3 या 4 बाइट में एन्कोड करने के लिए किया जाता है। चूँकि एक Unicode कोड पॉइंट को अधिकतम 4 बाइट में एन्कोड किया जा सकता है, rune टाइप को 4 बाइट तक डेटा रख पाने में सक्षम होना चाहिए। इसीलिए rune टाइप int32 का एलियस है, क्योंकि int32 टाइप 4 बाइट तक डेटा रख सकता है।
Go के सोर्स कोड फाइलें UTF-8 में एन्कोड की जाती हैं।
रून का उपयोग
rune टाइप के वेरिएबल घोषित करते समय अक्षर को सिंगल कोट्स के अंदर रखा जाता है:
myRune := '¿'
चूँकि rune केवल int32 का एलियस है, रून का टाइप प्रिंट करने पर int32 मिलेगा:
myRune := '¿'
fmt.Printf("myRune type: %T\n", myRune)
// Output: myRune type: int32
इसी तरह, रून की वैल्यू प्रिंट करने पर उसका पूर्णांक (दशमलव) मान मिलेगा:
myRune := '¿'
fmt.Printf("myRune value: %v\n", myRune)
// Output: myRune value: 191
रून द्वारा दर्शाए गए Unicode अक्षर को प्रिंट करने के लिए %c फॉर्मेटिंग वर्ब का उपयोग कीजिए:
myRune := '¿'
fmt.Printf("myRune Unicode character: %c\n", myRune)
// Output: myRune Unicode character: ¿
रून द्वारा दर्शाए गए Unicode कोड पॉइंट को प्रिंट करने के लिए %U फॉर्मेटिंग वर्ब का उपयोग कीजिए:
myRune := '¿'
fmt.Printf("myRune Unicode code point: %U\n", myRune)
// Output: myRune Unicode code point: U+00BF
रून और स्ट्रिंग
Go में स्ट्रिंग UTF-8 में एन्कोड की जाती हैं, यानी उनमें Unicode अक्षर होते हैं। स्ट्रिंग के अक्षर जिस Unicode अक्षर को दर्शाते हैं, उसके अनुसार उन्हें 1, 2, 3 या 4 बाइट में संग्रहीत और एन्कोड किया जाता है।
Go में क्रम दर्शाने के लिए स्लाइस का उपयोग किया जाता है, और इन स्लाइस पर range की मदद से इटरेशन किया जा सकता है। जब हम किसी स्ट्रिंग पर इटरेशन करते हैं, तो Go उस स्ट्रिंग को रून की एक श्रृंखला में बदल देता है, और इनमें से हर रून 4 बाइट का होता है (याद रखिए, रून टाइप int32 का एलियस है!)
स्ट्रिंग भले ही बाइट का एक स्लाइस हो, range कीवर्ड स्ट्रिंग के बाइट पर नहीं, बल्कि उसके रून पर इटरेशन करता है।
इस उदाहरण में index वेरिएबल मौजूदा रून के बाइट क्रम का शुरुआती इंडेक्स दर्शाता है और char वेरिएबल मौजूदा रून दर्शाता है:
myString := "❗hello"
for index, char := range myString {
fmt.Printf("Index: %d\tCharacter: %c\t\tCode Point: %U\n", index, char, char)
}
// Output:
// Index: 0 Character: ❗ Code Point: U+2757
// Index: 3 Character: h Code Point: U+0068
// Index: 4 Character: e Code Point: U+0065
// Index: 5 Character: l Code Point: U+006C
// Index: 6 Character: l Code Point: U+006C
// Index: 7 Character: o Code Point: U+006F
चूँकि रून 1, 2, 3 या 4 बाइट में संग्रहीत किए जा सकते हैं, स्ट्रिंग की लंबाई हमेशा स्ट्रिंग के अक्षरों की संख्या के बराबर नहीं होगी। स्ट्रिंग की लंबाई बाइट में पाने के लिए बिल्ट-इन len फंक्शन का और स्ट्रिंग में रून की संख्या पाने के लिए utf8.RuneCountInString फंक्शन का उपयोग कीजिए:
import "unicode/utf8"
myString := "❗hello"
stringLength := len(myString)
numberOfRunes := utf8.RuneCountInString(myString)
fmt.Printf("myString - Length: %d - Runes: %d\n", stringLength, numberOfRunes)
// Output: myString - Length: 8 - Runes: 6
सीखने का अभ्यास
