正则表达式 - 转义转义字符

Question

我的问题很复杂，但可以归结为一个简单的例子。

我正在编写一种自定义查询语言，用户可以在其中输入我解析为 LinQ 表达式的字符串。

我想做的是用* 字符分割字符串，除非它被正确转义。

Input         Output                          Query Description
"*\\*"    --> { "*", "\\", "*" }       -- contains a '\'
"*\\\**"  --> { "*", "\\\*", "*" }     -- contains '\*'
"*\**"    --> { "*", "\*", "*" }       -- contains '*' (works now)

我不介意 Regex.Split 返回空字符串，但我最终得到了这个：

Regex.Split(@"*\\*", @"(?<!\\)(\*)")  --> {"", "*", "\\*"}

如您所见，我尝试了消极的后视，它适用于我的所有情况，除了这个。我也试过Regex.Escape，但没有运气。

显然，我的问题是我正在寻找 \*，与 \\* 匹配。但在这种情况下， \\ 是另一个转义序列。

任何解决方案都不必涉及正则表达式。

Answer 1

我认为匹配比拆分容易得多，尤其是因为您没有从初始字符串中删除任何内容。那么要搭配什么呢？除了未转义的 * 之外的所有内容。

如何做到这一点？使用以下正则表达式：

@"(?:[^*\\]+|\\.)+|\*"

(?:[^*\\]+|\\.)+ 匹配不是* 或任何转义字符的所有内容。无需任何环顾。

\* 将匹配分隔符。

在代码中：

using System;
using System.Text.RegularExpressions;
using System.Linq;
public class Test
{
    public static void Main()
    {   
        string[] tests = new string[]{
            @"*\\*",
            @"*\\\**",
            @"*\**",
        };

        Regex re = new Regex(@"(?:[^*\\]+|\\.)+|\*");

        foreach (string s in tests) {
            var parts = re.Matches(s)
             .OfType<Match>()
             .Select(m => m.Value)
             .ToList();

            Console.WriteLine(string.Join(", ", parts.ToArray()));
        }
    }
}

输出：

*, \\, *
*, \\\*, *
*, \*, *

ideone demo

Answer 2

我想出了这个正则表达式(?<=(?:^|[^\\])(?:\\\\)*)(\*)。

说明：

您只需将* 之前可能发生的情况列入白名单，这些情况是：

• 字符串的开头^
• 不是\ - [^\\]
• （不是\ 或字符串的开头）然后是偶数个\ - (^|[^\\])(\\\\)*

测试代码及示例：

string[] tests = new string[]{
    @"*\\*",
    @"*\\\**",
    @"*\**",
    @"test\**test2",
};

Regex re = new Regex(@"(?<=(?:^|[^\\])(?:\\\\)*)(\*)");

foreach (string s in tests) {
    string[] m = re.Split( s );
    Console.WriteLine(String.Format("{0,-20} {1}", s, String.Join(", ",
       m.Where(x => !String.IsNullOrEmpty(x)))));
}

结果：

*\\*                 *, \\, *
*\\\**               *, \\\*, *
*\**                 *, \*, *
test\**test2         test\*, *, test2

Answer 3

我认为一个纯解析、非正则表达式的解决方案将是对这个问题的一个很好的补充。

我阅读这篇文章的速度明显快于我理解任何这些正则表达式的速度。这也使得修复意外的角落案例变得容易。逻辑直接布局。

public static String[] splitOnDelimiterWithEscape(String toSplit, char delimiter, char escape) {
    List<String> strings = new ArrayList<>();

    char[] chars = toSplit.toCharArray();
    String sub = "";

    for(int i = 0 ; i < chars.length ; i++) {
        if(chars[i] == escape) {
            sub += (i+1 < chars.length) ? chars[++i] : ""; //assign whatever char is after the escape to the string. This essentially makes single escape character non-existent. It just forces the next character to be literal. If the escape is at end, then we just ignore it

            //this is the simplest implementation of the escape. If escaping certain characters should have
            //special behaviour it should be implemented here.

            //You could even pass a Map mapping escape characters, to literal characters to make this even 
            //more general.

        } else if(chars[i] == delimiter) {
            strings.add(sub); //Found delimiter. So we split.
            sub = "";
        } else {
            sub += chars[i]; //nothing special. Just append to current string.
        }
    }

    strings.add(sub); //end of string is a boundary. Must include.

    return strings.toArray(new String[strings.size()]);
}

更新：我现在对这个问题有点困惑。正如我一直知道的那样，拆分不包括分隔符（但看起来像您的示例一样）。如果您希望分隔符存在于数组中，在它们自己的插槽中，那么对此的修改相当简单。 （我将把它作为练习留给读者作为代码可维护性的证据）