本文介绍一种更可靠、可维护的 Go 字符串解析策略：避开复杂单正则匹配，转而采用“定位→分割→逐项解析”的三步法，高效处理 {...} 内逗号分隔、含范围（如 1-9、a-f）与自由项（如 aa、b+）混合的语法结构。
本文介绍一种更可靠、可维护的 go 字符串解析策略：避开复杂单正则匹配，转而采用“定位→分割→逐项解析”的三步法，高效处理 `{...}` 内逗号分隔、含范围（如 `1-9`、`a-f`）与自由项（如 `aa`、`b+`）混合的语法结构。
在 Go 中直接用单个正则表达式完整匹配形如 {aa,bb,cc,1-9,a-f,b+,x-C} 这类嵌套结构，不仅难以覆盖所有合法变体（如空格、换行、混合类型、边界情况），还极易因回溯爆炸或捕获组嵌套导致性能下降与维护困难。与其强行堆砌 (?:...) 和 [\w-]+ 组合，不如回归解析本质——分层解耦。
✅ 推荐方案：三步正交解析
- 定位所有 {...} 块：使用非贪婪匹配提取内容主体；
- 按逗号分割各块内部：规范化空白后切分，得到原子片段；
- 逐项语义解析：对每个片段独立判断是字面量、数字范围还是字符范围。
以下是完整可运行示例：
package main
import (
"fmt"
"regexp"
"strings"
)
func parseBracedGroups(s string) [][]string {
// Step 1: 提取所有 {} 内容（非贪婪，避免跨组匹配）
reGroup := regexp.MustCompile(`\{([^}]*)\}`)
matches := reGroup.FindAllStringSubmatch([]byte(s), -1)
var result [][]string
for _, m := range matches {
// m[0] 是 "{...}"，m[1] 是内部内容（不含花括号）
content := strings.TrimSpace(string(m[1]))
if content == "" {
result = append(result, []string{}) // 支持空组 {}
continue
}
// Step 2: 按逗号分割，自动 trim 空格/制表符
parts := regexp.MustCompile(`\s*,\s*`).Split(content, -1)
for i := range parts {
parts[i] = strings.TrimSpace(parts[i])
}
result = append(result, parts)
}
return result
}
// 示例用法
func main() {
s := "{aa,bb,cc, dd}, {a+,\tb+,c+}, {1-9}, {1-9,10,19,20-52}, {a-f}, {A-F}, {x-C}, {}"
groups := parseBracedGroups(s)
for i, group := range groups {
fmt.Printf("Group %d: %v\n", i+1, group)
}
}
输出结果：
Group 1: [aa bb cc dd] Group 2: [a+ b+ c+] Group 3: [1-9] Group 4: [1-9 10 19 20-52] Group 5: [a-f] Group 6: [A-F] Group 7: [x-C] Group 8: []
⚠️ 关键注意事项
- 不要尝试用一个正则解决全部：{1-9,10,19,20-52} 中既有范围又有离散值，正则无法自然区分语义层级；
- 优先考虑可读性与扩展性：后续若需支持 a*b+、[0-9]+ 或转义 ,（如 \,），只需增强第 3 步逻辑，无需重写整个正则；
- 注意边界安全：使用 [^}]* 替代 .+? 可避免意外跨越多个 }；FindAllStringSubmatch 比 FindAllString 更利于精准提取子匹配；
- 空组与空白处理：显式检查 content == "" 并保留空切片，符合多数 DSL 解析约定。
✅ 后续解析建议（第 3 步延伸）
对每个原子片段（如 "20-52" 或 "b+"），可进一步定义解析器：
type Token struct {
Literal string // "aa", "b+"
Range struct {
Start, End interface{} // int or rune
} `json:",omitempty"`
}
func parseToken(s string) Token {
if strings.Contains(s, "-") && len(strings.Split(s, "-")) == 2 {
parts := strings.Split(s, "-")
if start, end := parseRuneOrInt(parts[0]), parseRuneOrInt(parts[1]); start != nil && end != nil {
return Token{Range: struct{ Start, End interface{} }{start, end}}
}
}
return Token{Literal: s}
}
这种分治策略让代码职责清晰、测试友好、演进灵活——这正是 Go “简单即强大”哲学的典型体现。
