GoLang字符串比较(一)

1. 写在前面

Kubernetes

字符串比较字符串比较字符串比较

• 字符串比较的不同方式
• 忽略大小的字符串比较
• 不同方法的性能比较

2. 字符串比较基本方式

2.1 区分大小写

So easy

package main

import "fmt"

func main() {
    srcString := "This a string"
    destString := "this a string"

    if srcString == destString {
        fmt.Println("Equals")
    } else {
        fmt.Println("Not Equals")
    }
}

2.2 不区分大小写

2.2.1 使用strings.ToLower

package main

import (
    "fmt"
    "strings"
)

func main() {
    ...

    if strings.ToLower(srcString) == strings.ToLower(destString) {
        fmt.Println("Equals")
    } else {
        fmt.Println("Not Equals")
    }
}

2.2.2 使用strings.Compare

package main

import (
    "fmt"
    "strings"
)

func main() {
    ...
    if strings.Compare(strings.ToLower(srcString), strings.ToLower(destString)) == 0 {
        fmt.Println("Equals")
    } else {
        fmt.Println("Not Equals")
    }
}

2.2.1

3. 使用EqualFold

2.2

package main

import (
    "fmt"
    "strings"
)

func main() {
    ...

    if strings.EqualFold(srcString, destString) == true {
        fmt.Println("Equals")
    } else {
        fmt.Println("Not Equals")
    }
}

4. 性能分析

我们前面只是简单的给出了结论，哪种方式是比较高效的。那样是不严谨的，那么，如何来实际测试一下，看一下，到底哪种方式更加的高效呢？ 这一章节中，我们将会通过一个测试样本进行实际测试一下。

4.1 生成数据样本

在开始之前，我们需要所准备一个数据样本，样本的获取可以通过mockaroo来得到，也可以使用以下程序来生成：

package main

import (
    "crypto/rand"
    "fmt"
    "os"
)

func GenerateRandomString(n int) string {
    const CHARACTER = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    var bytes = make([]byte, n)

    if _, err := rand.Read(bytes); err != nil {
        panic(err)
    }

    for i, c := range bytes {
        bytes[i] = CHARACTER[c % byte(len(CHARACTER))]
    }

    return string(bytes)
}

func GenFile() {
    f, err := os.Create("mock_data.txt")

    if err != nil {
        panic(err)
    }

    defer f.Close()

    var tempStr string

    for i := 0; i < 200000; i++ {
        tempStr = fmt.Sprintf("%v\n", GenerateRandomString(16))
        if _, err2 := f.WriteString(tempStr); err2 != nil {
            panic(err2)
        }
    }

}

func main() {
    GenFile()
}

我们得到了一个200000行数据的数据样本：

jeffrey@hacker ~/Desktop/hello
$ cat mock_data.txt | wc -l
200000

4.2 测试读取耗时

为了测试读取文件的耗时，我们写了以下程序：

main.go

package main

import "main/utils/reader"

func main() {
    //gen.GenFile()
    reader.ReadFile("mock_data.txt")
}

reader.go

package reader

import (
    "bufio"
    "fmt"
    "os"
)

func ReadFile(fileName string) {
    f, err := os.Open(fileName)

    if err != nil {
        panic(err)
    }

    scan := bufio.NewScanner(f)
    scan.Split(bufio.ScanLines)

    for scan.Scan() {
        cmptString := scan.Text()
        fmt.Printf("%s\n", cmptString)
    }

    f.Close()
}

执行上面获取文件的代码，耗时如下：

...
IBg0Fg79uIwwX9aF
ZcLmE0v1eUqjb6yK
EH6ykTgMTiUBtg3c
aVPont9anIcYBxcW
nKj04D2QIwx1J3VA
bwDRBkuRuw6XDn2I
79rIt3yb8zp5EMRw

real    0m1.122s
user    0m0.000s
sys     0m0.015s

jeffrey@hacker ~/Desktop/hello

4.3 区分大小写时的耗时

==

==

func BasicCompare(src, dest string) bool {
    if srcString == destString {
        return true
    } else {
        return false
    }
}

main.go

package main

import "main/utils/reader"

func main() {
    //gen.GenFile()
    reader.ReadFile("mock_data.txt")
}

reader.go

package reader

import (
    "bufio"
    "fmt"
    "os"
)

func ReadFile(fileName string) {
    srcString := "fuckSBWu"

    f, err := os.Open(fileName)

    if err != nil {
        panic(err)
    }

    scan := bufio.NewScanner(f)
    scan.Split(bufio.ScanLines)

    for scan.Scan() {
        if BasicCompare(scan.Text(), strcString) {
            fmt.Println("Equal")
        }
    }

    f.Close()
}

jeffrey@hacker ~/Desktop/hello
$ time go run main.go

real    0m0.436s
user    0m0.000s
sys     0m0.015s

Compare

func CompareCompare(src, dest string) bool {
    if strings.Compare(src, dest) == 0 {
        return true
    }
    return false
}
jeffrey@hacker ~/Desktop/hello
$ time go run main.go

real    0m0.395s
user    0m0.000s
sys     0m0.015s

4.3.3 结论

strings.Compare()略显快一些。

4.4 不区分大小写时的耗时

==

func CaseInSensitiveBasicCompare(src, dest string) bool {
    if strings.ToLower(src) == strings.ToLower(dest) {
        return true
    } else {
        return false
    }
}
jeffrey@hacker ~/Desktop/hello
$ time go run main.go

real    0m0.423s
user    0m0.000s
sys     0m0.015s

Compare

func CaseInSensitiveCompareCompare(src, dest string) bool {
    if strings.Compare(strings.ToLower(src), strings.ToLower(dest)) == 0 {
        return true
    } else {
        return false
    }
}
jeffrey@hacker ~/Desktop/hello
$ time go run main.go

real    0m0.426s
user    0m0.015s
sys     0m0.000s

4.4.3 使用EqualFold时的耗时

jeffrey@hacker ~/Desktop/hello
$ time go run main.go

real    0m0.394s
user    0m0.015s
sys     0m0.000s

5. 总结

EqualFold地道