1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

s := "héllo, 世界"

// ── 查找与判断 ──
strings.Contains(s, "ell")      // true
strings.ContainsAny(s, "xyz世") // true
strings.ContainsRune(s, '世')   // true
strings.HasPrefix(s, "hé")      // true
strings.HasSuffix(s, "界")      // true
strings.Index(s, "l")           // 3（字节下标！é 占 2 字节）
strings.LastIndex(s, "l")       // 4
strings.IndexByte(s, 'l')       // 3
strings.IndexRune(s, '世')      // 8（字节下标）🔥 下标是字节不是字符序号
strings.Count(s, "l")           // 2
strings.EqualFold("Go", "GO")   // true，忽略大小写
strings.Compare("a", "b")       // -1

1
2
3
4
5
6
7
8
9

// ── 切分 ──
strings.Cut("key=value", "=")         // "key" "value" true 🔥 最常见
strings.CutPrefix("prefix-x", "pre")  // "fix-x" true      🆕 1.20
strings.CutSuffix("x-suffix", "fix")  // "x-suf" true      🆕 1.20
strings.CutLast("a/b/c", "/")         // "a/b" "c" true    🆕 1.27
strings.Split("a,b,c", ",")           // ["a" "b" "c"]
strings.SplitN("a,b,c", ",", 2)       // ["a" "b,c"]
strings.Fields("  a  b\tc  ")         // ["a" "b" "c"]（按空白切）
strings.FieldsFunc("a1b2c", unicode.IsDigit) // ["a" "b" "c"]

1
2
3
4

Cut: "key" "value" true
"fix-x" true
"x-suf" true
a/b c true

1
2
3
4
5
6

for part := range strings.SplitSeq("a,b,c", ",") {
	fmt.Print(part, "|")
}
for line := range strings.Lines("l1\nl2\n") {
	fmt.Print("[", strings.TrimRight(line, "\n"), "]")
}

1
2

a|b|c|
[l1][l2]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// ── 变换 ──
strings.TrimSpace("  x  ")            // "x"
strings.TrimLeft("xxabc", "x")        // "abc"
strings.TrimPrefix("prefix", "pre")   // "fix"
strings.TrimSuffix("a.go", ".go")     // "a"
strings.ToUpper("go")                 // "GO"
strings.ToLower("GO")                 // "go"
strings.Title(s)                      // 🪦 已废弃：官方建议改 golang.org/x/text/cases
strings.ToTitle("hello world")        // "HELLO WORLD" ⚠️ 是全大写，不是首字母大写
strings.ToTitle(s) != strings.Title(s) // 两者语义完全不同，别混用
strings.Repeat("ab", 3)               // "ababab"
strings.Join([]string{"a","b"}, "-")  // "a-b"
strings.Replace("aaa", "a", "b", 2)   // "bba"（n<0 表示全部）
strings.ReplaceAll("aaa", "a", "b")   // "bbb"
strings.NewReplacer("a","1","b","2").Replace("abc")  // "12c"

1
2
3
4
5
6
7
8

var sb strings.Builder
sb.Grow(64)                 // 预分配，避免多次扩容 🔥
for i := range 3 {
	fmt.Fprintf(&sb, "%d,", i)
}
sb.String()                 // "0,1,2,"
sb.Len()                    // 6
sb.Reset()                  // 复用

1

builder: 0,1,2, len: 6

1

拷贝后再写入 → panic: strings: illegal use of non-zero Builder copied by value

1
2
3
4
5
6
7

var buf bytes.Buffer
buf.WriteString("hello ")
buf.WriteString("world")
buf.String()        // "hello world"
buf.Bytes()         // []byte，⚠️ 与 buf 共享底层
buf.Len()
buf.Reset()

1
2
3
4
5
6
7
8

b := []byte("hello")

// 标准写法：发生拷贝 ✅ 安全
s := string(b)

// 零拷贝写法：共享内存 ⚠️ 只能只读，且 b 不能再被修改
s2 := unsafe.String(&b[0], len(b))
b2 := unsafe.Slice(unsafe.StringData(s), len(s))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 整数
strconv.Itoa(42)                    // "42"
strconv.Atoi("123")                 // 123, nil
strconv.ParseInt("ff", 16, 64)      // 255, nil
strconv.FormatInt(255, 16)          // "ff"
strconv.FormatInt(255, 2)           // "11111111"

