河小马
这是一个关于如何在Golang中比较字符串的指南。你将学到在不同的使用场景中，哪种方法能提供最佳性能。此外，我们还会探讨如何结合多种方法来实现最佳性能，无论你在进行哪种Golang字符串比较。
如果你已经知道如何比较字符串，这可能看起来是个简单的问题。你可以选择一种有效的方法并使用它。然而，在一些Golang函数中进行字符串比较时存在较大的性能问题，而这些问题是设计使然。因此，你需要了解这些注意事项，以确保你的代码尽可能高效。
接下来，让我们将一起探索这些方法，并通过一些示例来加深理解。你还可以使用我们提供的链接，实时测试你的代码。
在Golang中比较字符串的最佳方法
在Golang中，有两种方法在字符串比较中表现最佳，同时也有一种方法表现最差。除此之外，还有其他用于不同需求的方法。我们将详细讨论每种方法的最佳使用方式，但这里先给出今天将要探讨的所有方法的简要总结：
1. 等号操作符（==, !=）：进行区分大小写的字符串比较的最佳选择。
2. `strings.EqualFold()`：进行不区分大小写的字符串比较的最佳方法。
3. `strings.Compare()`：进行区分大小写或不区分大小写比较的最差方法。
4. `len()`：此函数允许你比较两个字符串的长度。它本身很有用，也可以作为其他函数的性能增强工具。
5. `strings.Contains()`：比较区分大小写的子字符串的最佳方法。
6. `strings.Contains()` + `strings.ToLower()`：比较不区分大小写的子字符串的最佳方法。
7. 不等号操作符（>, <, >=, <=）：根据字母顺序比较字符串的最佳方法。
现在让我们深入了解这些方法的细节。
len ()
让我们从一个简单但经常被遗忘的函数开始。len()允许您根据字节大小比较Golang中的字符串。因此，如果你想知道一个字符串是否比另一个字符串大，这个方法就是你要用的方法。
下面是一个简单的用法:
package main
import "fmt"
func main() {
var stringA = "John"
var stringB = "Paul"
if len(stringA) == len(stringB) {
fmt.Println("The size is the same")
} else {
fmt.Println("The size is different")
}
// Result: The size is the same
stringA = "Ringo"
stringB = "George"
if len(stringA) == len(stringB) {
fmt.Println("The size is the same")
}
if len(stringA) < len(stringB) {
fmt.Println("A is smaller than B")
} else {
fmt.Println("A is bigger than B")
}
// Result: A is smaller than B
}
len()函数对于改进其他函数也非常有用。当您运行字符串比较函数(如” == “)时，Go将逐个比较字符。这需要相当长的时间。
但是使用len()检查字符串的大小非常快。因此，可以在运行其他相等性测试之前添加测试以查看字符串大小是否相同。这允许您在字符串不同时减少处理时间。
让我们看看它是如何在实际示例中使用每个函数的。
strings.EqualFold()
strings.EqualFold()函数用于以不区分大小写的方式比较两个字符串。该函数是strings包的一部分，当你需要在不考虑字符大小写的情况下检查两个字符串是否相等时，它特别有用。
下面是一个演示如何使用string . equalfold()的简单示例:
package main
import (
"fmt"
"strings"
)
func main() {
str1 := "Hello"
str2 := "HELLO"
str3 := "hello"
str4 := "world"
fmt.Println(strings.EqualFold(str1, str2)) // Output: true
fmt.Println(strings.EqualFold(str1, str3)) // Output: true
fmt.Println(strings.EqualFold(str1, str4)) // Output: false
}
在这个例子中：
- “Hello” 和 “HELLO” 之间的比较返回 true，因为 strings.EqualFold() 忽略了大小写差异。
同样，”Hello” 和 “hello” 被认为是相等的。 - “Hello” 和 “world” 之间的比较返回 false，因为字符串不同。
strings.EqualFold() 函数在各种情况下都很有用，例如：
- 用户认证：比较用户名或密码时忽略大小写差异。
- 数据验证：确保数据与预定义值匹配而不考虑大小写。
- 搜索和过滤：执行不区分大小写的搜索以提高结果准确性。
- 文件操作：在不区分大小写的文件系统上处理文件名或路径。
通过使用 strings.EqualFold()，你可以确保字符串比较时不区分大小写，从而在 Go 应用程序中实现更一致和用户友好的行为。
等号操作符（==, !=）
等号操作符允许你检查一个字符串是否与另一个字符串相等或不同。它检查的是精确匹配，因此是区分大小写的。对于区分大小写的比较，这是最快的选择，也是Golang团队推荐的选项。
你可以将等号操作符与len()函数结合使用，以获得更好的性能。在这种情况下，你首先检查字符串的长度是否相同，然后再对字符串的内容使用等号操作符。
如果你想在不区分大小写的比较中使用等号操作符，可以使用strings.ToLower()函数将所有字符转换为小写，然后检查两个字符串是否相等。不过，你不需要这样做。EqualFold()函数是进行不区分大小写比较的更好选择。
以下是一些在Golang中使用等号操作符比较字符串的示例：
package main
import (
"fmt"
"strings"
)
func main() {
var stringA = "John"
var stringB = "Paul"
if stringA == stringB {
fmt.Println("John is Paul")
} else {
fmt.Println("John isn't Paul")
}
// Result: John isn't Paul
stringA = "John"
stringB = "john"
if stringA == stringB {
fmt.Println("John is john")
} else {
fmt.Println("John isn't john")
}
// Result: John isn't john
stringA = "John"
stringB = "john"
if strings.ToLower(stringA) == strings.ToLower(stringB) {
fmt.Println("John is john when converted to lowercase")
} else {
fmt.Println("John isn't john when converted to lowercase")
}
// Result: John is john when converted to lowercase
}
stringA = "John"
stringB = "John Lennon"
if len(stringA) == len(stringB) {
if stringA == stringB {
fmt.Println("The sizes are the same, but John isn't John Lennon")
} else {
fmt.Println("The sizes are the same, and John is John Lennon")
}
} else {
fmt.Println("The sizes are different")
}
// Result: The sizes are different
不等号操作符（>, <, >=, <=）
在比较数字时，这些操作符的含义很容易理解。但在处理字符串时，它们的行为有些特殊。
如果你使用不等号操作符比较字符串，你实际上是在比较这些字符串的字典顺序。技术文档中通常将其称为字典序，这与字典顺序是一样的，但在比较包含数字和字母的字符串时可能会有些棘手。
需要注意的是，较低的顺序意味着数字在字典中排在前面。所以“abc”的顺序低于“def”。此外，大写字母排在小写字母之前。因此，“ABC”的顺序低于“abc”，这意味着“ABC”在字典中排在“abc”之前。
看看它是如何工作的：
package main
import (
"fmt"
)
func main() {
var stringA = "John"
var stringB = "john"
if stringA < stringB {
fmt.Println("John comes before john")
} else {
fmt.Println("John doesn't come before john")
}
// Result: John comes before john - uppercase letters come first
stringA = "Johnny"
stringB = "John Lennon"
if stringA < stringB {
fmt.Println("Johnny comes before John Lennon")
} else {
fmt.Println("Johnny doesn't come before John Lennon")
}
// Result: Johnny doesn't come before John Lennon - smaller words come first
stringA = "10 John"
stringB = "2 John"
if stringA < stringB {
fmt.Println("10 John comes before 2 John")
} else {
fmt.Println("10 John doesn't come before 2 John")
}
// Result: 10 John comes before 2 John - Even though 10 is bigger than 2, it is a dictionary comparison so 1 comes before 2
}
strings.Compare ()
明确一点，即使是Golang团队也建议不要使用这个函数。以下是他们在比较声明中的说明：
func Compare(a, b string) int {
// 注意(rsc): 这个函数不会调用运行时的 cmpstring 函数，
// 因为我们不想为使用 strings.Compare 提供任何性能上的理由。
// 基本上没有人应该使用 strings.Compare。
// 正如上面的注释所说，它仅仅是为了与 bytes 包对称而存在。
// 如果性能很重要，编译器应该被修改以识别这种模式，
// 这样所有进行三向比较的代码，而不仅仅是使用 strings.Compare 的代码，都能受益。
[...]
}
所以，不应该使用Compare()。（这是他们说的，不是我说的！）
无论如何，如果你确实想使用它，或者你想看看它是如何工作的以便重构一些旧代码，基本思想是这个函数执行区分大小写的比较。但它不是返回一个true/false的结果，而是在字符串相等时返回零，或者返回两个字符串的字典顺序比较结果。
因此，它类似于运行等号操作符（带有“不同于”），如果字符串不同，则运行不等号操作符。以下是strings.Compare(stringA, stringB)的可能返回值：
- 如果stringA == stringB，返回 0
- 如果stringA > stringB，返回 1 —— 意味着A在字典中排在B之后
- 如果stringA < stringB，返回 -1 —— 意味着A在字典中排在B之前
你可以在这里看到它的实际效果：
package main
import (
"fmt"
"strings"
)
func main() {
var stringA = "John"
var stringB = "John"
fmt.Println(strings.Compare(stringA, stringB))
// Result: 0 - both are equal
stringA = "John"
stringB = "john"
fmt.Println(strings.Compare(stringA, stringB))
// Result: -1 - John comes first in the dictionary
stringA = "Johnny"
stringB = "John Lennon"
fmt.Println(strings.Compare(stringA, stringB))
// Result: 1 - John Lennon comes first in the dictionary
stringA = "10 John"
stringB = "2 John"
fmt.Println(strings.Compare(stringA, stringB))
// Result: -1 - 10 John comes first in the dictionary
}
strings.Contains()
你可以使用contains函数检查一个字符串是否完全包含在另一个字符串中。这是一个区分大小写的比较。
如果字符串包含另一个字符串，则返回true；如果不包含，则返回false。要记住参数的顺序，可以将代码“Contains(a, b)”翻译为“‘a’是否包含‘b’？”，因此A是较大的字符串，B是你要测试的子字符串。
以下是它的工作方式：
package main
import (
"fmt"
"strings"
)
func main() {
var stringA = "The Beatles were an amazing band"
var stringB = "John"
fmt.Println(strings.Contains(stringA, stringB))
// Result: false
stringA = "The Beatles were: John, Paul, George, Ringo"
stringB = "John"
fmt.Println(strings.Contains(stringA, stringB))
// Result: true
stringA = "The Beatles were: John, Paul, George, Ringo"
stringB = "john"
fmt.Println(strings.Contains(stringA, stringB))
// Result: false
}
strings.Contains() + strings.ToLower()
默认情况下，contains函数是区分大小写的。如果你需要比较一个字符串是否包含另一个子字符串而忽略大小写，可以在比较之前将两者都转换为小写。
看看以下一些示例：
package main
import (
"fmt"
"strings"
)
func main() {
var stringA = "The Beatles were an amazing band"
var stringB = "John"
fmt.Println(strings.Contains(strings.ToLower(stringA), strings.ToLower(stringB)))
// Result: false
stringA = "The Beatles were: John, Paul, George, Ringo"
stringB = "John"
fmt.Println(strings.Contains(strings.ToLower(stringA), strings.ToLower(stringB)))
// Result: true
stringA = "The Beatles were: John, Paul, George, Ringo"
stringB = "john"
fmt.Println(strings.Contains(strings.ToLower(stringA), strings.ToLower(stringB)))
// Result: true
}
结 论
今天你已经学到了在Golang中比较字符串的最佳方法。此外，你还学会了如何将这些高性能的方法与其他Golang函数结合使用，以实现最佳性能。
到今天结束时，你应该能够根据字符串的内容、长度、字典顺序和子字符串进行比较。希望你喜欢这篇指南。
常见问题
在Golang中可以使用==比较字符串吗？
是的，你可以在Golang中使用等号比较字符串。它会寻找精确匹配，因此这是一个区分大小写的搜索。
如果你需要不区分大小写的方法，考虑使用strings.EqualFold()，因为它在这方面的性能更好。或者，你可以使用strings.ToLower()方法，但它的速度不会那么快。
你不应该使用strings.Compare()函数，因为Golang团队不推荐使用它，而且它比其他替代方法明显慢得多。
如何在Golang中找到字符串的长度？
你可以使用len()来获取字符串的字节大小。如果你使用的是占用多个字节的字符，这可能会导致不可预测的结果。如果你想知道字符串中的字符数，可以使用len([]rune(string))，例如len([]rune(“abc”))。
如何在Golang中将int转换为字符串？
你可以使用strconv函数。在其中，你可以使用Itoa方法直接转换十进制整数，例如strconv.Itoa(number)，或者你可以使用FormatInt方法从不同的进制进行转换，例如strconv.FormatInt(number, 10)。
