如何高效移除字符串中货币值里的转义反斜杠？

需求：移除长字符串中类似(23\,07 USD)格式货币值里的前置反斜杠，最终得到(23,07 USD)。示例长字符串为：fjsdkjfd$$klsgf|fj15%fdsjkl|gdag-63431|(34\,21 USD)|czjfkljsdklfjk。当前已有Go语言实现，询问是否有更高效的方案。

原实现代码：

package main

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

var (
    s = `fjsdkjfd$$klsgf|fj15%fdsjkl|gdag-63431|(34\,21 USD)|czjfkljsdklfjk`
)

func main() {
    re := regexp.MustCompile(`\(\d+\\,{0,1}\d{1,2}\ {0,1}\w{2,3}\)`)
    s1 := re.Find([]byte(s))
    s2 := strings.Replace(string(s1), `\,`, `,`, 1)
    s3 := strings.Replace(s, string(s1), s2, 1)
    fmt.Println(s3)
}

更高效的实现方式 #

原代码需要三次操作（匹配子串、替换子串、替换回原字符串），还涉及多次字符串类型转换，存在不必要的开销。下面两种方案可以优化效率：

方式一：正则捕获组替换（一次完成） #

利用正则的捕获组，直接定位货币格式内的\,，一次替换完成所有操作，代码更简洁，效率更高，还能处理多个匹配项。

package main

import (
    "fmt"
    "regexp"
)

var (
    s = `fjsdkjfd$$klsgf|fj15%fdsjkl|gdag-63431|(34\,21 USD)|czjfkljsdklfjk`
)

func main() {
    // 用捕获组保留反斜杠逗号前后的内容，替换时直接拼接为普通逗号
    re := regexp.MustCompile(`(\(\d+)\\,(\d{1,2}\s?\w{2,3}\))`)
    result := re.ReplaceAllString(s, "$1,$2")
    fmt.Println(result)
}

说明：

• 正则中的$1对应第一个捕获组（(\(\d+)，即(开头的数字部分），$2对应第二个捕获组（(\d{1,2}\s?\w{2,3}\))，即逗号后的数字+货币代码+)部分）
• 一次正则替换就完成了所有目标操作，无需额外的字符串替换和类型转换
• 支持处理字符串中多个符合格式的货币值，原代码只能处理第一个匹配项

方式二：手动遍历字符串（无正则开销） #

如果处理的字符串规模极大，正则的编译和匹配开销不可忽略，可以用手动遍历的方式，直接识别并替换目标内容，完全避免正则开销。

package main

import (
    "fmt"
)

var (
    s = `fjsdkjfd$$klsgf|fj15%fdsjkl|gdag-63431|(34\,21 USD)|czjfkljsdklfjk`
)

func main() {
    result := make([]rune, 0, len(s))
    strLen := len(s)

    for i := 0; i < strLen; i++ {
        current := rune(s[i])
        // 遇到反斜杠且下一个字符是逗号时，检查是否在货币格式内
        if current == '\\' && i+1 < strLen && rune(s[i+1]) == ',' {
            // 向前查找最近的(，确认是否进入货币格式块
            inCurrency := false
            openParenIdx := -1
            for j := i - 1; j >= 0; j-- {
                if s[j] == '(' {
                    openParenIdx = j
                    inCurrency = true
                    break
                }
                // 遇到常见分隔符，说明不在货币块内
                if s[j] == '|' || s[j] == '$' || s[j] == '%' {
                    break
                }
            }

            if inCurrency {
                // 向后查找对应的)，验证格式有效性
                for k := i + 2; k < strLen; k++ {
                    if s[k] == ')' {
                        // 简单验证中间内容是数字、空格、字母（货币代码）
                        valid := true
                        for m := openParenIdx + 1; m < k; m++ {
                            c := s[m]
                            if !(c >= '0' && c <= '9' || c == ' ' || c == ',' || c == '\\') {
                                if !(c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z') {
                                    valid = false
                                    break
                                }
                            }
                        }
                        if valid {
                            // 替换为普通逗号，跳过下一个字符（逗号）
                            result = append(result, ',')
                            i++
                            goto nextIter
                        }
                    }
                }
            }
            // 不是货币内的反斜杠，保留原字符
            result = append(result, current)
        } else {
            result = append(result, current)
        }
    nextIter:
    }

    fmt.Println(string(result))
}

说明：

• 直接遍历字符，仅处理货币格式内的\,，其他字符直接保留
• 完全避免正则的性能开销，适合超大规模字符串处理场景
• 实现相对复杂，需要额外做格式有效性验证，适合对性能要求极高的场景

方案选择 #

一般业务场景下，方式一的正则捕获组替换是最优解，兼顾代码简洁性和执行效率，能覆盖绝大多数需求；如果是超大规模字符串处理，且对性能有极致要求，再考虑方式二的手动遍历实现。

内容的提问来源于stack exchange，提问作者Tom