提取格式化字符串中的一些值答案

【问题标题】：Extract some values in formatted string提取格式化字符串中的一些值
【发布时间】：2015-09-02 06:56:16
【问题描述】：

我想检索格式如下的字符串中的值：

public var any:int = 0;
public var anyId:Number = 2;
public var theEnd:Vector.<uint>;
public var test:Boolean = false;
public var others1:Vector.<int>;
public var firstValue:CustomType;
public var field2:Boolean = false;
public var secondValue:String = "";
public var isWorks:Boolean = false;

我想在自定义类属性中存储字段名称、类型和值：

public class Property
{
    public string Name { get; set; }
    public string Type { get; set; }
    public string Value { get; set; }
}

并使用正则表达式获取这些值。

我该怎么办？

谢谢

编辑：我试过了，但我不知道如何进一步使用vectors..etc

    /public var ([a-zA-Z0-9]*):([a-zA-Z0-9]*)( = \"?([a-zA-Z0-9]*)\"?)?;/g

【问题讨论】：

请发布您到目前为止所尝试的内容。
好的，看看this demo。如果我应该发布它，或者如果您更喜欢基于 LINQ 的示例，请告诉我。
@stribizhev 这应该是一个答案。顺便说一句，您可以在 .NET 正则表达式中解析多行字符串，您不需要在模式中包含换行符

标签： c# regex string field extract

【解决方案1】：

好的，发布我的基于正则表达式的答案。

您的正则表达式 - /public var ([a-zA-Z0-9]*):([a-zA-Z0-9]*)( = \"?([a-zA-Z0-9]*)\"?)?;/g - 包含正则表达式分隔符，它们在 C# 中不受支持，因此被视为文字符号。您需要删除它们并使用修饰符 g，因为可以使用 C# 中的多个匹配项 Regex.Matches 或 Regex.Match 与 while 和 Match.Success/.NextMatch()。

我使用的正则表达式是(?<=\s*var\s*)(?<name>[^=:\n]+):(?<type>[^;=\n]+)(?:=(?<value>[^;\n]+))?。包含换行符是因为否定字符类可以匹配换行符。

var str = "public var any:int = 0;\r\npublic var anyId:Number = 2;\r\npublic var theEnd:Vector.<uint>;\r\npublic var test:Boolean = false;\r\npublic var others1:Vector.<int>;\r\npublic var firstValue:CustomType;\r\npublic var field2:Boolean = false;\r\npublic var secondValue:String = \"\";\r\npublic var isWorks:Boolean = false;";
var rx = new Regex(@"(?<=\s*var\s*)(?<name>[^=:\n]+):(?<type>[^;=\n]+)(?:=(?<value>[^;\n]+))?");
var coll = rx.Matches(str);
var props = new List<Property>();
foreach (Match m in coll)
    props.Add(new Property(m.Groups["name"].Value,m.Groups["type"].Value, m.Groups["value"].Value));
foreach (var item in props)
    Console.WriteLine("Name = " + item.Name + ", Type = " + item.Type + ", Value = " + item.Value);

或使用 LINQ：

var props = rx.Matches(str)
          .OfType<Match>()
          .Select(m => 
               new Property(m.Groups["name"].Value, 
                   m.Groups["type"].Value, 
                   m.Groups["value"].Value))
          .ToList();

以及类示例：

public class Property
{
    public string Name { get; set; }
    public string Type { get; set; }
    public string Value { get; set; }
    public Property()
    {}
    public Property(string n, string t, string v)
    {
        this.Name = n;  
        this.Type = t;
        this.Value = v;
    }
}

性能说明：

正则表达式不是最快的，但它肯定优于另一个答案中的那个。这是在regexhero.net 进行的测试：

【讨论】：

我想就是这样，但如果您有更多问题，请随时发表评论。
您可以使用非贪婪匹配而不是否定，例如。 (?<name>\w+?)
@PanagiotisKanavos：使用name，为什么不呢，但我试图让正则表达式尽可能通用。在处理基于正则表达式的分隔符匹配时，我更喜欢否定类。
谢谢，它工作正常！我稍微编辑了模式以避免空格： "(?var \s)(?[^=:\n]+):(?[^ ;=\n]+) (?:= (?[^;\n]+))?"
@stribizhev 当您不必必须添加每个不匹配的类时，它会更通用。您可以在其他元素中使用\S 来匹配非空白字符

【解决方案2】：

看来，你不想要正则表达式；在一个简单的情况下正如您提供的那样：

  String text =
    @"public var any:int = 0;
      public var anyId:Number = 2;
      public var theEnd:Vector.<uint>;
      public var test:Boolean = false;
      public var others1:Vector.<int>;
      public var firstValue:CustomType;
      public var field2:Boolean = false;";

  List<Property> result = text
    .Split(new Char[] {'\r','\n'}, StringSplitOptions.RemoveEmptyEntries)
    .Select(line => {
       int varIndex = line.IndexOf("var") + "var".Length;
       int columnIndex = line.IndexOf(":") + ":".Length;
       int equalsIndex = line.IndexOf("="); // + "=".Length;
       // '=' can be absent
       equalsIndex = equalsIndex < 0 ? line.Length : equalsIndex + "=".Length;

       return new Property() {
         Name = line.Substring(varIndex, columnIndex - varIndex - 1).Trim(),
         Type = line.Substring(columnIndex, columnIndex - varIndex - 1).Trim(),
         Value = line.Substring(equalsIndex).Trim(' ', ';')
       };
    })
    .ToList();

如果文本可以包含 cmets 和其他五线谱，例如

  "public (*var is commented out*) var sample: int = 123;;;; // another comment"

你必须实现一个解析器

【讨论】：

即使在这种“简单”的情况下，正则表达式也比字符串拆分更简单、更易于维护。

【解决方案3】：

您可以使用以下模式：

\s*(?<vis>\w+?)\s+var\s+(?<name>\w+?)\s*:\s*(?<type>\S+?)(\s*=\s*(?<value>\S+?))?\s*;

匹配一行中的每个元素。在量词之后附加? 会导致非贪婪匹配，这使得模式更简单 - 无需否定所有不需要的类。

值是可选的，因此值组被包装在另一个可选组(\s*=\s*(?<value>\S+?))?

使用RegexOptions.Multiline 选项意味着我们不必担心意外匹配换行符。

以下示例中的 C# 6 语法不是必需的，但多行字符串文字和内插字符串使代码更简洁。

var input= @"public var any:int = 0;
            public var anyId:Number = 2;
            public var theEnd:Vector.<uint>;
            public var test:Boolean = false;
            public var others1:Vector.<int>;
            public var firstValue:CustomType;
            public var field2:Boolean = false;
            public var secondValue:String = """";
            public var isWorks:Boolean = false;";

var pattern= @"\s*(?<vis>\w+?)\s+var\s+(?<name>\w+?)\s*:\s*(?<type>\S+?)(\s*=\s*(?<value>\S+?))?\s*;"
var regex = new Regex(pattern, RegexOptions.Multiline);
var results=regex.Matches(input);
foreach (Match m in results)
{
    var g = m.Groups;
    Console.WriteLine($"{g["name"],-15} {g["type"],-10} {g["value"],-10}");
}

var properties = (from m in results.OfType<Match>()
                    let g = m.Groups
                    select new Property
                    {
                        Name = g["name"].Value,
                        Type = g.["type"].Value,
                        Value = g["value"].Value
                    })
                    .ToList();

如果我必须解析更复杂的输入或者有多个模式要匹配，我会考虑使用像 ANTLR 这样的解析器生成器。学习如何编写语法需要一些时间，但是一旦你学会了它，就很容易创建可以匹配需要非常复杂的正则表达式的输入的解析器。空白管理也变得容易了很多

在这种情况下，语法可能是这样的：

property   : visibility var name COLON type (EQUALS value)? SEMICOLON;
visibility : ALPHA+;
var        : ALPHA ALPHA ALPHA;
name       : ALPHANUM+;
type       : (ALPHANUM|DOT|LEFT|RIGHT);
value      : ALPHANUM
           | literal;
literal    : DOUBLE_QUOTE ALPHANUM* DOUBLE_QUOTE;

ALPHANUM   : ALPHA
           | DIGIT;
ALPHA      : [A-Z][a-z];
DIGIT      : [0-9];
...
WS         : [\r\n\s] -> skip;

使用解析器，添加例如 cmets 就像在 property 规则中的 SEMICOLON 之前添加 comment 以及匹配评论模式的新 comment 规则一样简单

【讨论】：