रून में

रून के बारे में

Go में rune टाइप int32 का एलियस है। इस अंतर्निहित int32 टाइप को देखते हुए, rune टाइप एक साइन्ड 32-बिट पूर्णांक वैल्यू रखता है। हालाँकि, int32 टाइप के विपरीत, rune टाइप में संग्रहीत पूर्णांक वैल्यू एक अकेले यूनिकोड अक्षर को दर्शाती है।

यूनिकोड और यूनिकोड कोड पॉइंट

यूनिकोड ASCII का सुपरसेट है, जो हर अक्षर को एक अद्वितीय संख्या असाइन करके अक्षरों को दर्शाता है। इस अद्वितीय संख्या को यूनिकोड कोड पॉइंट कहा जाता है। यूनिकोड का उद्देश्य दुनिया के सभी अक्षरों को, जिनमें विभिन्न वर्णमालाएँ, संख्याएँ, प्रतीक और यहाँ तक कि इमोजी भी शामिल हैं, यूनिकोड कोड पॉइंट के रूप में दर्शाना है।

Go में, rune टाइप एक अकेले यूनिकोड कोड पॉइंट को दर्शाता है।

नीचे दी गई तालिका में उदाहरण यूनिकोड अक्षर, उनके यूनिकोड कोड पॉइंट और दशमलव वैल्यू दिए गए हैं:

UTF-8

UTF-8 एक वेरिएबल-चौड़ाई वाला अक्षर एन्कोडिंग है, जिसका उपयोग हर यूनिकोड कोड पॉइंट को 1, 2, 3 या 4 बाइट में एन्कोड करने के लिए किया जाता है। चूँकि एक यूनिकोड कोड पॉइंट को अधिकतम 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

रून द्वारा दर्शाए गए यूनिकोड अक्षर को प्रिंट करने के लिए %c फॉर्मेटिंग वर्ब का उपयोग कीजिए:

myRune := '¿'
fmt.Printf("myRune Unicode character: %c\n", myRune)
// Output: myRune Unicode character: ¿

रून द्वारा दर्शाए गए यूनिकोड कोड पॉइंट को प्रिंट करने के लिए %U फॉर्मेटिंग वर्ब का उपयोग कीजिए:

myRune := '¿'
fmt.Printf("myRune Unicode code point: %U\n", myRune)
// Output: myRune Unicode code point: U+00BF

किसी अक्षर को सिंगल कोट्स में लपेटकर रून बनाने के अलावा, आप हेक्साडेसिमल या दशमलव संख्या भी निर्दिष्ट कर सकते हैं:

myRune := rune(0xbf)
myRune = 191
fmt.Printf("myRune Unicode character: %c\n", myRune)
// Output: myRune Unicode character: ¿

रून और स्ट्रिंग

Go में स्ट्रिंग UTF-8 में एन्कोड होती हैं, जिसका मतलब है कि उनमें यूनिकोड अक्षर होते हैं। स्ट्रिंग में मौजूद अक्षर, वे जिस यूनिकोड अक्षर को दर्शाते हैं उसके आधार पर 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

रून का टाइप कन्वर्ज़न

रून के स्लाइस को स्ट्रिंग में टाइप कन्वर्ट किया जा सकता है:

myRuneSlice := []rune{'e', 'x', 'e', 'r', 'c', 'i', 's', 'm'}
myString := string(myRuneSlice)
fmt.Println(myString)
// Output: exercism

इसी तरह, एक स्ट्रिंग को रून के स्लाइस में टाइप कन्वर्ट किया जा सकता है। याद रखिए, फॉर्मेटिंग वर्ब के बिना, किसी रून को प्रिंट करने पर उसकी पूर्णांक (दशमलव) वैल्यू मिलती है:

myString := "exercism"
myRuneSlice := []rune(myString)
fmt.Println(myRuneSlice)
// Output: [101 120 101 114 99 105 115 109]