Go 字符串

提示

1. 字符串定义与基本使用：字符串是字符序列，用双引号表示。在 Go 中，可以使用 var 关键字或使用简写符号 := 来创建字符串变量。
2. 字符串访问与长度计算：字符串的各个字符可以通过索引（从0开始）访问，使用 len() 函数可以获得字符串的长度。
3. 字符串操作与方法：Go 提供了多种字符串操作方法，例如 Compare(), Contains(), Replace(), ToUpper(), ToLower() 和 Split()，需导入 strings 包来使用这些方法。

字符串是字符的序列。例如，"Golang" 是一个包括字符 G、o、l、a、n、g 的字符串。

在 Go 中，我们使用双引号来表示字符串。例如，

// 使用 var
var name1 = "Go 编程"

// 使用简写表示法
name2 := "Go 编程"

这里，name1 和 name2 都是值为 "Go 编程" 的字符串。

示例：Golang 字符串

// Golang 中创建字符串的程序

package main
import "fmt"

func main() {

 // 使用 var 创建字符串
 var message1 = "Hello,"

 // 使用简写表示法创建字符串
 message2 := "欢迎来到 Programiz"

 fmt.Println(message1)
 fmt.Println(message2)
}

输出

Hello,
欢迎来到 Programiz

使用反引号 ( ) 表示 Golang 字符串

在 Go 中，我们也可以使用反引号标记表示字符串。例如，

// 使用反引号表示字符串的程序

package main
import "fmt"

func main() {

 // 使用 ` ` 表示字符串
 message := `我爱 Go 编程`

 fmt.Println(message)
}

输出

我爱 Go 编程

在 Go 中访问字符串字符

我们知道字符串是字符的序列。因此，我们可以访问字符串的单个字符。

就像 Go 数组 一样，我们使用索引号来访问字符串字符。例如，

// 访问字符串单个字符的程序

package main
import "fmt"

func main() {

 // 创建并初始化一个字符串
 name := "Programiz"

 // 访问第一个字符
 fmt.Printf("%c\n", name[0]) // P

 // 访问第四个字符
 fmt.Printf("%c\n", name[3]) // g

 // 访问最后一个字符
 fmt.Printf("%c", name[8]) // z
}

记住字符串索引从 0 开始，而不是 1。

因此，

• name[0] - 返回字符串的第一个字符
• name[3] - 返回第四个字符
• name[8] - 返回第九个（最后一个）字符

查找字符串的长度

在 Go 中，我们使用 len() 函数来查找字符串的长度。例如，

// 计算字符串长度的程序

package main
import "fmt"

func main() {

 // 创建字符串
 message := "欢迎来到 Programiz"

 // 使用 len() 函数计算长度
 stringLength := len(message)

 fmt.Println("字符串的长度是:", len(stringLength))

}

输出

字符串的长度是: 20

这里，len() 返回字符串中字符的数量。

拼接两个字符串

在 Go 中，我们可以使用 + 运算符来拼接（连接）字符串。例如，

// 拼接两个字符串的程序

package main
import "fmt"

func main() {
 message1 := "我爱"
 message2 := "Go 编程"

 // 使用 + 运算符拼接
 result := message1 + " " + message2

 fmt.Println(result)
}

输出

我爱 Go 编程

这里，我们使用 + 运算符连接了三个字符串：message1、" " 和 message2。

Golang 字符串方法

在 Go 中，字符串包提供了各种方法，可以用来对字符串执行不同操作。

函数	描述
Compare()	比较两个字符串
Contains()	检查字符串中是否存在子串
Replaces()	用另一个子串替换子串
ToLower()	将字符串转换为小写
ToUpper()	将字符串转换为大写
Split()	将字符串分割为多个子串

要使用这些方法，我们必须首先在代码中导入字符串包。

import (
 "fmt"
 "strings"
)

在 Go 中比较两个字符串

我们使用 strings 包的 Compare() 来比较两个字符串。例如，

// 使用 Compare() 比较字符串的程序

package main
import (
 "fmt"
 "strings"
)

func main() {

 // 创建三个字符串
 string1 := "Programiz"
 string2 := "Programiz Pro"
 string3 := "Programiz"

 // 比较字符串
 fmt.Println(strings.Compare(string1, string2)) // -1
 fmt.Println(strings.Compare(string2, string3)) // 1
 fmt.Println(strings.Compare(string1, string3)) // 0

}

这里，我们使用了

strings.Compare(string1, string2)

来比较两个字符串：string1 和 string2。该函数返回：

• -1 因为 string1 比 string2 小
• 1 因为 string2 比 string3 大
• 0 因为 string1 和 string3 相等

注意： 我们在程序开始时导入了 strings 并使用了 strings.Compare() 而不是 Compare()。

检查字符串中是否包含子串

要检查子串是否存在于字符串中，我们使用 Go strings 包的 Contains() 方法。

让我们看一个例子，

// 使用 Contains() 的程序

package main
import (
 "fmt"
 "strings"
)

func main() {

 text := "Go 编程"
 substring1 := "Go"
 substring2 := "Golang"

 // 检查 Go 是否存在于 Go 编程中
 result := strings.Contains(text, substring1)
 fmt.Println(result)

 // 检查 Golang 是否存在于 Go 编程中
 result = strings.Contains(text, substring2)
 fmt.Println(result)
}

输出

true
false

这里，我们得到输出

• true 因为子串 "Go" 存在于字符串 "Go 编程" 中
• false 因为子串 "Golang" 不存在于字符串 "Go 编程" 中

在 Go 中替换字符串

要替换字符串，我们使用 strings 包中的 Replace() 方法。例如，