// 浮点
strconv.ParseFloat("3.14", 64)      // 3.14, nil
strconv.FormatFloat(3.14159, 'f', 2, 64)   // "3.14"
strconv.FormatFloat(0.00001234, 'e', 2, 64) // "1.23e-05"
strconv.FormatFloat(1234.5678, 'g', -1, 64) // "1234.5678"（最短表示）

// 布尔
strconv.ParseBool("true")           // true, nil
strconv.FormatBool(true)            // "true"

// 引号与转义
strconv.Quote("a\nb")               // "\"a\\nb\""
strconv.QuoteRune('世')              // "'世'"
strconv.Unquote(`"a\nb"`)           // "a\nb", nil

1
2
3
4
5
6

42 "a\nb"
123 <nil>
3.14 <nil>
true <nil>
ff 3.14
'世'

1
2
3

strconv.ParseInt("127", 10, 8)   // 127, nil
strconv.ParseInt("128", 10, 8)   // 127, error ⚠️ 不是返回 0！
strconv.ParseInt("0x1f", 0, 64)  // 31, nil（base=0 时自动识别前缀）

1
2

ParseInt("128", 10, 8)                       = 127,   value out of range
ParseInt("99999999999999999999", 10, 64)     = 9223372036854775807, value out of range

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import (
	"unicode"
	"unicode/utf8"
)

// 字符类别判断
unicode.IsLetter('A')     // true
unicode.IsDigit('5')      // true
unicode.IsSpace(' ')      // true
unicode.IsUpper('A')      // true
unicode.Is(unicode.Han, '世')  // true，是否汉字

// UTF-8 编解码
utf8.RuneCountInString("世界")   // 2（字符数）
utf8.ValidString("世界")         // true
utf8.RuneLen('世')               // 3
utf8.DecodeRuneInString("世界")  // '世', 3
utf8.EncodeRune(buf, '世')       // 写入 3 字节

// 按符文迭代（处理非法 UTF-8 时替换为 U+FFFD）
for i, r := range "a世" { ... }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

xs := []int{3, 1, 2}
slices.Sort(xs)                     // [1 2 3]

users := []User{{"b", 30}, {"a", 20}, {"c", 20}}
slices.SortFunc(users, func(a, b User) int {
	if c := cmp.Compare(a.Age, b.Age); c != 0 {
		return c    // 先按年龄
	}
	return cmp.Compare(a.Name, b.Name)   // 再按名字 🔥 多字段排序的标准写法
})
slices.SortStableFunc(users, func(a, b User) int { return cmp.Compare(a.Age, b.Age) })

idx, found := slices.BinarySearch([]int{1, 2, 3}, 2)   // 1, true（要求已排序）
slices.Contains(xs, 2)              // true
slices.Index(xs, 2)                 // 1
slices.Equal([]int{1, 2}, []int{1, 2})   // true
slices.Max(xs)                      // 3
slices.Compact([]int{1, 1, 2, 2, 3})     // [1 2 3]（去相邻重复）
slices.Insert([]int{1, 3}, 1, 2)    // [1 2 3]
slices.Delete([]int{1, 2, 3}, 1, 2) // [1 3]
slices.ContainsFunc(users, func(u User) bool { return u.Age > 25 })   // true

1
2
3
4

Sort: [1 2 3]
SortFunc: [{a 20} {c 20} {b 30}]
BinarySearch: 1 true
Compact: [1 2 3]

1
2
3
4
5
6
7
8
9

m := map[string]int{"c": 3, "a": 1, "b": 2}

slices.Sorted(maps.Keys(m))              // [a b c]，迭代器 → 有序切片 🔥
slices.Sorted(maps.Values(m))            // [1 2 3]
maps.Clone(m)                            // 浅拷贝
maps.Equal(map[string]int{"a": 1}, map[string]int{"a": 1})   // true
maps.DeleteFunc(m, func(k string, v int) bool { return v < 2 })
maps.Copy(dst, src)                      // 合并
maps.Insert(m, iter.Seq2[string, int])   // 🆕 1.23

1
2
3
4

cmp.Compare(1, 2)        // -1
cmp.Less(1, 2)           // true
cmp.Or("", "fallback")   // "fallback"  ← 取第一个非零值 🔥
cmp.Or(0, 0, 30)         // 30

1
2

