Go 字符串
- 字符串定义与基本使用:字符串是字符序列,用双引号表示。在 Go 中,可以使用
var
关键字或使用简写符号:=
来创建字符串变量。 - 字符串访问与长度计算:字符串的各个字符可以通过索引(从0开始)访问,使用
len()
函数可以获得字符串的长度。 - 字符串操作与方法: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]