正则表达式以及转义和未转义分隔符

Question

与this相关的问题

我有一个字符串

a\;b\\;c;d

，在Java中看起来

String s = "a\\;b\\\\;c;d"

我需要按照以下规则用分号分隔它：

1. 如果分号前面有反斜杠，不应将其视为分隔符（a 和 b 之间）。

2. 如果反斜杠本身被转义，因此不会转义自己的分号，则该分号应该是分隔符（在 b 和 c 之间）。

因此，如果分号前面有零个或偶数个反斜杠，则应将其视为分隔符。

例如上面的例子，我想得到以下字符串（java编译器的双反斜杠）：

a\;b\\
c
d

Answer 1

您可以使用正则表达式

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

来匹配未转义分号之间的所有文本：

List<String> matchList = new ArrayList<String>();
try {
    Pattern regex = Pattern.compile("(?:\\\\.|[^;\\\\]++)*");
    Matcher regexMatcher = regex.matcher(subjectString);
    while (regexMatcher.find()) {
        matchList.add(regexMatcher.group());
    } 

说明：

(?:        # Match either...
 \\.       # any escaped character
|          # or...
 [^;\\]++  # any character(s) except semicolon or backslash; possessive match
)*         # Repeat any number of times.

所有格匹配 (++) 对于避免由于嵌套量词而导致灾难性回溯非常重要。

Answer 2

我不相信用任何类型的正则表达式来检测这些情况。我通常会为此类事情做一个简单的循环，我将使用 C 绘制它的草图，因为我上次接触 Java 已经是很久以前的事情了；-)

int i, len, state;
char c;

for (len=myString.size(), state=0, i=0; i < len; i++) {
    c=myString[i];
    if (state == 0) {
       if (c == '\\') {
            state++;
       } else if (c == ';') {
           printf("; at offset %d", i);
       }
    } else {
        state--;
    }
}

优点 are：

1. 您可以在每个步骤上执行语义操作。
2. 将其移植到另一种语言非常容易。
3. 您不需要仅仅为了这个简单的任务就包含完整的正则表达式库，这增加了可移植性。
4. 它应该比正则表达式匹配器快很多。

编辑：
我添加了一个完整的 C++ 示例来进行说明。

#include <iostream>                                                             
#include <sstream>                                                              
#include <string>                                                               
#include <vector>                                                               
                                                                                
std::vector<std::string> unescapeString(const char* s)                        
{                                                                               
    std::vector<std::string> result;                                            
    std::stringstream ss;                                                       
    bool has_chars;                                                             
    int state;                                                                  
                                                                                
    for (has_chars = false, state = 0;;) {                                      
        auto c = *s++;                                                          
                                                                                
        if (state == 0) {                                                       
            if (!c) {                                                           
                if (has_chars) result.push_back(ss.str());                      
                break;                                                          
            } else if (c == '\\') {                                             
                ++state;                                                        
            } else if (c == ';') {                                              
                if (has_chars) {                                                
                    result.push_back(ss.str());                                 
                    has_chars = false;                                          
                    ss.str("");                                                 
                }                                                               
            } else {                                                            
                ss << c;                                                        
                has_chars = true;                                               
            }                                                                   
        } else /* if (state == 1) */ {                                          
            if (!c) {                                                           
                ss << '\\';                                                     
                result.push_back(ss.str());                                     
                break;                                                          
            }                                                                   
                                                                                
            ss << c;                                                            
            has_chars = true;                                                   
            --state;                                                            
        }                                                                       
    }                                                                           
                                                                                
    return result;                                                              
}                                                                               
                                                                                
int main(int argc, char* argv[])                                                
{                                                                               
    for (size_t i = 1; i < argc; ++i) {                                         
        for (const auto& s: unescapeString(argv[i])) {                          
            std::cout << s << std::endl;                                        
        }                                                                       
    }                                                                           
}                                                     

Answer 3

String[] splitArray = subjectString.split("(?<!(?<!\\\\)\\\\);");

这应该有效。

解释：

// (?<!(?<!\\)\\);
// 
// Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!(?<!\\)\\)»
//    Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!\\)»
//       Match the character “\” literally «\\»
//    Match the character “\” literally «\\»
// Match the character “;” literally «;»

因此，您只需匹配分号，而分号前面不正好有一个\。

编辑：

String[] splitArray = subjectString.split("(?<!(?<!\\\\(\\\\\\\\){0,2000000})\\\\);");

这将处理任何奇数个 .如果 \ 数量超过 4000000 个，当然会失败。编辑答案的解释：

// (?<!(?<!\\(\\\\){0,2000000})\\);
// 
// Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!(?<!\\(\\\\){0,2000000})\\)»
//    Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!\\(\\\\){0,2000000})»
//       Match the character “\” literally «\\»
//       Match the regular expression below and capture its match into backreference number 1 «(\\\\){0,2000000}»
//          Between zero and 2000000 times, as many times as possible, giving back as needed (greedy) «{0,2000000}»
//          Note: You repeated the capturing group itself.  The group will capture only the last iteration.  Put a capturing group around the repeated group to capture all iterations. «{0,2000000}»
//          Match the character “\” literally «\\»
//          Match the character “\” literally «\\»
//    Match the character “\” literally «\\»
// Match the character “;” literally «;»

Answer 4

此方法假设您的字符串中不包含 char '\0'。如果这样做，您可以使用其他字符。

public static String[] split(String s) {
    String[] result = s.replaceAll("([^\\\\])\\\\;", "$1\0").split(";");
    for (int i = 0; i < result.length; i++) {
        result[i] = result[i].replaceAll("\0", "\\\\;");
    }
    return result;
}

Answer 5

这是我认为的真实答案。
就我而言，我尝试使用 | 进行拆分，转义字符是 &。

    final String regx = "(?<!((?:[^&]|^)(&&){0,10000}&))\\|";
    String[] res = "&|aa|aa|&|&&&|&&|s||||e|".split(regx);
    System.out.println(Arrays.toString(res));

在此代码中，我使用 Lookbehind 来转义 &特点。
请注意，后面的外观必须具有最大长度。

(?<!((?:[^&]|^)(&&){0,10000}&))\\|

这意味着除了 ((?:[^&]|^)(&&){0,10000}&)) 之后的任何 |这部分表示任意奇数个&。
(?:[^&]|^) 部分对于确保计算 |& 非常重要code> 开头或一些其他字符。