स्ट्रिंग्स, बाइट्स और रून्स

गो में string बाइट्स का एक अपरिवर्तनीय अनुक्रम है। स्ट्रिंग शाब्दिक UTF-8 में एन्कोड किया गया है। rune int32 का उपनाम है और एकल यूनिकोड कोड बिंदु का प्रतिनिधित्व करता है।

बाइट्स और रून्स के बीच अंतर को समझना आवश्यक है जब किसी स्ट्रिंग में उच्चारण, इमोजी, आइडियोग्राम या कोई भी हो तो बग से बचें गैर-ASCII वर्ण.

string = बाइट्स, अक्षर नहीं

s := "ciaò"
fmt.Println(len(s))   // 5 — not 4!
fmt.Println(s[0])     // 99 ('c' as a byte)
fmt.Println(s[3])     // 195 (first byte of 'ò' in UTF-8)

len(s) बाइट्स की संख्या लौटाता है, दृश्यमान वर्णों की नहीं। अनुक्रमण s[i] i-th बाइट (uint8) लौटाता है, वर्ण नहीं।

for range रून्स को पुनरावृत्त करता है

for i, r := range s UTF-8 को तुरंत डिकोड करता है: i बाइट-ऑफ़सेट है रूण की शुरुआत में, r रूण (int32) है:

s := "ciaò"
for i, r := range s {
    fmt.Printf("%d %c (U+%04X)\n", i, r, r)
}
// 0 c (U+0063)
// 1 i (U+0069)
// 2 a (U+0061)
// 3 ò (U+00F2)   <- starts at byte 3, takes 2 bytes

[]rune(s): प्रति-वर्ण अनुक्रमण

स्पष्ट रूपांतरण: रून्स का एक नया टुकड़ा आवंटित करता है। महँगा लेकिन कभी-कभी आवश्यक:

runes := []rune("ciaò")
fmt.Println(len(runes))    // 4
fmt.Println(string(runes[3])) // ò

string(runes) उलटा रूपांतरण है: []rune लेता है और उत्पादन करता है एक UTF-8 स्ट्रिंग.

तार अपरिवर्तनीय हैं

s := "ciao"
// s[0] = 'C'   // ERROR: cannot assign to s[0]

परिवर्तन करने के लिए, []byte या []rune में कनवर्ट करें, संचालित करें, वापस कनवर्ट करें:

b := []byte(s)
b[0] = 'C'
s = string(b)   // "Ciao"

कड़ी

+ ऑपरेटर काम करता है, लेकिन लूप में कई संयोजनों के लिए इसका उपयोग करें strings.Builder (अधिक कुशल, मध्यवर्ती आवंटन से बचा जाता है):

var sb strings.Builder
for i := 0; i < 5; i++ {
    sb.WriteString("ab")
}
fmt.Println(sb.String())   // "ababababab"

उपयोगी पैकेज

• strings: Contains, HasPrefix, Split, Join, ToUpper, Replace...
• strconv: Atoi, Itoa, ParseFloat, FormatInt...
• unicode: IsLetter, IsDigit, ToUpper...
• unicode/utf8: RuneCountInString (len([]rune(s)) का विकल्प)।

इसे अजमाएं

s := "ciaò"
fmt.Println(len(s))

संक्षिप्त

• string = बाइट्स का अपरिवर्तनीय अनुक्रम, UTF-8 एन्कोडेड।
• len(s) = बाइट्स; s[i] = i-वें बाइट (uint8)।
• for i, r := range s रन को डिकोड करता है; i बाइट-ऑफ़सेट है।
• []rune(s) चरित्र द्वारा अनुक्रमित करने के लिए (महंगा, आवंटित)।
• परिवर्तन करने के लिए: []byte या []rune से गुजरें।
• एक लूप में संयोजित करने के लिए: strings.Builder।
• मुख्य पैकेज: strings, strconv, unicode, unicode/utf8।