.NET RegEx-前M行的前N个字符

Question

对于以下4种基本情况，我需要4个常规RegEx表达式：

1. 从文件开头的行开始至B个字符之后，最多A个字符开始，从文件的开始至D行之后，最多C个行开始
2. 从文件开头的行开始在B个字符之后最多A个字符，在文件末尾的D行之前最多出现C行
3. 从文件末尾开始，最多A字符从行末B字符开始，直到C行开始
4. 从文件末尾开始，最多A字符从行末B字符开始，直到C行从文件末尾开始D行之前

这些将允许选择文件中任意位置的任意文本块。

到目前为止，我已经设法提出仅适用于行和字符的情况：

• (?<=(?m:^[^\\r]{N}))[^\\r]{1,M} =最多N个字符，每行最多M个字符
• [^\\r]{1,M}(?=(?m:.{N}\\r$)) =每行最多M个字符，最后N个字符之前

上面的2个表达式用于char，它们返回许多匹配项（每行一个）。

• (?<=(\\A([^\\r]*\\r\\n){N}))(?m:\\n*[^\\r]*\\r$){1,M} =最多M先行后N行
• (((?=\\r?)\\n[^\\r]*\\r)|((?=\\r?)\\n[^\\r]+\\r?)){1,M}(?=((\\n[^\\r]*\\r)|(\\n[^\\r]+\\r?)){N}\\Z) =从末尾起最后N行之前最多M行

这2个表达式与这些行等效，但是它们始终仅返回一个匹配项。

任务是组合这些表达式以允许方案1-4。 有人可以帮忙吗？

请注意，问题标题中的情况只是方案＃1的子类，其中B = 0和D = 0。

示例1：第3-5行的字符3-6。 总共3场比赛。

资源：

line1 blah 1
line2 blah 2
line3 blah 3
line4 blah 4
line5 blah 5
line6 blah 6

结果：

<match>ne3 </match>
<match>ne4 </match>
<match>ne5 </match>

示例2：2行的最后4个字符在最后1行之前。 总共2场比赛。

资源：

line1 blah 1
line2 blah 2
line3 blah 3
line4 blah 4
line5 blah 5
line6 blah 6

结果：

<match>ah 4</match>
<match>ah 5</match>

Answer 1

这是基本情况2的一个正则表达式：

Regex regexObj = new Regex(
    @"(?<=              # Assert that the following can be matched before the current position
     ^                # Start of line
     .{2}             # 2 characters (B = 2)
    )                 # End of lookbehind assertion
    .{1,3}            # Match 1-3 characters (A = 3)
    (?=               # Assert that the following can be matched after the current position
     .*$              # rest of the current line
     (?:\r\n.*){2,4}  # 2 to 4 entire lines (D = 2, C = 4+1-2)
     \z               # end of the string
    )", 
    RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace);

在文字中

line1 blah 1
line2 blah 2
line3 blah 3
line4 blah 4
line5 blah 5
line6 blah 6

它会匹配

ne2
ne3
ne4

（ ne2从倒数第五行（C + D = 5）的第三个字符（B = 2）开始，等等。）

Answer 2

编辑 ：根据您的评论，听起来这确实是您无法控制的。 我发布此答案的原因是，我经常感到（尤其是在使用正则表达式时），开发人员容易陷入技术难题，而看不到实际目标： 解决问题 。 我知道我也是这样。 我认为这只是技术和创造性思维的不幸结果。

因此，如果可能的话，我想让您重新关注当前的问题，并强调指出，在拥有充足的工具集的情况下，Regex不是适合此工作的合适工具。 如果它是您无法控制的唯一工具，那么您别无选择。

我认为您可能有理由要求Regex解决方案。 但是由于这些原因还没有完全解释，因此我觉得您仍然很固执；）

---

您说这需要在Regex中完成，但我不相信！

首先，我仅限于.NET 2.0 [。 。 。 ]

没问题。 谁说您需要 LINQ这样的问题？ LINQ只是使事情变得容易 ; 这不会使不可能的事情变为可能。

例如，这是您可以从问题中实现第一种情况的一种方式（将其重构为更灵活的方式也很简单，也可以涵盖情况2–3）：

public IEnumerable<string> ScanText(TextReader reader,
                                    int start,
                                    int count,
                                    int lineStart,
                                    int lineCount)
{
    int i = 0;
    while (i < lineStart && reader.Peek() != -1)
    {
        reader.ReadLine();
        ++i;
    }

    i = 0;
    while (i < lineCount && reader.Peek() != -1)
    {
        string line = reader.ReadLine();

        if (line.Length < start)
        {
            yield return ""; // or null? or continue?
        }
        else
        {
            int length = Math.Min(count, line.Length - start);
            yield return line.Substring(start, length);
        }

        ++i;
    }
}

