如何为自制Python编程语言实现类主流语言的字符串系统？

核心设计目标 #

覆盖主流编程语言的字符串特性：

• 支持单引号、双引号包裹的单行字符串
• 支持三引号（单/双）包裹的多行字符串
• 支持转义字符（\n、\t、\"、\'、\\等）
• 支持原始字符串（禁用转义，如Python的r""、C++的R"()"）
• 提供字符串读取器，支持逐字符读取、预读、截取等操作

实现代码 #

import re

class StringParser:
    # 匹配各类字符串字面量的正则规则
    STRING_PATTERNS = [
        # 原始单行字符串: r'...' 或 r"..."
        (r'r([\'"])(.*?)\1', lambda m: m.group(2)),
        # 原始多行字符串: r'''...''' 或 r"""..."""
        (r"r('''|\"\"\")(.*?)\1", lambda m: m.group(2), re.DOTALL),
        # 多行字符串: '''...''' 或 """"..."""
        (r"('''|\"\"\")(.*?)\1", lambda m: _unescape_string(m.group(2)), re.DOTALL),
        # 单行字符串: '...' 或 "..."
        (r"([\'"])(.*?)\1", lambda m: _unescape_string(m.group(2)))
    ]

    @staticmethod
    def parse(raw_str):
        """解析输入的字符串字面量，返回处理后的实际字符串"""
        for pattern, handler, *flags in StringParser.STRING_PATTERNS:
            regex_flags = flags[0] if flags else 0
            match = re.fullmatch(pattern, raw_str.strip(), regex_flags)
            if match:
                return handler(match)
        raise ValueError("Invalid string literal format")

def _unescape_string(s):
    """处理字符串中的转义字符"""
    escape_map = {
        'n': '\n',
        't': '\t',
        'r': '\r',
        'b': '\b',
        'f': '\f',
        '"': '"',
        "'": "'",
        '\\': '\\'
    }
    result = []
    i = 0
    while i < len(s):
        if s[i] == '\\' and i + 1 < len(s):
            char = s[i+1]
            result.append(escape_map.get(char, char))
            i += 2
        else:
            result.append(s[i])
            i += 1
    return ''.join(result)

class StringReader:
    def __init__(self, content):
        """初始化字符串读取器，传入解析后的字符串内容"""
        self.content = content
        self.pos = 0

    def read_char(self):
        """读取当前位置字符并后移指针，无字符时返回None"""
        if self.pos >= len(self.content):
            return None
        char = self.content[self.pos]
        self.pos += 1
        return char

    def peek(self):
        """预读当前位置字符，不移动指针，无字符时返回None"""
        if self.pos >= len(self.content):
            return None
        return self.content[self.pos]

    def read_until(self, delimiter):
        """读取到指定分隔符为止，返回分隔符前内容，指针停在分隔符位置"""
        result = []
        while self.pos < len(self.content):
            char = self.content[self.pos]
            if char == delimiter:
                break
            result.append(char)
            self.pos += 1
        return ''.join(result)

    def reset(self):
        """重置读取指针到起始位置"""
        self.pos = 0

    def remaining(self):
        """返回剩余未读取的字符串"""
        return self.content[self.pos:]

示例用法 #

# 1. 解析不同类型的字符串字面量
single_quote = StringParser.parse("'Hello\\'s World!'")
double_quote = StringParser.parse('"Line1\\nLine2"')
multi_line = StringParser.parse('''"""Multi
Line
String"""''')
raw_str = StringParser.parse(r'r"Raw string with \\n and \t"')

print(single_quote)   # 输出: Hello's World!
print(double_quote)   # 输出: Line1
                      #       Line2
print(multi_line)     # 输出: Multi
                      #       Line
                      #       String
print(raw_str)        # 输出: Raw string with \\n and \t

# 2. 使用字符串读取器
reader = StringReader(double_quote)
print(reader.read_char())  # 输出: L
print(reader.peek())       # 输出: i
print(reader.read_until('\n'))  # 输出: Line1
print(reader.remaining())       # 输出: Line2

扩展说明 #

• 可通过修改STRING_PATTERNS添加更多语言的字符串格式支持（比如C++的R"(...)"）
• StringReader可按需扩展方法（如read_line()、skip_whitespace()）
• 若需支持字符串插值（如Python的f-string、JS的${}），可在parse方法中添加对应处理逻辑

内容的提问来源于stack exchange，提问作者Withered W.D.