如何在括号内获取括号

Question

我试图在一个被括号包围的字符串中保留一个括号。

有问题的字符串是：test (blue,(hmmm) derp)

所需的数组输出为：test 和 (blue,(hmmm) derp)。

当前输出为：(blue,、(hmm)和derp)。

我当前的代码是this：

var input = Regex
  .Split(line, @"(\([^()]*\))")
  .Where(s => !string.IsNullOrEmpty(s))
  .ToList();

如何提取外括号内的文本（保留它们）并将内括号作为一个字符串保留在数组中？

编辑：

为了澄清我的问题，我想忽略内括号，只拆分外括号。

herpdediderp (orange,(hmm)) some other crap (red,hmm)

应该变成：

herpdediderp、orange,(hmm)、some other crap 和 red,hmm。

该代码适用于除双括号之外的所有内容：(orange,(hmm)) 到 orange,(hmm)。

Answer 1

你可以使用方法

public string Trim(params char[] trimChars)

这样

string trimmedLine = line.Trim('(', ')'); // Specify undesired leading and trailing chars.

// Specify separator characters for the split (here command and space):
string[] input = trimmedLine.Split(new[]{',', ' '}, StringSplitOptions.RemoveEmptyEntries);

如果该行可以以 2 个连续的括号开头或结尾，请使用简单的旧 if 语句：

if (line.StartsWith("(")) {
    line = line.Substring(1);
}
if (line.EndsWith(")")) {
    line = line.Substring(0, line.Length - 1);
}
string[] input = line.Split(new[]{',', ' '}, 

Answer 2

这里发生了很多猜测——来自我和其他人。你可以试试

[^(]+|\([^(]*(?:\([^(]*\)[^(]*)*\)

它处理一级括号递归（虽然可以扩展）。

Here at regexstorm.

Visual illustration at regex101.

如果这激起了你的兴趣，我会添加一个解释；）

编辑：

如果您需要使用拆分，请将所选内容放入一个组中，例如

([^(]+|\([^(]*(?:\([^(]*\)[^(]*)*\))

并过滤掉空字符串。参见示例here at ideone。

编辑 2：

不太确定你想要多级括号的行为，但我认为这可以为你做到：

([^(]+|\([^(]*(?:\([^(]*(?:\([^(]*\)[^(]*)*\)[^(]*)*\))
                        ^^^^^^^^^^^^^^^^^^^ added

对于您想要的每个递归级别，您“只需”添加另一个内部级别。所以这是用于两个级别的递归；）

See it here at ideone.

Answer 3

希望有人会想出一个正则表达式。这是我的代码答案。

static class ExtensionMethods
{
    static public IEnumerable<string> GetStuffInsideParentheses(this IEnumerable<char> input)
    {
        int levels = 0;
        var current = new Queue<char>();
        foreach (char c in input)
        {
            if (levels == 0)
            {
                if (c == '(') levels++;
                continue;
            }
            if (c == ')')
            {
                levels--; 
                if (levels == 0)
                { 
                    yield return new string(current.ToArray()); 
                    current.Clear();
                    continue;
                }
            }
            if (c == '(')
            {
                levels++; 
            }
            current.Enqueue(c); 
        }
    }
}

测试程序：

public class Program
{
    public static void Main()
    {

        var input = new []
        {
            "(blue,(hmmm) derp)", 
            "herpdediderp (orange,(hmm)) some other crap (red,hmm)"
        };

        foreach ( var s in input )
        {
            var output = s.GetStuffInsideParentheses();
            foreach ( var o in output )
            {
                Console.WriteLine(o);
            }
            Console.WriteLine();
        }
    }
}

输出：

blue,(hmmm) derp

orange,(hmm)
red,hmm

Code on DotNetFiddle

Answer 4

我认为，如果你倒过来考虑问题，它会变得更容易一些 - 不要分裂你不想要的东西，提取你想要的东西。

如果匹配嵌套括号，唯一有点棘手的部分是，我假设你只会深入一层。

第一个例子：

var s1 = "(blue, (hmmm) derp)";
var input = Regex.Matches(s1, @"\((?:\(.+?\)|[^()]+)+\)").Cast<Match>().Select(m => Regex.Matches(m.Value, @"\(\w+\)|\w+").Cast<Match>().Select(m2 => m2.Value).ToArray()).ToArray();
// input is string[][] { string[] { "blue", "(hmmm)", "derp" } }

第二个例子使用了扩展方法：

public static string TrimOutside(this string src, string openDelims, string closeDelims) {
    if (!String.IsNullOrEmpty(src)) {
        var openIndex = openDelims.IndexOf(src[0]);
        if (openIndex >= 0 && src.EndsWith(closeDelims.Substring(openIndex, 1)))
            src = src.Substring(1, src.Length - 2);
    }
    return src;
}

代码/模式不同，因为这两个示例的处理方式不同：

var s2 = "herpdediderp (orange,(hmm)) some other crap (red,hmm)";
var input3 = Regex.Matches(s2, @"\w(?:\w| )+\w|\((?:[^(]+|\([^)]+\))+\)").Cast<Match>().Select(m => m.Value.TrimOutside("(",")")).ToArray();
// input2 is string[] { "herpdediderp", "orange,(hmm)", "some other crap", "red,hmm" }