字符串与 UTF-8：为什么 len("你好") 是 6

package main

import "fmt"

func main() {
    name := "摸鱼 hello"

    fmt.Println("len(name) =", len(name)) // 字节数
    fmt.Println("name[:10] =", name[:10]) // 按字节截断
    fmt.Printf("name[0] = %q\n", name[0]) // 下标取到的是 byte
}

len(name) = 12
name[:10] = 摸鱼 he
name[0] = '\xe6'

s := "鱼"

内存字节: E9 B1 9C        <- UTF-8 编码（3 字节）
码点:     U+9C7C          <- unicode.ToUpper/IsLetter 操作的对象
下标:     s[0] = 0xE9     <- byte
range:    i=0, r='鱼'     <- 字节下标 + 码点

s := "鱼Go"

for i, r := range s {
    fmt.Printf("字节下标 %d, 码点 %c, 编码 %U\n", i, r, r)
}

字节下标 0, 码点 鱼, 编码 U+9C7C
字节下标 3, 码点 G, 编码 U+0047
字节下标 4, 码点 o, 编码 U+006F

import (
    "unicode/utf8"
)

fmt.Println(utf8.RuneCountInString("鱼Go")) // 3
fmt.Println(len([]rune("鱼Go")))            // 3，但多付一次切片分配

bad := string([]byte{0xE6, 0x96, 0x87, 0xFF, 'x'}) // 0xFF 是非法字节

for i, r := range bad {
    fmt.Printf("i=%d r=%q\n", i, r)
}
fmt.Println("字节数:", len(bad), "码点数:", utf8.RuneCountInString(bad))
fmt.Println("是否合法 UTF-8:", utf8.ValidString(bad))

i=0 r='文'
i=3 r='\ufffd'
i=4 r='x'
字节数: 5 码点数: 3
是否合法 UTF-8: false

func TruncateByRunes(s string, n int) string {
    if utf8.RuneCountInString(s) <= n {
        return s
    }
    for i := range s { // i 依次取每个码点的起始字节下标
        if n == 0 {
            return s[:i] // 字节下标必然落在边界上，切出来仍是合法 UTF-8
        }
        n--
    }
    return s
}

// 反例：O(n^2)，一万个片段就是一万次整串复制
var s string
for _, p := range parts {
    s += p
}

// 正解：O(n) 摊销，Builder 不可复制（编译器会拦住误用）
var b strings.Builder
b.Grow(estimate) // 已知大小时预分配，再省一轮扩容
for _, p := range parts {
    b.WriteString(p)
}
result := b.String()

n, err := strconv.Atoi("42")          // string -> int，带错误返回（输入可能不是数字）
s1 := strconv.Itoa(42)                // int -> string
f, err := strconv.ParseFloat("3.14", 64)
s2 := strconv.FormatFloat(3.14, 'f', 2, 64) // 固定两位小数
s3 := fmt.Sprintf("%d 元", 42)        // 多变量格式化，比 strconv 灵活但更慢

string(65)          // "A"（按码点解释）
string(rune(65))    // "A"，显式写法，意图清晰
strconv.Itoa(65)    // "65"（想要的一般是这个）

strings.Contains(s, "go")        // 是否包含
strings.HasPrefix(s, "http")     // 前缀判断（常与 HasSuffix 一起用于路由/文件名）
strings.Index(s, "go")           // 子串首次出现的字节下标，没有返回 -1
strings.Fields(s)                // 按任意空白切分（比 Split(" ") 更能处理多空格）
strings.Split(s, ",")            // 按分隔符切分
strings.Join(parts, ",")         // 拼回
strings.TrimSpace(s)             // 去两端空白
strings.ReplaceAll(s, "a", "b")  // 全量替换；Replace 可限次数
strings.Cut(s, "=")              // 1.18 起：按首个分隔符切成前后两段，自带是否找到

rs := []rune("你好")
for i, j := 0, len(rs)-1; i < j; i, j = i+1, j-1 {
    rs[i], rs[j] = rs[j], rs[i]
}
fmt.Println(string(rs)) // 好你

package main

import (
    "bufio"
    "fmt"
    "os"
    "unicode"
    "unicode/utf8"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Scan()
    s := scanner.Text()

    letters, digits := 0, 0
    for _, r := range s { // 码点层遍历
        switch {
        case unicode.IsLetter(r):
            letters++
        case unicode.IsDigit(r):
            digits++
        }
    }
    fmt.Println("字节:", len(s))
    fmt.Println("码点:", utf8.RuneCountInString(s))
    fmt.Println("字母:", letters)
    fmt.Println("数字:", digits)
}

func TestTruncateByRunes(t *testing.T) {
    cases := []struct {
        in   string
        n    int
        want string
    }{
        {"hello", 3, "hel"},
        {"摸鱼", 1, "摸"},
        {"摸鱼", 5, "摸鱼"},   // n 超出总数
        {"", 2, ""},
        {"a鱼b", 2, "a鱼"}, // 边界落在多字节码点之后
    }
    for _, c := range cases {
        got := TruncateByRunes(c.in, c.n)
        if got != c.want {
            t.Errorf("Truncate(%q,%d) = %q, want %q", c.in, c.n, got, c.want)
        }
        if !utf8.ValidString(got) {
            t.Errorf("结果不是合法 UTF-8: %q", got)
        }
    }
}

func BenchmarkPlusConcat(b *testing.B) {
    parts := make([]string, 10000)
    for i := range parts {
        parts[i] = "片段"
    }
    b.ReportAllocs()
    for b.Loop() {
        var s string
        for _, p := range parts {
            s += p
        }
        _ = s
    }
}

func BenchmarkBuilderConcat(b *testing.B) {
    parts := make([]string, 10000)
    for i := range parts {
        parts[i] = "片段"
    }
    b.ReportAllocs()
    for b.Loop() {
        var bd strings.Builder
        bd.Grow(len(parts) * len("片段")) // 字节层预算正是 len 的正确用法
        for _, p := range parts {
            bd.WriteString(p)
        }
        _ = bd.String()
    }
}