Ruby 中奇怪的反斜杠替换

Question

我不明白这段 Ruby 代码：

>> puts '\\ <- single backslash'
# \ <- single backslash

>> puts '\\ <- 2x a, because 2 backslashes get replaced'.sub(/\\/, 'aa')
# aa <- 2x a, because two backslashes get replaced

到目前为止，一切都按预期进行。但是如果我们用 /\\/ 搜索 1，并用 '\\\\' 编码的 2 替换，为什么我们会得到这个：

>> puts '\\ <- only 1 ... replace 1 with 2'.sub(/\\/, '\\\\')
# \ <- only 1 backslash, even though we replace 1 with 2

然后，当我们用 '\\\\\\' 编码 3，我们只得到 2：

>> puts '\\ <- only 2 ... 1 with 3'.sub(/\\/, '\\\\\\')
# \\ <- 2 backslashes, even though we replace 1 with 3

任何人都能够理解为什么反斜杠会被吞入替换字符串中？这发生在 1.8 和 1.9 上。

Answer 1

快速回答

如果您想避免所有这些混乱，请使用更不易混淆的块语法。下面是一个用 2 个反斜杠替换每个反斜杠的示例：

"some\\path".gsub('\\') { '\\\\' }

---

可怕的细节

问题在于，当使用 sub （和 gsub）时，没有块，ruby 会解释 special替换参数中的字符序列。不幸的是，sub 使用反斜杠作为这些字符的转义字符：

\& (the entire regex)
\+ (the last group)
\` (pre-match string)
\' (post-match string)
\0 (same as \&)
\1 (first captured group)
\2 (second captured group)
\\ (a backslash)

与任何转义一样，这会产生一个明显的问题。如果您想在输出字符串中包含上述序列之一的文字值（例如 \1），则必须对其进行转义。因此，要获得 Hello \1，您需要将替换字符串设置为 Hello \\1。要将其表示为 Ruby 中的字符串文字，您必须再次转义这些反斜杠，如下所示： "Hello \\\\1"

因此，有两种不同的转义通道。第一个获取字符串文字并创建内部字符串值。第二个获取该内部字符串值并用匹配数据替换上面的序列。

如果反斜杠后面没有与上述序列之一匹配的字符，则反斜杠（以及后面的字符）将不改变地通过。这也会影响字符串末尾的反斜杠——它将不加改变地通过。在 rubinius 代码中最容易看到这个逻辑；只需在 中查找 to_sub_replacement 方法字符串类。

以下是 一些示例，说明 String#sub 如何解析替换字符串：

• 1 反斜杠 \ (其字符串文字为 "\\")

  原样通过，因为反斜杠位于字符串末尾并且后面没有任何字符。

  结果： \

• 2 个反斜杠 \\ （字符串文字为 "\ \\\")

  这对反斜杠与转义的反斜杠序列匹配（请参阅上面的 \\），并转换为单个反斜杠。

  结果： \

• 3 个反斜杠 \\\ （字符串文字为 " \\\\\\")

  前两个反斜杠与 \\ 序列匹配，并转换为单个反斜杠。然后最后一个反斜杠位于字符串的末尾，因此它不会改变。

  结果： \\

• 4 个反斜杠 \\\\ （字符串文字为 “\\\\\\\\”)

  两对反斜杠分别匹配 \\ 序列并转换为单个反斜杠。

  结果： \\

• 2 个反斜杠，中间有字符 \a\ （其中有一个字符串"\\a\\" 的文字)

  \a 与任何转义序列都不匹配，因此允许它不改变地通过。尾随反斜杠也允许通过。

  结果： \a\

  注意：可以从以下位置获得相同的结果：\\a\\（使用文字字符串："\\\\a\\\ \")

事后看来，如果 String#sub 使用不同的转义字符，这可能不会那么混乱。这样就不需要双重转义所有反斜杠了。

Answer 2

这是一个问题，因为反斜杠 (\) 充当正则表达式和字符串的转义字符。您可以使用特殊变量 \&减少 gsub 替换字符串中反斜杠的数量。

foo.gsub(/\\/,'\&\&\&') #for some string foo replace each \ with \\\

编辑：我应该提到 \& 的价值来自正则表达式匹配，在本例中是单个反斜杠。

另外，我认为有一种特殊的方法来创建一个禁用转义字符的字符串，但显然不是。这些都不会产生两个斜杠：

puts "\\"
puts '\\'
puts %q{\\}
puts %Q{\\}
puts """\\"""
puts '''\\'''
puts <<EOF
\\
EOF  

Answer 3

啊，在我输入所有这些内容后，我意识到 \ 用于引用替换字符串中的组。我想这意味着您需要在替换字符串中使用文字 \\ 来替换 \。要获得文字 \\，您需要四个 \，因此要将 1 替换为 2，您实际上需要 8 个（！）。

# Double every occurrence of \. There's eight backslashes on the right there!
>> puts '\\'.sub(/\\/, '\\\\\\\\')

我缺少什么吗？还有什么更有效的方法吗？

Answer 4

澄清作者第二行代码中的一些混乱。

你说：

>> puts '\\ <- 2x a, because 2 backslashes get replaced'.sub(/\\/, 'aa')
# aa <- 2x a, because two backslashes get replaced

2 个反斜杠在这里没有被替换。您要将 1 个转义 反斜杠替换为两个 a ('aa')。也就是说，如果您使用 .sub(/\\/, 'a')，您只会看到一个 'a'

'\\'.sub(/\\/, 'anything') #=> anything

Answer 5

实际上，镐书提到了这个确切的问题。这是另一种选择（来自最新版本的第 130 页）

str = 'a\b\c'               # => "a\b\c"
str.gsub(/\\/) { '\\\\' }   # => "a\\b\\c"