当前位置：网站首页>Go 字符串比较

Go 字符串比较

2022-06-23 09:35:00 【51CTO】

golang 字符串比较

字符串比较，可以直接使用 == 进行比较，也可用用 strings.Compare 比较

go 中字符串比较有三种方式：

== 比较
strings.Compare 比较
strings.EquslFold 比较

      
      
       
       #### 代码示例
       
       
```go
       
       
fmt.Println("go"=="go")
       
       
fmt.Println("GO"=="go")
       
       

       
       
fmt.Println(strings.Compare("GO","go"))
       
       
fmt.Println(strings.Compare("go","go"))
       
       

       
       
fmt.Println(strings.EqualFold("GO","go"))
      
      
      
      
       
       1.
       
       2.
       
       3.
       
       4.
       
       5.
       
       6.
       
       7.
       
       8.
       
       9.

上述代码执行结果如下：

Compare 和 EqualFold 区别

EqualFold 是比较UTF-8编码在小写的条件下是否相等，不区分大小写

      
      
       
       // EqualFold reports whether s and t, interpreted as UTF-8 strings, // are equal under Unicode case-folding. func EqualFold(s, t string) bool
      
      
      
      
       
       1.

要注意的是Compare 函数是区分大小写的， == 速度执行更快

       
       / Compare is included only for symmetry with package bytes. // It is usually clearer and always faster to use the built-in // string comparison operators ==, 
       
       <
       
       , 
       
       >, and so on. func Compare(a, b string) int
      
1.

忽略大小写比较

有时候要忽略大小写比较, 可以使用strings.EqualFold 字符串比较是否相等

源码实现

       
       // EqualFold reports whether s and t, interpreted as UTF-8 strings,
       
// are equal under Unicode case-folding, which is a more general
       
// form of case-insensitivity.
       
func EqualFold(s, t string) bool {
       
    for s != "" 
       
       &
       
       & t != "" {
       
        // Extract first rune from each string.
       
        var sr, tr rune
       
        if s[0] 
       
       < 
       
       utf8.RuneSelf 
       
       {
       
       sr, 
       
       s = 
       
       rune(s[0]), 
       
       s[1:]
       
       } 
       
       else 
       
       {
       
       r, 
       
       size 
       
       := 
       
       utf8.DecodeRuneInString(s)
       
       sr, 
       
       s = 
       
       r, 
       
       s[size:]
       
       }
       
       if 
       
       t[0] 
       
       < utf8.RuneSelf {
       
            tr, t = rune(t[0]), t[1:]
       
        } else {
       
            r, size := utf8.DecodeRuneInString(t)
       
            tr, t = r, t[size:]
       
        }
       
        // If they match, keep going; if not, return false.
       
        // Easy case.
       
        if tr == sr {
       
            continue
       
        }
       
        // Make sr 
       
       < 
       
       tr 
       
       to 
       
       simplify 
       
       what 
       
       follows.
       
       if 
       
       tr 
       
       < sr {
       
            tr, sr = sr, tr
       
        }
       
        // Fast check for ASCII.
       
        if tr 
       
       < 
       
       utf8.RuneSelf 
       
       {
       
       /
       
       / 
       
       ASCII 
       
       only, 
       
       sr/tr 
       
       must 
       
       be 
       
       upper/lower 
       
       case
       
       if 
       
       'A' 
       
       <= sr 
       
       &
       
       & sr 
       
       <
       
       = 
       
       'Z' 
       
       && 
       
       tr =
       
       = 
       
       sr+
       
       'a'
       
       -
       
       'A' 
       
       {
       
       continue
       
       }
       
       return 
       
       false
       
       }
       
       /
       
       / 
       
       General 
       
       case. 
       
       SimpleFold(x) 
       
       returns 
       
       the 
       
       next 
       
       equivalent 
       
       rune 
       
       > x
       
        // or wraps around to smaller values.
       
        r := unicode.SimpleFold(sr)
       
        for r != sr 
       
       &
       
       & r 
       
       < 
       
       tr 
       
       {
       
       r = 
       
       unicode.SimpleFold(r)
       
       }
       
       if 
       
       r =
       
       = 
       
       tr 
       
       {
       
       continue
       
       }
       
       return 
       
       false
       
       }
       
       /
       
       / 
       
       One 
       
       string 
       
       is 
       
       empty. 
       
       Are 
       
       both?
       
       return 
       
       s =
       
       = 
       
       t
       
       }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.

通过源码可看到 if 'A' <= sr && sr <= 'Z' && tr == sr+'a'-'A' 可以看到不区分大小写的实现。

看个完整测试代码：

      
      
       
       // Golang program to illustrate the
       
       
// strings.EqualFold() Function
       
       
package main
       
       

       
       
// importing fmt and strings
       
       
import (
       
       
 "fmt"
       
       
 "strings"
       
       
)
       
       

       
       
// calling main method
       
       
func main() {
       
       
 // case insensitive comparing and returns true.
       
       
 fmt.Println(strings.EqualFold("Geeks", "Geeks"))
       
       

       
       
 // case insensitive comparing and returns true.
       
       
 fmt.Println(strings.EqualFold("computerscience", "computerscience"))
       
       
}
      
      
      
      
       
       1.
       
       2.
       
       3.
       
       4.
       
       5.
       
       6.
       
       7.
       
       8.
       
       9.
       
       10.
       
       11.
       
       12.
       
       13.
       
       14.
       
       15.
       
       16.
       
       17.
       
       18.

执行结构

获得更多内容，关注公众号程序员财富自由之路

Go 字符串比较_golang

公众号:程序员财富自由之路

关注我们，了解更多

参考资料

原网站

版权声明
本文为[51CTO]所创，转载请带上原文链接，感谢
https://blog.51cto.com/u_15683090/5410244