解析空格分隔文本的最佳方法

Question

我有这样的字符串，

 /c SomeText\MoreText "Some Text\More Text\Lol" SomeText

我想对其进行标记，但是我不能只在空格上进行拆分。 我想出了一个有点丑陋的解析器，但我想知道是否有人有更优雅的设计。

顺便说一句，这是 C# 中的。

编辑：我的丑陋版本虽然丑陋，但它是 O(N) 并且实际上可能比使用正则表达式更快。

private string[] tokenize(string input)
{
    string[] tokens = input.Split(' ');
    List<String> output = new List<String>();

    for (int i = 0; i < tokens.Length; i++)
    {
        if (tokens[i].StartsWith("\""))
        {
            string temp = tokens[i];
            int k = 0;
            for (k = i + 1; k < tokens.Length; k++)
            {
                if (tokens[k].EndsWith("\""))
                {
                    temp += " " + tokens[k];
                    break;
                }
                else
                {
                    temp += " " + tokens[k];
                }
            }
            output.Add(temp);
            i = k + 1;
        }
        else
        {
            output.Add(tokens[i]);
        }
    }

    return output.ToArray();            
}

Answer 1

您正在做的事情的计算机术语是词法分析； 阅读该文章以获得对这一常见任务的良好总结。

根据您的示例，我猜测您希望用空格来分隔单词，但引号中的内容应被视为不带引号的“单词”。

最简单的方法是将单词定义为正则表达式：

([^"^\s]+)\s*|"([^"]+)"\s*

此表达式指出“单词”是 (1) 被空格包围的非引号、非空白文本，或 (2) 被空格包围的非引号文本通过引号（后跟一些空格）。 请注意使用捕获括号来突出显示所需的文本。

有了该正则表达式，您的算法就很简单：在文本中搜索捕获括号定义的下一个“单词”，然后返回它。 重复此操作，直到您用完“单词”为止。

这是我能用 VB.NET 编写的最简单的工作代码。 请注意，我们必须检查两个组中的数据，因为有两组捕获括号。

Dim token As String
Dim r As Regex = New Regex("([^""^\s]+)\s*|""([^""]+)""\s*")
Dim m As Match = r.Match("this is a ""test string""")

While m.Success
    token = m.Groups(1).ToString
    If token.length = 0 And m.Groups.Count > 1 Then
        token = m.Groups(2).ToString
    End If
    m = m.NextMatch
End While

注1：上面的Will的答案与这个想法相同。 希望这个答案能更好地解释场景背后的细节:)

Answer 2

Microsoft.VisualBasic.FileIO 命名空间（在 Microsoft.VisualBasic.dll 中）有一个 TextFieldParser，可用于分割空格分隔的文本。 它可以很好地处理引号内的字符串（即“这是一个标记”thisistokentwo）。

请注意，仅仅因为 DLL 显示 VisualBasic 并不意味着您只能在 VB 项目中使用它。 它是整个框架的一部分。

Answer 3

有状态机方法。

    private enum State
    {
        None = 0,
        InTokin,
        InQuote
    }

    private static IEnumerable<string> Tokinize(string input)
    {
        input += ' '; // ensure we end on whitespace
        State state = State.None;
        State? next = null; // setting the next state implies that we have found a tokin
        StringBuilder sb = new StringBuilder();
        foreach (char c in input)
        {
            switch (state)
            {
                default:
                case State.None:
                    if (char.IsWhiteSpace(c))
                        continue;
                    else if (c == '"')
                    {
                        state = State.InQuote;
                        continue;
                    }
                    else
                        state = State.InTokin;
                    break;
                case State.InTokin:
                    if (char.IsWhiteSpace(c))
                        next = State.None;
                    else if (c == '"')
                        next = State.InQuote;
                    break;
                case State.InQuote:
                    if (c == '"')
                        next = State.None;
                    break;
            }
            if (next.HasValue)
            {
                yield return sb.ToString();
                sb = new StringBuilder();
                state = next.Value;
                next = null;
            }
            else
                sb.Append(c);
        }
    }

它可以很容易地扩展到诸如嵌套引号和转义之类的事情。 返回为 IEnumerable 允许您的代码仅解析您需要的内容。 这种惰性方法没有任何真正的缺点，因为字符串是不可变的，因此您知道在解析整个内容之前 input 不会改变。

请参阅：http://en.wikipedia.org/wiki/Automata-Based_Programming

Answer 4

您可能还想研究正则表达式。 这可能会帮助你。 这是从 MSDN 中盗取的示例...

using System;
using System.Text.RegularExpressions;

public class Test
{

    public static void Main ()
    {

        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumped over the lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }

    }

}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumped over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54

Answer 5

Craig 是对的 - 使用正则表达式。 Regex.Split 可能会更简洁地满足您的需求。

Answer 6

[^\t]+\t|"[^"]+"\t

使用正则表达式绝对看起来是最好的选择，但是这个只返回整个字符串。我正在尝试调整它，但运气不佳，所以远的。

string[] tokens = System.Text.RegularExpressions.Regex.Split(this.BuildArgs, @"[^\t]+\t|""[^""]+""\t");