timeout := cmp.Or(cfg.Timeout, 30*time.Second)
name := cmp.Or(req.Name, "anonymous")

1
2
3
4
5
6
7

// 旧 API（官方未标 deprecated，但新代码请用 slices）
sort.Slice(users, func(i, j int) bool { return users[i].Age < users[j].Age })
sort.SliceStable(...)
sort.Sort(byAge(users))          // 需要实现 sort.Interface
sort.Strings(ss)
sort.Ints(ns)
sort.Search(n, func(i int) bool { return ns[i] >= target })

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

re := regexp.MustCompile(`(\w+)@(\w+)\.com`)     // 专门匹配 email

fmt.Println(re.MatchString("a@b.com"))            // true
fmt.Println(re.FindString("contact a@b.com now")) // a@b.com
fmt.Println(re.FindStringSubmatch("a@b.com"))     // [a@b.com a b]
fmt.Println(re.ReplaceAllString("a@b.com", "$2#$1")) // b#a
fmt.Println(re.NumSubexp())                       // 2

digits := regexp.MustCompile(`\d+`)                 // 匹配数字，用途不同所以单独编译
fmt.Println(digits.FindAllString("a1b22c333", -1))                    // [1 22 333]
fmt.Println(digits.ReplaceAllStringFunc("a1b2", func(s string) string { return "<" + s + ">" })) // a<1>b<2>

ws := regexp.MustCompile(`\s+`)                     // 按空白切分
fmt.Println(ws.Split("a  b   c", -1))             // [a b c]

1
2
3
4
5
6
7
8

MatchString: true
FindString: a@b.com
FindStringSubmatch: [a@b.com a b]
ReplaceAllString: b#a
NumSubexp: 2
FindAllString: [1 22 333]
ReplaceAllStringFunc: a<1>b<2>
Split: [a b c]

1
2
3
4
5
6
7

re2 := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})`)
m := re2.FindStringSubmatch("2026-09")
for i, name := range re2.SubexpNames() {
	if name != "" {
		fmt.Println("named:", name, m[i])
	}
}

1
2

named: year 2026
named: month 09

1
2
3
4
5
6

// 🛑 每次调用都重新编译
func bad(s string) bool { return regexp.MustCompile(`^\d+$`).MatchString(s) }

// ✅ 包级编译一次
var digitsOnly = regexp.MustCompile(`^\d+$`)
func good(s string) bool { return digitsOnly.MatchString(s) }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

math.Round(2.5)      // 3   四舍五入（远离零）
math.Round(-2.5)     // -3  ⚠️ 不是银行家舍入
math.Round(2.4)      // 2
math.Floor(2.7)      // 2
math.Ceil(2.1)       // 3
math.Trunc(-2.7)     // -2  向零截断
math.Abs(-3.5)       // 3.5
math.Max(1, 2)       // 2
math.Pow(2, 10)      // 1024
math.Sqrt(16)        // 4
math.Mod(7, 3)       // 1
math.IsNaN(math.NaN())            // true（NaN != NaN，必须用它）
math.IsInf(math.Inf(1), 1)        // true
math.MaxInt64 / math.MinInt64     // 整数边界常量
math.MaxFloat64 / math.SmallestNonzeroFloat64

1
2
3
4
5
6

Round: 3 -3 2
Floor/Ceil/Trunc: 2 3 -2
Abs/Max/Min: 3.5 2 1
Pow/Sqrt: 1024 4
IsNaN: true true
Mod: 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import "math/rand/v2"

rand.IntN(100)              // [0,100) 的 int
rand.Float64()              // [0.0,1.0)
rand.N(10 * time.Second)    // 泛型：任意整数/时长类型 🔥
rand.Shuffle(n, swap)       // 洗牌
rand.Perm(5)                // 随机排列

// 可复现的随机源
r := rand.New(rand.NewPCG(1, 2))
r.IntN(100)

// 密码学安全要用 crypto/rand
import crand "crypto/rand"
b := make([]byte, 16)
crand.Read(b)

1
2
3
4
5
6
7
8

import "math/big"

a := big.NewInt(1)
a.Exp(big.NewInt(2), big.NewInt(100), nil)   // 2^100，精确
a.String()                                    // 1267650600228229401496703205376

f := new(big.Float).SetPrec(200)             // 200 位精度
r := new(big.Rat).SetFrac64(1, 3)            // 精确分数 1/3