在go语言里面优雅的反转字符串

在go语言里面优雅的反转字符串

一、用于反转ascii字符的方法

        通常，说到反转字符串，由于string的不变性，就转为[]byte然后处理

1.  
   func reverseBytes(s string) string {
2.  
   r := []byte(s)
3.  
   for i := 0; i < len(s); i {
4.  
   r[i] = s[len(s)-1-i]
5.  
   }
6.  
   return string(r)
7.  
   }

        这种反转适用于 ascII的字符，因为byte底层为uint8，一字节，最多表示256种不同字符，如果使用此方法的字符串包含UTF-8的多字节表示的情况，将不能获得正确结果。

二、反转UTF-8的情况，需要使用rune

        rune字符底层为uint32，4字节长度，适用于多字节编码的情况，此处处理UTF-8的情况

1.  
   func reverseCodePoints(s string) string {
2.  
   r := make([]rune, len(s))
3.  
   start := len(s)
4.  
   for _, c := range s {
5.  
   // quietly skip invalid UTF-8
6.  
   if c != utf8.RuneError {
7.  
   start--
8.  
   r[start] = c
9.  
   }
10.  
    }
11.  
    return string(r[start:])
12.  
    }

三、部分特殊字符，需要多字节段合并，才能正确读取并反转

        对于这种特殊情况，需要特殊处理合并，下面展示一种。

1.  
   func reversePreservingCombiningCharacters(s string) string {
2.  
   if s == "" {
3.  
   return ""
4.  
   }
5.  
   p := []rune(s)
6.  
   r := make([]rune, len(p))
7.  
   start := len(r)
8.  
   for i := 0; i < len(p); {
9.  
   // quietly skip invalid UTF-8
10.  
    if p[i] == utf8.RuneError {
11.  
    i
12.  
    continue
13.  
    }
14.  
    j := i 1
15.  
    for j < len(p) && (unicode.Is(unicode.Mn, p[j]) ||
16.  
    unicode.Is(unicode.Me, p[j]) || unicode.Is(unicode.Mc, p[j])) {
17.  
    j
18.  
    }
19.  
    for k := j - 1; k >= i; k-- {
20.  
    start--
21.  
    r[start] = p[k]
22.  
    }
23.  
    i = j
24.  
    }
25.  
    return string(r[start:])

测试代码

1.  
   func main() {
2.  
   test("asdf")
3.  
   test("as⃝df̅中国")
4.  
   }
5.  
    
6.  
   func test(s string) {
7.  
   fmt.Println("\noriginal: ", []byte(s), s)
8.  
   r := reverseBytes(s)
9.  
   fmt.Println("reversed bytes:", []byte(r), r)
10.  
    fmt.Println("original code points:", []rune(s), s)
11.  
    r = reverseCodePoints(s)
12.  
    fmt.Println("reversed code points:", []rune(r), r)
13.  
    r = reversePreservingCombiningCharacters(s)
14.  
    fmt.Println("combining characters:", []rune(r), r)
15.  
    }
16.  
    //original: [97 115 100 102] asdf
17.  
    //reversed bytes: [102 100 115 97] fdsa
18.  
    //original code points: [97 115 100 102] asdf
19.  
    //reversed code points: [102 100 115 97] fdsa
20.  
    //combining characters: [102 100 115 97] fdsa
21.  
    //
22.  
    //original: [97 115 226 131 157 100 102 204 133 228 184 173 229 155 189] as⃝df̅中国
23.  
    //reversed bytes: [189 155 229 173 184 228 133 204 102 100 157 131 226 115 97] ��學��fd���sa
24.  
    //original code points: [97 115 8413 100 102 773 20013 22269] as⃝df̅中国
25.  
    //reversed code points: [22269 20013 773 102 100 8413 115 97] 国中̅fd⃝sa
26.  
    //combining characters: [22269 20013 102 773 100 115 8413 97] 国中f̅ds⃝a

参考文献：How to reverse a string in Go? - Stack Overflow

这篇好文章是转载于：学新通技术网