处理带嵌套引号的大文本时，最忌讳用那种会触发大量回溯的正则——分分钟让你的程序卡住。我之前处理GB级日志的时候踩过这个坑，后来总结出两种高效的方案，分享给你：

一、线性扫描法（最优选择，O(n)时间复杂度） #

这是性能天花板级别的方案，逐字符遍历，全程没有回溯，逻辑也清晰，适合任何规模的文本。

核心思路： #

我们只需要跟踪两个状态：当前是否处于引号内，以及当前外层的引号类型（单/双）。遇到匹配的外层引号时，就把中间的内容摘出来。

代码实现（Python）： #

def extract_outer_quotes(text):
    results = []
    in_quote = False
    current_quote = None
    start_idx = -1
    escape_char = '\\'  # 处理转义引号，比如 \" 或者 \'

    for idx, char in enumerate(text):
        if not in_quote:
            # 遇到外层引号，开始记录
            if char in ('"', "'"):
                in_quote = True
                current_quote = char
                start_idx = idx + 1  # 跳过引号本身，从下一个字符开始记录内容
        else:
            # 遇到和外层相同的引号，检查是否是转义的
            if char == current_quote:
                if idx > 0 and text[idx-1] == escape_char:
                    continue  # 转义引号，不算闭合
                # 闭合外层引号，提取内容
                results.append(text[start_idx:idx])
                in_quote = False
                current_quote = None
                start_idx = -1
    return results

# 测试你的示例输入
input_text = 'The "\'quick\', \'brown fox\'", \'jumps over the "lazy dog"\''
print(extract_outer_quotes(input_text))
# 输出：["'quick', 'brown fox'", 'jumps over the "lazy dog"']

这个方法的优势太明显了：不管文本多大，都是一遍遍历搞定，没有任何额外开销，还能轻松处理转义引号的情况，调试和扩展也方便。

二、优化后的正则表达式（适合简单场景） #

如果你实在想用正则，一定要写无回溯的正则，别用那种"(.*?)"的非贪婪匹配——那玩意儿遇到嵌套分分钟炸锅。

正则思路： #

用明确的字符集匹配规则，避免正则引擎回溯。比如针对单双引号分别写匹配逻辑，确保每一步都没有回溯点。

代码实现（Python）： #

import re

def extract_outer_quotes_regex(text):
    # 匹配单引号外层：'([^'\\]*(?:\\.[^'\\]*)*)'
    # 匹配双引号外层："([^"\\]*(?:\\.[^"\\]*)*)"
    # 这个正则没有回溯点，效率很高
    pattern = re.compile(r"'([^'\\]*(?:\\.[^'\\]*)*)'|\"([^\"\\]*(?:\\.[^\"\\]*)*)\"")
    results = []
    for match in pattern.finditer(text):
        # 取第一个非空的分组（单引号或双引号的内容）
        content = match.group(1) or match.group(2)
        results.append(content)
    return results

# 测试示例
input_text = 'The "\'quick\', \'brown fox\'", \'jumps over the "lazy dog"\''
print(extract_outer_quotes_regex(input_text))
# 输出：["'quick', 'brown fox'", 'jumps over the "lazy dog"']

注意事项： #

这个正则虽然高效，但如果文本里有极深的嵌套或者海量转义字符，还是不如线性扫描稳定。毕竟正则引擎的底层还是有一些额外开销，而线性扫描是纯手动控制，逻辑更透明。

为什么别用普通嵌套正则？ #

比如"(.*?)"或者平衡组正则，遇到大量嵌套时，正则引擎会不断回溯尝试匹配，时间复杂度直接退化到O(n²)甚至更高，大文本下直接卡死。上面两种方法都从根源上避免了这个问题。

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