Go语言字符串操作指南：简单易懂的实战技巧

// 定义一个字符串
greeting := "Hello, Go!"
fmt.Println(greeting) ?// 输出: Hello, Go!

str := "GoLang"
// str[0] = 'g' ?// 这会报错
newStr := "g" + str[1:]
fmt.Println(newStr) ?// 输出: golang, 通过创建新的字符串来"修改"原字符串

// 字符串和其对应的字节
str := "Hello"
for i := 0; i < len(str); i++ {
? ? fmt.Printf("%x ", str[i]) ?// 输出每个字符的十六进制表示
}
// 输出: 48 65 6c 6c 6f

// byte和ASCII字符
byteValue := byte('A')
fmt.Println(byteValue) ?// 输出: 65
// rune和UTF-8字符
runeValue := rune('你')
fmt.Printf("%#U \n", runeValue) ?// 输出: U+4F60

// 字符串连接
str1 := "Hello"
str2 := "World"
result := str1 + ", " + str2
fmt.Println(result) ?// 输出: Hello, World

// 字符串切片
str := "GoLang"
subStr := str[2:4]
fmt.Println(subStr) ?// 输出: La

import "strings"

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

position := strings.Index(str, "Go")
fmt.Println(position) ?// 输出: 7

str1 := "apple"
str2 := "banana"

// 使用==比较字符串
isEqual := str1 == str2
fmt.Println(isEqual) ?// 输出: false

// 使用strings.Compare比较字符串
compResult := strings.Compare(str1, str2)
fmt.Println(compResult) ?// 输出: -1, 表示str1在str2之前

source := "go is good, go is great"
replaced := strings.ReplaceAll(source, "go", "Go")
fmt.Println(replaced) ?// 输出: Go is good, Go is great

str := "GoLang"
lowercase := strings.ToLower(str)
uppercase := strings.ToUpper(str)
fmt.Println(lowercase) ?// 输出: golang
fmt.Println(uppercase) ?// 输出: GOLANG

import "regexp"

str := "My email is example@example.com"
re := regexp.MustCompile(`[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}`)
email := re.FindString(str)
fmt.Println(email) ?// 输出: example@example.com

import (
? ? "crypto/md5"
? ? "fmt"
? ? "io"
)
str := "secret data"
hasher := md5.New()
io.WriteString(hasher, str)
fmt.Printf("%x\n", hasher.Sum(nil)) ?// 输出: md5哈希值

str := "apple,banana,cherry"
items := strings.Split(str, ",")
fmt.Println(items) ?// 输出: [apple banana cherry]

items := []string{"apple", "banana", "cherry"}
str := strings.Join(items, ", ")
fmt.Println(str) ?// 输出: apple, banana, cherry

str := "Go"
byteValue := str[1]
fmt.Println(byteValue) ?// 输出: 111 (ASCII码的'o')

str := "Go"
for index, char := range str {
? ? fmt.Printf("At index %d, char: %c\n", index, char)
}

str := " ? Go Lang ? "
trimmed := strings.TrimSpace(str)
fmt.Println(trimmed) ?// 输出: Go Lang

str := "Go"
padded := fmt.Sprintf("%-10s", str)
fmt.Println(padded) ?// 输出: Go ? ? ? ?

str := "Go is easy to learn. Go is powerful."
count := strings.Count(str, "Go")
fmt.Println(count) ?// 输出: 2

import "strings"
str := "go is awesome"
title := strings.Title(str)
fmt.Println(title) ?// 输出: Go Is Awesome

import "strconv"
number := 12345
strNum := strconv.Itoa(number)
fmt.Println(strNum) ?// 输出: "12345"

import "unicode"
ch := 'A'
isLetter := unicode.IsLetter(ch)
fmt.Println(isLetter) ?// 输出: true

str := "Go"
for i := 0; i < len(str); i++ {
? ? fmt.Printf("%x ", str[i])
}
// 输出: 47 6f?

str := "语言"
for _, char := range str {
? ? fmt.Printf("U+%04X ", char)
}
// 输出: U+8BED U+8A00

str := "语言"
byteLen := len(str)
runeLen := utf8.RuneCountInString(str)
fmt.Println(byteLen) ?// 输出: 6
fmt.Println(runeLen) ?// 输出: 2

str := "语言"
runes := []rune(str)
fmt.Println(runes) ?// 输出: [35821 35328]

// 请首先安装 golang.org/x/text/encoding
import "golang.org/x/text/encoding/simplifiedchinese"
import "golang.org/x/text/transform"
str := "语言"
encoder := simplifiedchinese.GB18030.NewEncoder()
encoded, _, _ := transform.String(encoder, str)
fmt.Println(encoded) ?// 输出: GBK编码的字符串

num := 123
str := strconv.Itoa(num)
fmt.Println(str) ?// 输出: "123"

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

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

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

str := "Go"
bytes := []byte(str)
fmt.Println(bytes) ?// 输出: [71 111]

bytes := []byte{72, 101, 108, 108, 111}
str := string(bytes)
fmt.Println(str) ?// 输出: "Hello"