字符串

Go 中的字符串是字节序列的只读切片。Go 语言将字符串当作 UTF-8 编码文本的容器，这使其能够表示来自不同语言的各种字符。

package main

import "fmt"

func main() {
    // 声明并初始化一个包含英文字母和中文字符的字符串
    str := "Hello, 世界"

    // 打印字符串
    fmt.Println("String:", str)
    // => String: Hello, 世界

    // 访问字符串中的单个字节
    char := str[0] // T这给出的是字节值，而不是字符
    fmt.Printf("Byte Value: %c\n", char)
    // => Byte Value: H

    // 字符串长度
    length := len(str)
    fmt.Println("String Length:", length)
    // => String Length: 13
    // 7(Hello, ) + 6(世界) = 13
}

Runes 符文

在其他语言中，字符串由“字符”组成。在 Go 中，字符的概念称为 rune，可译为符文。 它是 int32 的别名。Runes 用于表示字符串中的单个字符，使得处理 Unicode 字符更为方便。

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
    // 声明并初始化一个符文
    var r rune = '世'
    fmt.Printf("Rune: %c\n", r)
    // => Rune: 世

    str := "Hello, 世界"
   
    // 计算字符串的符文长度
    runeCount := utf8.RuneCountInString(str)
    // 7(Hello, ) + 2(世界) = 9

    fmt.Printf("String: %s, in bytes: %d, in runes: %d", str, len(str), runeCount)
    // => String: Hello, 世界, in bytes: 13, in runes: 9
}

格式化

fmt 包提供了各种用于格式化字符串的函数，类似于 C 中的 printf 函数系列。

package main

import "fmt"

func main() {
    name := "John"
    age := 30

    // 基本字符串格式化
    fmt.Printf("Name: %s, Age: %d\n", name, age)

    // 宽度和精度
    value := 123.456789

    fmt.Printf("Default: %f\n", value)
    fmt.Printf("Width 8: %8f\n", value)
    fmt.Printf("Precision 2: %.2f\n", value)
    fmt.Printf("Width 8, Precision 2: %8.2f\n", value)
}

你还可以使用 Sprintf 格式化生成一个字符串供后续使用。

package main

import "fmt"

func main() {
    name := "Alice"
    age := 25

    // 使用 Sprintf 格式化字符串
    formattedString := fmt.Sprintf("Name: %s, Age: %d", name, age)
    // ...
}

使用占位符进行格式化

Printf 函数系列支持各种占位符，用于格式化不同类型的值。

例如：

• %s: 字符串
• %b: 二进制
• %c: 字符
• %d: 十进制（整数）
• %f: 浮点数
• %e: 科学计数法表示的浮点数
• %x: 十六进制编码
• %t: 布尔
• %v: 默认格式
• %T: 值的类型

package main

import "fmt"

type point struct {
    x, y int
}

func main() {
    p := point{5, 8}
    fmt.Printf("struct1: %v\n", p)
    fmt.Printf("struct2: %+v\n", p)
    fmt.Printf("struct3: %#v\n", p)

    fmt.Printf("type: %T\n", p)
    fmt.Printf("bool: %t\n", true)
    fmt.Printf("int: %d\n", 58)
    fmt.Printf("bin: %b\n", 58)
    fmt.Printf("char: %c\n", 72)
    fmt.Printf("hex: %x\n", 5858)

    fmt.Printf("float1: %f\n", 58.9)
    fmt.Printf("float2: %e\n", 158800000.0)
    fmt.Printf("float3: %E\n", 158800000.0)

    fmt.Printf("str1: %s\n", "\"abc\"")
    fmt.Printf("str2: %q\n", "\"abc\"")
    fmt.Printf("str3: %x\n", "hello")

    fmt.Printf("pointer: %p\n", &p)

    fmt.Printf("width1: |%6d|%6d|\n", 12, 586)
    fmt.Printf("width2: |%6.2f|%6.2f|\n", 1.2, 3.45)
    fmt.Printf("width3: |%-6.2f|%-6.2f|\n", 1.2, 3.45)
    fmt.Printf("width4: |%6s|%6s|\n", "lite", "r")
    fmt.Printf("width5: |%-6s|%-6s|\n", "lite", "rank")
}

其输出：

struct1: {5 8}
struct2: {x:5 y:8}
struct3: main.point{x:5, y:8}
type: main.point
bool: true
int: 58
bin: 111010
char: H
hex: 16e2
float1: 58.900000
float2: 1.588000e+08
float3: 1.588000E+08
str1: "abc"
str2: "\"abc\""
str3: 68656c6c6f
pointer: 0xc0000a4000
width1: |    12|   586|
width2: |  1.20|  3.45|
width3: |1.20  |3.45  |
width4: |  lite|     r|
width5: |lite  |rank  |

字符串函数

Go 提供了许多用于处理字符串的函数，其中许多函数来自标准库 strings。

package main

import (
	"fmt"
	"strings"
)

func main() {
	// len - 字符串长度
	str3 := "Hello, Literank!"
	length := len(str3)
	fmt.Println("String Length:", length)

	// strings.Contains - 检查子串
	contains := strings.Contains(str3, "Golang")
	fmt.Println("Contains 'Golang':", contains)

	// strings.ToLower 和 strings.ToUpper - 更改大小写
	lower := strings.ToLower(str3)
	upper := strings.ToUpper(str3)
	fmt.Println("Lowercase:", lower)
	fmt.Println("Uppercase:", upper)

	// strings.Split - 拆分字符串
	str4 := "apple,orange,banana"
	parts := strings.Split(str4, ",")
	fmt.Println("Split String:", parts)

	// strings.Join - 连接字符串
	joined := strings.Join(parts, ", ")
	fmt.Println("Joined String:", joined)

	// strings.Replace - 替换子串
	replaced := strings.Replace(str3, "Literank", "World", -1)
	fmt.Println("Replaced String:", replaced)

	// strings.TrimSpace - 删除空格
	str5 := "   Hello, Golang!   "
	trimmed := strings.TrimSpace(str5)
	fmt.Println("Trimmed String:", trimmed)
}

代码挑战

编写一个 Go 函数，检查给定的字符串是否是回文。
回文是一个忽略空格、标点和大小写情况下从前往后读和从后往前读都是一样的字符串。