Golang中如何计算固定宽度文件的UTF8字符数

在处理固定宽度文件时，确实需要按符文（rune）计数而不是字节数。以下是更高效的实现方式：

func processRow(row string) error {
    // 直接使用符文迭代器处理字段
    var col1, col2, col3 strings.Builder
    count := 0
    
    for _, r := range row {
        switch count {
        case 0:
            col1.WriteRune(r)
        case 1:
            col2.WriteRune(r)
        case 2:
            col3.WriteRune(r)
        }
        count++
    }
    
    if count != 3 {
        return fmt.Errorf("invalid row length: %v", count)
    }
    
    fmt.Printf("Row columns: %v, %v, %v.", 
        col1.String(), col2.String(), col3.String())
    return nil
}

对于更通用的解决方案，可以这样处理任意数量的字段：

func splitFixedWidth(row string, fieldWidths []int) ([]string, error) {
    var result []string
    var current strings.Builder
    runeCount := 0
    fieldIndex := 0
    
    for _, r := range row {
        current.WriteRune(r)
        runeCount++
        
        if fieldIndex < len(fieldWidths) && runeCount == fieldWidths[fieldIndex] {
            result = append(result, current.String())
            current.Reset()
            runeCount = 0
            fieldIndex++
        }
    }
    
    // 检查是否还有剩余字符
    if current.Len() > 0 {
        return nil, fmt.Errorf("extra characters after last field")
    }
    
    if fieldIndex != len(fieldWidths) {
        return nil, fmt.Errorf("insufficient characters for all fields")
    }
    
    return result, nil
}

// 使用示例
func main() {
    row := "Ñ世界"
    fields, err := splitFixedWidth(row, []int{1, 1, 1})
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Printf("Row columns: %v, %v, %v\n", fields[0], fields[1], fields[2])
}

如果字段宽度相同，可以使用更简洁的版本：

func splitEqualWidth(row string, width, numFields int) ([]string, error) {
    result := make([]string, 0, numFields)
    runes := []rune(row)
    
    if len(runes) != width*numFields {
        return nil, fmt.Errorf("invalid row length")
    }
    
    for i := 0; i < len(runes); i += width {
        result = append(result, string(runes[i:i+width]))
    }
    
    return result, nil
}

这些方法避免了创建中间符文切片，直接处理符文迭代，内存效率更高。对于性能关键场景，可以预分配缓冲区：

func processRowEfficient(row string) error {
    if utf8.RuneCountInString(row) != 3 {
        return fmt.Errorf("invalid row length")
    }
    
    // 预分配符文数组
    runes := [3]rune{}
    i := 0
    for _, r := range row {
        runes[i] = r
        i++
    }
    
    // 直接使用数组切片
    col1 := string(runes[0:1])
    col2 := string(runes[1:2])
    col3 := string(runes[2:3])
    
    fmt.Printf("Row columns: %v, %v, %v.", col1, col2, col3)
    return nil
}