因此，有一个.NET 2.0友好型解决方案可以解决一般问题，而无需使用正则表达式（或LINQ）。

其次，我需要RegEx的灵活性，以允许在这些[。]上构建更复杂的表达式。 。 。 ]

也许我只是在密密麻麻。 是什么阻止您从非Regex入手，然后再使用Regex进行更“复杂”的操作？ 例如，如果您需要在上述ScanText 返回的行上进行其他处理，则可以使用Regex进行处理。 但是从一开始就坚持使用Regex似乎……我不知道，只是没有必要。

不幸的是，由于项目的性质，必须在RegEx [。 。 。 ]

如果确实如此，那很好。 但是，如果你的理由仅仅是那些从上面摘录的话，我不同意，这个问题的某一方面 （扫描从文本中的某些行某些字符）需要使用正则表达式来解决，即使正则表达式将需要的其他方面问题不在此问题的范围内。

另一方面，如果由于某些任意原因而被迫使用Regex（例如，某人选择编写某些需求/规范，可能没有考虑太多，那么正则表达式将用于此任务）好吧，我个人建议与它作斗争。 向有能力改变此要求的人解释，即Regex不必要，并且无需使用Regex ...或结合使用“正常”代码和Regex即可轻松解决该问题。

我能想到的唯一其他可能性（尽管这可能是我自己缺乏想象力的结果），这可能会解释您需要对问题中描述的问题使用Regex ，这是因为您只能使用特定的该工具专门接受正则表达式作为用户输入。 但是你的问题是标签.net ，所以我必须承担有一定程度你可以写在解决这个问题中使用自己的代码。 如果是这种情况，那么我会再说一遍：我认为您不需要Regex;）

Answer 3

首先，这是“基本案例1”的答案：

Regex regexObj = new Regex(
    @"(?<=            # Assert that the following can be matched before the current position
     \A               # Start of string
     (?:.*\r\n){2,4}  # 2 to 4 entire lines (D = 2, C = 4+1-2)
     .{2}             # 2 characters (B = 2)
    )                 # End of lookbehind assertion
    .{1,3}            # Match 1-3 characters (A = 3)", 
    RegexOptions.IgnorePatternWhitespace);

您现在可以使用来遍历比赛

Match matchResults = regexObj.Match(subjectString);
while (matchResults.Success) {
    // matched text: matchResults.Value
    // match start: matchResults.Index
    // match length: matchResults.Length
    matchResults = matchResults.NextMatch();
}

所以，在文字中

line1 blah 1
line2 blah 2
line3 blah 3
line4 blah 4
line5 blah 5
line6 blah 6

它会匹配

ne3
ne4
ne5

Answer 4

这是一种基本情况3：

Regex regexObj = new Regex(
    @"(?<=            # Assert that the following can be matched before the current position
     \A               # Start of string
     (?:.*\r\n){2,4}  # 2 to 4 entire lines (D = 2, C = 4+1-2)
     .*               # any number of characters
    )                 # End of lookbehind assertion
    (?=               # Assert that the following can be matched after the current position
     .{8}             # 8 characters (B = 8)
     $                # end of line
    )                 # End of lookahead assertion
    .{1,3}            # Match 1-3 characters (A = 3)", 
    RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace);

所以在文字中

line1 blah 1
line2 blah 2
line3 blah 3
line4 blah 4
line5 blah 5
line6 blah 6

它会匹配

3 b
4 b
5 b

（ 3 b因为它是3个字符（A = 3），从第8个字符到最后一个字符（B = 8），从第三行开始（D = 2），依此类推。）

Answer 5

最后是基本情况4的一种解决方案：

Regex regexObj = new Regex(
    @"(?=             # Assert that the following can be matched after the current position
     .{8}             # 8 characters (B = 8)
     (?:\r\n.*){2,4}  # 2 to 4 entire lines (D = 2, C = 4+1-2)
     \z               # end of the string
    )                 # End of lookahead assertion
    .{1,3}            # Match three characters (A = 3)", 
    RegexOptions.IgnorePatternWhitespace);

在文字中

line1 blah 1
line2 blah 2
line3 blah 3
line4 blah 4
line5 blah 5
line6 blah 6

