Go语言中处理UTF-8字符串的字节与字符索引偏移问题

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "ウ"
    fmt.Printf("字符串 \"%s\" 的字节长度：%d\n", s, len(s)) // 输出：字符串 "ウ" 的字节长度：3
    fmt.Printf("字符串 \"%s\" 的字符数量：%d\n", s, utf8.RuneCountInString(s)) // 输出：字符串 "ウ" 的字符数量：1
}

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "ウィキa" // "ウィ" 是两个多字节字符，"キ"也是多字节字符
    // 假设我们期望 'a' 的字符索引是 3 (0:ウ, 1:ィ, 2:キ, 3:a)

    // regexp.FindStringIndex 返回的是字节索引
    matchIndex := regexp.MustCompile(`a`).FindStringIndex(text)
    fmt.Printf("字符串 \"%s\" 中 'a' 的字节索引：%v\n", text, matchIndex) // 输出：字符串 "ウィキa" 中 'a' 的字节索引：[9 10]
    // 解释：
    // 'ウ' 占用 3 字节 (0-2)
    // 'ィ' 占用 3 字节 (3-5)
    // 'キ' 占用 3 字节 (6-8)
    // 'a' 占用 1 字节 (9)
    // 所以 'a' 的起始字节索引是 9，结束字节索引是 10。
}

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    text := "ウィキa"

    // 创建一个 strings.Reader，它实现了 io.RuneReader 接口
    reader := strings.NewReader(text)

    // 使用 FindReaderIndex 查找，它返回的是字符索引
    matchIndex := regexp.MustCompile(`a`).FindReaderIndex(reader)

    // FindReaderIndex 返回的索引是基于字符计数的
    fmt.Printf("字符串 \"%s\" 中 'a' 的字符索引：%v\n", text, matchIndex) // 输出：字符串 "ウィキa" 中 'a' 的字符索引：[3 4]
    // 解释：
    // 'ウ' 是第 0 个字符
    // 'ィ' 是第 1 个字符
    // 'キ' 是第 2 个字符
    // 'a' 是第 3 个字符
    // 所以 'a' 的起始字符索引是 3，结束字符索引是 4。
}

package main

import (
    "fmt"
    "regexp"
    "unicode/utf8" // 导入 utf8 包
)

func main() {
    s := "ab日aba本語ba"

    // 1. 使用 regexp.FindAllStringIndex 获取所有匹配项的字节索引
    byteIndexes := regexp.MustCompile(`a`).FindAllStringIndex(s, -1)
    fmt.Println("原始字节索引:", byteIndexes) // 输出：原始字节索引: [[0 1] [5 6] [7 8] [15 16]]

    // 2. 构建字节位置到字符位置的映射表
    // posMap[byte_position] = offset_from_byte_to_char
    posMap := make([]int, len(s)+1) // 长度为 len(s)+1，因为索引可能到 len(s)

    offset := 0 // 当前字符位置相对于字节位置的偏移量
    // 遍历字符串的每一个 rune
    for bytePos, char := range s {
        // bytePos 是当前 rune 的起始字节索引
        // char 是当前的 rune 值

        // 记录从 bytePos 到 charPos 需要减去的偏移量
        // 这里的 offset 累积了之前所有多字节字符造成的偏移
        posMap[bytePos] = offset

        // 计算当前 rune 的字节长度
        runeLen := utf8.RuneLen(char)

        // 如果当前 rune 是多字节字符，则增加偏移量
        // offset 记录的是“字符位置”比“字节位置”少的数量
        if runeLen > 1 {
            offset += (runeLen - 1)
        }
    }
    // 最后一个位置的映射，用于处理结束索引
    posMap[len(s)] = offset 

    fmt.Println("位置映射表 (bytePos -> offset):", posMap)

    // 3. 根据映射表转换字节索引为字符索引
    charIndexes := make([][]int, len(byteIndexes))
    for i, byteIndexPair := range byteIndexes {
        startByte := byteIndexPair[0]
        endByte := byteIndexPair[1]

        // 字符起始位置 = 字节起始位置 - 对应字节位置的偏移量
        charStart := startByte - posMap[startByte]
        // 字符结束位置 = 字节结束位置 - 对应字节位置的偏移量
        charEnd := endByte - posMap[endByte]

        charIndexes[i] = []int{charStart, charEnd}
    }
    fmt.Println("转换后的字符索引:", charIndexes) // 输出：转换后的字符索引: [[0 1] [3 4] [5 6] [9 10]]

    // 验证 "ab日aba本語ba"
    // 0:a, 1:b, 2:日(char), 3:a, 4:b, 5:a, 6:本(char), 7:語(char), 8:b, 9:a
    // 'a' at char 0 -> [0 1]
    // 'a' at char 3 -> [3 4]
    // 'a' at char 5 -> [5 6]
    // 'a' at char 9 -> [9 10]
    // 结果符合预期。
}