స్ట్రింగ్‌లు, బైట్‌లు మరియు రూన్‌లు

గోలో 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, **INAGYTOK...**INAGYTOK
• 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-th బైట్ (uint8).
• for i, r := range s రూన్‌లను డీకోడ్ చేస్తుంది; i అనేది బైట్-ఆఫ్‌సెట్.
• []rune(s) అక్షరం వారీగా ఇండెక్స్ చేయడానికి (ఖరీదైన, కేటాయించినవి).
• మార్చడానికి: []byte లేదా []rune ద్వారా వెళ్లండి.
• లూప్‌లో కలపడానికి: strings.Builder.
• కీలక ప్యాకేజీలు: strings, strconv, unicode, unicode/utf8.