这将匹配

2 b
3 b
4 b

（ 2 b是因为它是三个字符（A = 3），从倒数第二行（C + D = 5）的倒数第8个字符（B = 8）开始，等等。）

Answer 6

你为什么不做这样的事情：

//Assuming you have it read into a string name sourceString
String[] SplitString = sourceString.Split(Environment.Newline); //You will probably need to account for any line delimeter
String[M] NewStrings;
for(i=0;i<M;i++) {
    NewStrings[i] = SplitString[i].SubString(0,N) //Or (N, SplitString[i].Length -1) depending on what you need
}

您不需要RegEx，也不需要LINQ。

好吧，我重新阅读了问题的开头，您可以简单地将for循环的起点和终点以及Split进行参数设置，以获取所需的确切信息。

Answer 7

请问两点：

• 我提出的解决方案并不完全基于正则表达式。 我知道，我读到您需要纯正则表达式解决方案。 但是我遇到了一个有趣的问题，然后我迅速得出结论，正则表达式在此问题上的使用过于复杂。 我无法用纯正则表达式解决方案来回答。 我找到了以下内容，并显示给他们； 也许，他们可以给您想法。

• 我不知道C＃或.NET，只有Python。 由于正则表达式在所有语言中几乎都是相同的，所以我认为我只想回答正则表达式，这就是为什么我开始研究这个问题的原因。 现在，我以相同的方式展示我在Python中的解决方案，因为我认为无论如何它还是很容易理解的。

我认为通过唯一的正则表达式来捕获文本中想要的所有字母出现是非常困难的，因为在多行中找到多个字母对我来说似乎是在匹配中找到嵌套匹配的问题（也许我不够熟练）在正则表达式中）。

因此，我认为最好首先搜索所有行中所有出现的字母并将其放入列表中，然后再通过在列表中切片来选择出现的字母。

对于一行中的字母搜索，正则表达式首先对我来说不错。 因此，具有功能selectRE（）的解决方案。

事后，我意识到选择一行中的字母与在方便的索引处对一行进行切片相同，也与对列表进行切片相同。 因此，函数select（）。

我同时给出了两个解决方案，因此可以验证两个函数的两个结果是否相等。

import re

def selectRE(a,which_chars,b,x,which_lines,y,ch):
    ch = ch[:-1] if ch[1]=='\n' else ch # to obtain an exact number of lines
    NL = ch.count('\n') +1 # number of lines

    def pat(a,which_chars,b):
        if which_chars=='to':
            print repr(('.{'+str(a-1)+'}' if a else '') + '(.{'+str(b-a+1)+'}).*(?:\n|$)')
            return re.compile(('.{'+str(a-1)+'}' if a else '') + '(.{'+str(b-a+1)+'}).*(?:\n|$)')
        elif which_chars=='before':
            print repr('.*(.{'+str(a)+'})'+('.{'+str(b)+'}' if b else '')+'(?:\n|$)')
            return re.compile('.*(.{'+str(a)+'})'+('.{'+str(b)+'}' if b else '')+'(?:\n|$)')
        elif which_chars=='after':
            print repr(('.{'+str(b)+'}' if b else '')+'(.{'+str(a)+'}).*(?:\n|$)')
            return re.compile(('.{'+str(b)+'}' if b else '')+'(.{'+str(a)+'}).*(?:\n|$)')

    if   which_lines=='to'    :  x   = x-1
    elif which_lines=='before':  x,y = NL-x-y,NL-y
    elif which_lines=='after' :  x,y = y,y+x

    return pat(a,which_chars,b).findall(ch)[x:y]


def select(a,which_chars,b,x,which_lines,y,ch):
    ch = ch[:-1] if ch[1]=='\n' else ch # to obtain an exact number of lines
    NL = ch.count('\n') +1 # number of lines

    if   which_chars=='to'    :  a   = a-1
    elif which_chars=='after' :  a,b = b,a+b

    if   which_lines=='to'    :  x   = x-1
    elif which_lines=='before':  x,y = NL-x-y,NL-y
    elif which_lines=='after' :  x,y = y,y+x

    return [ line[len(line)-a-b:len(line)-b] if which_chars=='before' else line[a:b]
             for i,line in enumerate(ch.splitlines()) if x<=i<y ]


ch = '''line1 blah 1
line2 blah 2
line3 blah 3
line4 blah 4
line5 blah 5
line6 blah 6
'''
print ch,'\n'