// 使用 Replace() 替换字符串的程序

package main
import (
 "fmt"
 "strings"
)

func main() {

 text := "car"
 fmt.Println("旧字符串:", text)

 // 替换 r 为 t
 replacedText := strings.Replace(text, "r", "t", 1)

 fmt.Println("新字符串:", replacedText)
}

输出

旧字符串: car
新字符串: cat

注意 Replace() 方法的使用

strings.Replace(text, "r", "t", 1)

这里，

• text - 我们执行替换操作的字符串
• "r" - 需要被替换的旧字符
• "t" - 替换旧字符的新字符
• 1 - 表示需要替换多少个旧字符

注意： 如果我们需要替换多个字符，我们可以将数字的值从 1 改变为其他值。例如，

// 将 2 个 r 替换为 2 个 a
strings.Replace("Programiz", "r", "R", 2)

// 输出：PRogRamiz

更改 Go 字符串的大小写

字符串包提供了

• ToUpper() - 将字符串转换为大写
• ToLower() - 将字符串转换为小写

我们使用 ToUpper() 函数将给定的字符串转换为大写。ToUpper() 函数由 strings 包提供。例如，

// 将字符串转换为大写和小写的程序

package main
import (
 "fmt"
 "strings"
)

func main() {

 text1 := "go 学起来很有趣"

 // 转换为大写
 text1 = strings.ToUpper(text1)

 fmt.Println(text1)

 text2 := "I LOVE GOLANG"

 // 转换为小写
 text2 = strings.ToLower(text2)
 fmt.Println(text2)
}

输出

输出

GO IS FUN TO LEARN
i love golang

以下是代码的工作原理：

Golang 中分割字符串

在 Go 中，我们可以使用 Split() 方法将一个字符串分割成多个子字符串。例如，

package main
import (
 "fmt"
 "strings"
)

func main() {
 var message = "I Love Golang"

 // 以空格 " " 分割字符串
 splittedString := strings.Split(message, " ")

 fmt.Println(splittedString)
}

// 输出：[I Love Golang]

注意代码，

strings.Split(message, " ")

这里，我们在 " " 处分割字符串。因此，我们得到了单独的单词作为输出。

Split() 方法返回一个所有子字符串的切片。在我们的例子中，[I Love Golang] 就是一个切片。

其他字符串操作

使用 == 比较 Golang 字符串

在 Go 中，我们还可以使用 == 运算符比较两个字符串。例如，

// 使用 == 运算符比较两个字符串的程序

package main
import "fmt"

func main() {

// 创建 2 个字符串
 string1 := "Programiz"
 string2 := "mashangxue123"

 // 比较两个字符串
 result := string1 == string2

 fmt.Println(result)
}

// 输出：false

== 运算符返回

• true - 如果两个字符串相等
• false - 如果两个字符串不相等

注意： == 运算符区分大小写。因此，Programiz 和 mashangxue123 是不相等的。

从切片创建字符串

在 Go 中，我们还可以通过连接字符串切片的所有元素来创建一个字符串。例如，

// 使用 Join() 从字符串切片中创建单个字符串的程序

package main
import (
 "fmt"
 "strings"
)

func main() {

 // 创建一个字符串切片
 words := []string{"I", "love", "Golang"}

 // 连接切片中的每个元素
 message := strings.Join(words, " ")
 fmt.Println(message)
}

// 输出：I love Golang

这里，我们使用了 strings 包的 Join() 方法来连接切片中的每个元素。

要了解更多关于切片，请访问 Golang 切片。

在 Golang 中遍历字符串

我们使用 for range 循环来遍历 Golang 字符串的每个字符。例如，

// 遍历字符串的程序

package main
import "fmt"

func main() {
 text := "Golang"

 // 使用 for range 循环遍历字符串
 for _, character := range text {
 fmt.Printf("%c\n", character)
 }

}

输出

G
o
l
a
n
g

要了解 for range 循环，请访问 Go for range。

Golang 字符串中的转义序列

我们使用转义字符来转义字符串内部的某些字符。例如，

假设我们需要在字符串中包含双引号。

// 包含双引号
message := "This article is about "String" in Go Programming."

由于字符串是由双引号表示的，编译器将把 "This article is about " 当作字符串。因此，上面的代码会导致错误。

为了解决这个问题，我们可以在 Go 中使用转义字符 \。例如，

// 使用转义字符
message := "This article is about \"String\" in Go Programming."

现在，转义字符告诉编译器转义双引号，并读取整个文本。

示例：转义序列

package main
import "fmt"

func main() {

 // 在字符串中使用转义字符
 message := "This article is about \"String\" in Go Programming."

 fmt.Println(message)
}

// 输出：This article is about "String" in Go Programming.

注意：\n 和 \t 是其他常用的转义序列，它们在字符串中添加新行和制表符。

Go 字符串是不可变的

在 Go 中，字符串是不可变的。这意味着一旦我们创建了一个字符串，就不能更改它。

为了理解这一点，请考虑一个示例，

// 创建一个字符串
message := "Go"

这里，我们创建了一个名为 message 的字符串变量，其值为 "Go"。

现在，假设我们想更改这个字符串。

// 向之前的字符串中添加另一个字符串 "String"
message = message + " " + "String"

这里，我们使用 + 运算符将另一个字符串 "String" 添加到之前的字符串中。

看起来我们可以更改之前字符串的值。然而，事实并非如此。让我们看看这里发生了什么，

1. Go 创建了第一个字符串 "Go"
2. 然后通过将第一个字符串与 "String" 连接来创建另一个字符串
3. 将新字符串赋值给 message
4. 第一个字符串 "Go" 保持不变。