.Net核心正则表达式,命名组,嵌套组,反向引用和惰性限定符

Question

我试图从使用.Net Core 2.1看起来像标记的字符串解析键值对.

考虑下面的示例Program.cs文件...

我的问题是:

1.

如何编写模式kvp以表现为"Key and Value if exists"而不是"Key或Value",因为它目前的行为？

例如,在测试用例2中输出,而不是:

=============================
input = <tag KEY1="vAl1">

--------------------
kvp[0] = KEY1
          key   =       KEY1
        value   =
--------------------
kvp[1] = vAl1
          key   =
        value   =       vAl1
=============================

我想看看:

=============================
input = <tag KEY1="vAl1">

--------------------
kvp[0] = KEY1="vAl1"
          key   =       KEY1
        value   =       vAl1
=============================

不破坏测试用例9:

=============================
input = <tag noValue1 noValue2>

--------------------
kvp[0] = noValue1
          key   =       noValue1
        value   =
--------------------
kvp[1] = noValue2
          key   =       noValue2
        value   =
=============================

2.

如何编写模式value以在名为" quotes " 的组匹配的下一个字符处停止匹配？换句话说,下一个平衡报价.我显然误解了反向引用是如何工作的,我的理解是\k<quotes>将被运行时匹配的值(不是设计时定义的模式)所取代(?<quotes>[""'`]).

例如,在测试用例5中输出,而不是:

--------------------
kvp[4] =  key3='hello,
          key   =
        value   =        key3='hello,
--------------------
kvp[5] = experts
          key   =
        value   =       experts
=============================

我想看到(尽管问题1的解决方案):

--------------------
kvp[4] =  key3
          key   =        key3
        value   =
--------------------
kvp[5] = hello, "experts"
          key   =
        value   =       hello, "experts"
=============================

3.

如何编写模式value以停止匹配/>？在测试用例7中,值key2应为thing-1.我不记得我尝试过的所有内容,但是我没有找到一个可以在不破坏测试用例6的情况下工作的模式,其中它/ 是值的一部分.

---

Program.cs中

using System;
using System.Reflection;
using System.Text.RegularExpressions;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            RegExTest();

            Console.ReadLine();
        }

        static void RegExTest()
        {
            // Test Cases
            var case1 = @"<tag>";
            var case2 = @"<tag KEY1=""vAl1"">";
            var case3 = @"<tag kEy2='val2'>";
            var case4 = @"<tag key3=`VAL3`>";
            var case5 = @"<tag           key1='val1' 

                        key2=""http://www.w3.org"" key3='hello, ""experts""'>";
            var case6 = @"<tag :key1 =some/thing>";
            var case7 = @"<tag key2=thing-1/>";
            var case8 = @"<tag key3      =        thing-2>";
            var case9 = @"<tag noValue1 noValue2>";
            var case10 = @"<tag/>";
            var case11 = @"<tag />";

            // A key may begin with a letter, underscore or colon, follow by 
            // zero or more of those, or numbers, periods, or dashs.
            string key = @"(?<key>(?<=\s+)[a-z_:][a-z0-9_:\.-]*?(?=[\s=>]+))";

            // A value may contain any character, and must be wrapped in balanced quotes (double, single, 
            // or back) if the value contains any quote, whitespace, equal, or greater- or less- than 
            // character.
            string value = @"(?<value>((?<=(?<quotes>[""'`])).*?(?=\k<quotes>)|(?<=[=][\s]*)[^""'`\s=<>]+))";

            // A key-value pair must contain a key, 
            // a value is optional
            string kvp = $"(?<kvp>{key}|{value})"; // Without the | (pipe), it doesn't match any test case...

            // ...value needs to be optional (case9), tried:
            //kvp = $"(?<kvp>{key}{value}?)";
            //kvp = $"(?<kvp>{key}({value}?))";
            //kvp = $"(?<kvp>{key}({value})?)";
            // ...each only matches key, but also matches value in case8 as key

            Regex getKvps = new Regex(kvp, RegexOptions.IgnoreCase);

            FormatMatches(getKvps.Matches(case1)); // OK

            FormatMatches(getKvps.Matches(case2)); // OK

            FormatMatches(getKvps.Matches(case3)); // OK

            FormatMatches(getKvps.Matches(case4)); // OK

            FormatMatches(getKvps.Matches(case5)); // Backreference and/or lazy qualifier doesn't work.

            FormatMatches(getKvps.Matches(case6)); // OK

            FormatMatches(getKvps.Matches(case7)); // The / is not part of the value.

            FormatMatches(getKvps.Matches(case8)); // OK

            FormatMatches(getKvps.Matches(case9)); // OK

            FormatMatches(getKvps.Matches(case10)); // OK

            FormatMatches(getKvps.Matches(case11)); // OK
        }

        static void FormatMatches(MatchCollection matches)
        {
            Console.WriteLine(new string('=', 78));

            var _input = matches.GetType().GetField("_input",
                BindingFlags.NonPublic |
                BindingFlags.Instance)
                .GetValue(matches);

            Console.WriteLine($"input = {_input}");
            Console.WriteLine();

            if (matches.Count < 1)
            {
                Console.WriteLine("[kvp not matched]");
                return;
            }

            for (int i = 0; i < matches.Count; i++)
            {
                Console.WriteLine(new string('-', 20));

                Console.WriteLine($"kvp[{i}] = {matches[i].Groups["kvp"]}");
                Console.WriteLine($"\t  key\t=\t{matches[i].Groups["key"]}");
                Console.WriteLine($"\tvalue\t=\t{matches[i].Groups["value"]}");
            }
        }
    }
}

Answer 1

您可以使用

\s(?<key>[a-z_:][a-z0-9_:.-]*)(?:\s*=\s*(?:(?<q>[`'"])(?<value>.*?)\k<q>|(?<value>(?:(?!/>)[^\s`'"<>])+)))?

请参阅突出显示组的正则表达式演示和.NET 正则表达式演示（证明）。

C# 用法：

var pattern = @"\s(?<key>[a-z_:][a-z0-9_:.-]*)(?:\s*=\s*(?:(?<q>[`'""])(?<value>.*?)\k<q>|(?<value>(?:(?!/>)[^\s`'""<>])+)))?";
var matches = Regex.Matches(case, pattern, RegexOptions.IgnoreCase);
foreach (Match m in matches)
{
    Console.WriteLine(m.Value);                 // The whole match
    Console.WriteLine(m.Groups["key"].Value);   // Group "key" value
    Console.WriteLine(m.Groups["value"].Value); // Group "value" value
}

细节

• \s- 一个空格
• (?<key>[a-z_:][a-z0-9_:.-]*)- 组“key”：一个字母，_或:，然后 0+ 个字母，数字，_, :,.或-
• (?:\s*=\s*(?:(?['"])(?<value>.*?)\k<q>|(?<value>(?:(?!/>)[^\s'"<>])+)))?- 出现一次或零次（因此该值是可选的）：
  • \s*=\s*- a=包含 0+ 空格
  • (?:- 非捕获组的开始：
    • (?[`'"])- 分隔符, `,'或"
    • (?<value>.*?)- 与除换行符之外的任何 0+ 字符匹配的“值”组尽可能少
    • \k<q>- 向后引用组“q”，相同的值必须匹配
  • |- 或者
    • (?<value>(?:(?!/>)[^\s`'"<>])+)`- 组“值”：除空格、 、'、"、<和之外的字符>，出现 1 次或多次，不启动/>字符序列
• )- 非捕获组的末尾。