print 'Characters 3-6 of lines 3-5. A total of 3 matches.'
print selectRE(3,'to',6,3,'to',5,ch)
print   select(3,'to',6,3,'to',5,ch)
print
print 'Characters 1-5 of lines 4-5. A total of 2 matches.'
print selectRE(1,'to',5,4,'to',5,ch)
print   select(1,'to',5,4,'to',5,ch)
print
print '7 characters before the last 3 chars of lines 2-6. A total of 5 matches.'
print selectRE(7,'before',3,2,'to',6,ch)
print   select(7,'before',3,2,'to',6,ch)
print
print '6 characters before the 2 last characters of 3 lines before the 3 last lines.'
print selectRE(6,'before',2,3,'before',3,ch)
print   select(6,'before',2,3,'before',3,ch)
print 
print '4 last characters of 2 lines before 1 last line. A total of 2 matches.'
print selectRE(4,'before',0,2,'before',1,ch)
print   select(4,'before',0,2,'before',1,ch)
print
print 'last 1 character of 4 last lines. A total of 2 matches.'
print selectRE(1,'before',0,4,'before',0,ch)
print   select(1,'before',0,4,'before',0,ch)
print
print '7 characters before the last 3 chars of 3 lines after the 2 first lines. A total of 5 matches.'
print selectRE(7,'before',3,3,'after',2,ch)
print   select(7,'before',3,3,'after',2,ch)
print
print '5 characters before the 3 last chars of the 5 first lines'
print selectRE(5,'before',3,5,'after',0,ch)
print   select(5,'before',3,5,'after',0,ch)
print
print 'Characters 3-6 of the 4 first lines'
print selectRE(3,'to',6,4,'after',0,ch)
print   select(3,'to',6,4,'after',0,ch)
print
print '9 characters after the 2 first chars of the 3 lines after the 1 first line'
print selectRE(9,'after',2,3,'after',1,ch)
print   select(9,'after',2,3,'after',1,ch)

结果

line1 blah 1
line2 blah 2
line3 blah 3
line4 blah 4
line5 blah 5
line6 blah 6


Characters 3-6 of lines 3-5. A total of 3 matches.
'.{2}(.{4}).*(?:\n|$)'
['ne3 ', 'ne4 ', 'ne5 ']
['ne3 ', 'ne4 ', 'ne5 ']

Characters 1-5 of lines 4-5. A total of 2 matches.
'.{0}(.{5}).*(?:\n|$)'
['line4', 'line5']
['line4', 'line5']

7 characters before the last 3 chars of lines 2-6. A total of 5 matches.
'.*(.{7}).{3}(?:\n|$)'
['ne2 bla', 'ne3 bla', 'ne4 bla', 'ne5 bla', 'ne6 bla']
['ne2 bla', 'ne3 bla', 'ne4 bla', 'ne5 bla', 'ne6 bla']

6 characters before the 2 last characters of 3 lines before the 3 last lines.
'.*(.{6}).{2}(?:\n|$)'
['2 blah', '3 blah', '4 blah']
['2 blah', '3 blah', '4 blah']

4 last characters of 2 lines before 1 last line. A total of 2 matches.
'.*(.{4})(?:\n|$)'
['ah 5', 'ah 6']
['ah 5', 'ah 6']

last 1 character of 4 last lines. A total of 2 matches.
'.*(.{1})(?:\n|$)'
['4', '5', '6']
['4', '5', '6']

7 characters before the last 3 chars of 3 lines after the 2 first lines. A total of 5 matches.
'.*(.{7}).{3}(?:\n|$)'
['ne3 bla', 'ne4 bla', 'ne5 bla']
['ne3 bla', 'ne4 bla', 'ne5 bla']

5 characters before the 3 last chars of the 5 first lines
'.*(.{5}).{3}(?:\n|$)'
['1 bla', '2 bla', '3 bla', '4 bla', '5 bla']
['1 bla', '2 bla', '3 bla', '4 bla', '5 bla']

Characters 3-6 of the 4 first lines
'.{2}(.{4}).*(?:\n|$)'
['ne1 ', 'ne2 ', 'ne3 ', 'ne4 ']
['ne1 ', 'ne2 ', 'ne3 ', 'ne4 ']

9 characters after the 2 first chars of the 3 lines after the 1 first line
'.{2}(.{9}).*(?:\n|$)'
['ne2 blah ', 'ne3 blah ', 'ne4 blah ']
['ne2 blah ', 'ne3 blah ', 'ne4 blah ']

现在，我将研究Tim Pietzcker的棘手解决方案