【Golang】语法基础——字符串处理详解

🚀本系列文章为个人学习笔记，目的是巩固知识并记录我的学习过程及理解。文笔和排版可能拙劣，望见谅。

---

目录

1. 简介
2. 字符串基础
   • 2.1 字符串的定义
   • 2.2 字符串的不可变性
3. 字符串操作
   • 3.1 字符串连接
   • 3.2 字符串长度
   • 3.3 字符串索引和切片
   • 3.4 遍历字符串
4. 字符串常用函数
   • 4.1 大小写转换
   • 4.2 字符串包含
   • 4.3 前缀和后缀
   • 4.4 字符串替换
   • 4.5 字符串分割
   • 4.6 去除空白字符
5. 字符串格式化
   • 5.1 格式化输出
   • 5.2 Sprintf 函数
6. 字符串转换
   • 6.1 字符串与整数转换
   • 6.2 字符串与浮点数转换
   • 6.3 字符串与布尔值转换

---

1. 简介

在 Go 语言中，字符串处理是一个非常常见的需求。本文将详细介绍 Go 语言中字符串的定义、操作、常用函数、格式化和转换方法。

2. 字符串基础

2.1 字符串的定义

在 Go 中，字符串是用双引号 "" 括起来的字符序列。

str := "Hello, World!"

2.2 字符串的不可变性

字符串在 Go 中是不可变的，即创建之后不能修改其内容。

str := "Hello"
str[0] = 'h' // 编译错误: cannot assign to str[0]

3. 字符串操作

3.1 字符串连接

使用 + 运算符可以连接两个字符串。

str1 := "Hello, "
str2 := "World!"
result := str1 + str2
fmt.Println(result) // 输出: Hello, World!

3.2 字符串长度

使用 len 函数可以获取字符串的长度（字节数）。

str := "Hello, World!"
length := len(str)
fmt.Println(length) // 输出: 13

3.3 字符串索引和切片

通过索引可以获取字符串中的单个字符，通过切片可以获取字符串的子字符串。

str := "Hello, World!"
fmt.Println(str[0])       // 输出: 72 (字符 'H' 的 ASCII 码)
fmt.Println(str[0:5])     // 输出: Hello
fmt.Println(str[:5])      // 输出: Hello
fmt.Println(str[7:])      // 输出: World!
fmt.Println(str[:])       // 输出: Hello, World!

3.4 遍历字符串

可以使用 for-range 语句遍历字符串中的每个字符。

str := "Hello, 世界"
for i, c := range str {
    fmt.Printf("%d: %c\n", i, c)
}
// 输出:
// 0: H
// 1: e
// 2: l
// 3: l
// 4: o
// 5: ,
// 6:  
// 7: 世
// 10: 界

4. 字符串常用函数

4.1 大小写转换

使用 strings 包中的 ToUpper 和 ToLower 函数可以进行大小写转换。

import "strings"

str := "Hello, World!"
fmt.Println(strings.ToUpper(str)) // 输出: HELLO, WORLD!
fmt.Println(strings.ToLower(str)) // 输出: hello, world!

4.2 字符串包含

使用 strings 包中的 Contains 函数可以判断一个字符串是否包含另一个字符串。

import "strings"

str := "Hello, World!"
fmt.Println(strings.Contains(str, "World")) // 输出: true
fmt.Println(strings.Contains(str, "Go"))    // 输出: false

4.3 前缀和后缀

使用 strings 包中的 HasPrefix 和 HasSuffix 函数可以判断字符串是否具有指定的前缀或后缀。

import "strings"

str := "Hello, World!"
fmt.Println(strings.HasPrefix(str, "Hello")) // 输出: true
fmt.Println(strings.HasSuffix(str, "World!")) // 输出: true

4.4 字符串替换

使用 strings 包中的 Replace 函数可以替换字符串中的部分内容。

import "strings"

str := "Hello, World!"
newStr := strings.Replace(str, "World", "Go", 1)
fmt.Println(newStr) // 输出: Hello, Go!

4.5 字符串分割

使用 strings 包中的 Split 函数可以将字符串分割为子字符串切片。

import "strings"

str := "Hello, World!"
parts := strings.Split(str, ", ")
fmt.Println(parts) // 输出: [Hello World!]

4.6 去除空白字符

使用 strings 包中的 TrimSpace 函数可以去除字符串两端的空白字符。

import "strings"

str := "   Hello, World!   "
trimmedStr := strings.TrimSpace(str)
fmt.Println(trimmedStr) // 输出: Hello, World!

5. 字符串格式化

5.1 格式化输出

使用 fmt 包中的 Printf 函数可以格式化输出字符串。

import "fmt"

name := "Alice"
age := 30
fmt.Printf("Name: %s, Age: %d\n", name, age) // 输出: Name: Alice, Age: 30

5.2 Sprintf 函数

使用 fmt 包中的 Sprintf 函数可以格式化字符串并返回结果。

import "fmt"

name := "Alice"
age := 30
str := fmt.Sprintf("Name: %s, Age: %d", name, age)
fmt.Println(str) // 输出: Name: Alice, Age: 30

6. 字符串转换

6.1 字符串与整数转换

使用 strconv 包中的 Atoi 和 Itoa 函数可以进行字符串与整数的转换。

import (
    "fmt"
    "strconv"
)

str := "123"
num, err := strconv.Atoi(str)
if err != nil {
    fmt.Println(err)
}
fmt.Println(num) // 输出: 123

num = 456
str = strconv.Itoa(num)
fmt.Println(str) // 输出: 456

6.2 字符串与浮点数转换

使用 strconv 包中的 ParseFloat 和 FormatFloat 函数可以进行字符串与浮点数的转换。

import (
    "fmt"
    "strconv"
)

str := "123.45"
f, err := strconv.ParseFloat(str, 64)
if err != nil {
    fmt.Println(err)
}
fmt.Println(f) // 输出: 123.45

f = 456.78
str = strconv.FormatFloat(f, 'f', 2, 64)
fmt.Println(str) // 输出: 456.78

6.3 字符串与布尔值转换

使用 strconv 包中的 ParseBool 和 FormatBool 函数可以进行字符串与布尔值的转换。

import (
    "fmt"
    "strconv"
)

str := "true"
b, err := strconv.ParseBool(str)
if err != nil {
    fmt.Println(err)
}
fmt.Println(b) // 输出: true

b = false
str = strconv.FormatBool(b)
fmt.Println(str) // 输出: false

---