“紧密”重复键/值匹配

Question

具有“紧密”重复键/值对模式的字符串（对于本示例，键为“名称”，值应为单个小写单词）

string text = "name: abc name: def name: ghi name: jkl";

应该转化为输出

abc、def、ghi、jkl、

而模式中的任何干扰（可以说是“不紧密”），如

string text = "name: abc x name: def name: ghi name: jkl";

应该导致匹配失败，类似于

abc, ## 发生异常：x 无法与模式匹配 ##

我试过了

string text = "name: abc name: def name: ghi name: jkl";
string pattern = @"name:\s*([a-z])*\s*";

MatchCollection ms = Regex.Matches(text, pattern);

foreach (Match m in ms)
{
    Console.Write(m.Groups[1].Value+", ");
}

但它会返回

c, f, i, l,

是什么导致了这种奇怪的行为，我该如何解决？

Answer 1

您只需将* 移动到括号内即可捕获完整的字符串。如果你想防止无效输入，那么正则表达式并不是绝对必要的。这假设您的值不能有空格，因为这将是一个更难解决的问题。

void Main()
{
    string validText = "name: abc name: def name: ghi name: jkl";
    string invalidText = "name: abc x name: def name: ghi name: jkl";
    string validPattern = @"name:\s*([a-z]*)\s*";

    if (!Validate(invalidText))
    {
        try
        {
            throw new Exception("invalid input");
        }
        catch (Exception exception)
        {
            Console.WriteLine($"Input '{invalidText}' produces: {exception.Message}");
        }
    }

    MatchCollection ms = Regex.Matches(validText, validPattern);

    Console.Write($"Input '{validText}' produces: ");
    foreach (Match m in ms)
    {
        Console.Write(m.Groups[1].Value + ", ");
    }
}

public static bool Validate(string input)
{
    var pairs = input.Split(' ');
    return !pairs.Where((item, index) => index % 2 != 0).Any(item => item.EndsWith(":"));
}

// Input 'name: abc x name: def name: ghi name: jkl' produces: invalid input
// Input 'name: abc name: def name: ghi name: jkl' produces: abc, def, ghi, jkl, 

https://regex101.com/r/qsQNr1/1

Answer 2

与大多数其他正则表达式风格不同，C# (.Net) 的引擎实际上通过 Group 类的 Captures 属性跟踪重复捕获。

Group.Captures 属性

获取与捕获组匹配的所有捕获的集合，按最内左最先的顺序（或如果使用RegexOptions.RightToLeft 选项修改正则表达式，则按最内最右最先的顺序）。

这意味着通过访问Groups[1]（如下面的代码所示）然后访问Captures 属性，我们实际上是在获取字符串上每个重复捕获的值。

---

代码

See code in use here

using System;
using System.Linq;
using System.Text.RegularExpressions;

class Example {

    static void Main() {
        string[] strings = new string[]{
            "name: abc name: def name: ghi name: jkl",
            "name: abc x name: def name: ghi name: jkl"
        };
        Regex regex = new Regex(@"^(?:name: *([a-z]+) *)+$");
        foreach(string s in strings) {
            if(regex.IsMatch(s)) {
                Match match = regex.Match(s);
                Console.WriteLine(string.Join(", ", from Capture c in match.Groups[1].Captures select c.Value));
            } else {
                Console.WriteLine("Invalid input");
            }
        }
    }
}

---

结果

name: abc name: def name: ghi name: jkl     # abc, def, ghi, jkl
name: abc x name: def name: ghi name: jkl   # Invalid input

Answer 3

你就不能用吗

var result = "name: abc name: def name: ghi name: jkl".Split(new [] { "name: " }, StringSplitOptions.None).Where(a=>!String.IsNullOrEmpty(a)).ToArray();

Answer 4

我终于也找到了获取“错误位置”的解决方案，即。重复匹配首先失败的位置。我希望任何有同样问题的人都能偶然发现这个错误的答案：

string s = "name: abc x name: def name: ghi name: jkl";
string pattern = @"\Gname:\s*([a-z]+)\s*";

int endOfLastMatch = 0;

// by using the \G anchor we can manage pattern repetition in a for-loop
for (Match m = Regex.Match(s, pattern); m.Success; m = m.NextMatch())
{
    Console.WriteLine(m.Groups[1].Value+ ", ");

    // keep track of until where matches were successful
    endOfLastMatch = m.Index + m.Length;
}

// in case that the match has failed, report where it has happened
if (endOfLastMatch != s.Length) 
{
    int reportSize = Math.Min(s.Length-endOfLastMatch, 10);
    string remainder = s.Substring(endOfLastMatch, reportSize);
    Console.WriteLine("Error: RegEx match failed at index "
        +endOfLastMatch+" (\""+remainder+"...\")");
}

输出：

abc,

错误：正则表达式匹配在索引 10 处失败（“x 名称：de...”）

魔术发生在\G 锚点中，它允许我们使用NextMatch 进行模式重复，同时强制下一个匹配紧跟上一个匹配。可以说，它是等同于^（行或字符串开始）锚点的匹配边界。

代价是我们不是在一个块中解析文本（就像在接受的答案中一样），而是在一个 for 循环中。不过因为比较小，我觉得还是可以接受的。