有很多类似的问题,但是显然没有完美的匹配,这就是我要问的原因。
我想分裂一个随机字符串(如123xx456yy789通过字符串分隔符的列表)(例如xx,yy在结果)和包括分隔符(在这里:123,xx,456,yy,789)。
123xx456yy789
xx
yy
123
456
789
良好的表现是不错的奖励。如果可能,应避免使用正则表达式。
更新 :我进行了一些性能检查,并比较了结果(虽然懒得正式检查它们)。测试的解决方案是(随机顺序):
其他解决方案未经过测试,因为它们与其他解决方案相似或太迟了。
这是测试代码:
class Program { private static readonly List<Func<string, List<string>, List<string>>> Functions; private static readonly List<string> Sources; private static readonly List<List<string>> Delimiters; static Program () { Functions = new List<Func<string, List<string>, List<string>>> (); Functions.Add ((s, l) => s.SplitIncludeDelimiters_Gabe (l).ToList ()); Functions.Add ((s, l) => s.SplitIncludeDelimiters_Guffa (l).ToList ()); Functions.Add ((s, l) => s.SplitIncludeDelimiters_Naive (l).ToList ()); Functions.Add ((s, l) => s.SplitIncludeDelimiters_Regex (l).ToList ()); Sources = new List<string> (); Sources.Add (""); Sources.Add (Guid.NewGuid ().ToString ()); string str = ""; for (int outer = 0; outer < 10; outer++) { for (int i = 0; i < 10; i++) { str += i + "**" + DateTime.UtcNow.Ticks; } str += "-"; } Sources.Add (str); Delimiters = new List<List<string>> (); Delimiters.Add (new List<string> () { }); Delimiters.Add (new List<string> () { "-" }); Delimiters.Add (new List<string> () { "**" }); Delimiters.Add (new List<string> () { "-", "**" }); } private class Result { public readonly int FuncID; public readonly int SrcID; public readonly int DelimID; public readonly long Milliseconds; public readonly List<string> Output; public Result (int funcID, int srcID, int delimID, long milliseconds, List<string> output) { FuncID = funcID; SrcID = srcID; DelimID = delimID; Milliseconds = milliseconds; Output = output; } public void Print () { Console.WriteLine ("S " + SrcID + "\tD " + DelimID + "\tF " + FuncID + "\t" + Milliseconds + "ms"); Console.WriteLine (Output.Count + "\t" + string.Join (" ", Output.Take (10).Select (x => x.Length < 15 ? x : x.Substring (0, 15) + "...").ToArray ())); } } static void Main (string[] args) { var results = new List<Result> (); for (int srcID = 0; srcID < 3; srcID++) { for (int delimID = 0; delimID < 4; delimID++) { for (int funcId = 3; funcId >= 0; funcId--) { // i tried various orders in my tests Stopwatch sw = new Stopwatch (); sw.Start (); var func = Functions[funcId]; var src = Sources[srcID]; var del = Delimiters[delimID]; for (int i = 0; i < 10000; i++) { func (src, del); } var list = func (src, del); sw.Stop (); var res = new Result (funcId, srcID, delimID, sw.ElapsedMilliseconds, list); results.Add (res); res.Print (); } } } } }
如您所见,它实际上只是一个快速而肮脏的测试,但是我以不同的顺序多次运行了该测试,结果始终非常一致。对于较大的数据集,所测量的时间范围在毫秒到秒的范围内。我在随后的评估中忽略了低毫秒范围内的值,因为在实践中它们似乎可以忽略不计。这是我盒子上的输出:
S 0 D 0 F 3 11毫秒 1个 S 0 D 0 F 2 7毫秒 1个 S 0 D 0 F 1 6毫秒 1个 S 0 D 0 F 0 4ms 0 S 0 D 1 F 3 28毫秒 1个 S 0 D 1 F 2 8ms 1个 S 0 D 1 F 1 7毫秒 1个 S 0 D 1 F 0 3ms 0 S 0 D 2 F 3 30毫秒 1个 S 0 D 2 F 2 8ms 1个 S 0 D 2 F 1 6毫秒 1个 S 0 D 2 F 0 3毫秒 0 S 0 D 3 F 3 30毫秒 1个 S 0 D 3 F 2 10毫秒 1个 S 0 D 3 F 1 8毫秒 1个 S 0 D 3 F 0 3毫秒 0 S 1 D 0 F 3 9毫秒 1 9e5282ec-e2a2-4 ... S 1 D 0 F 2 6毫秒 1 9e5282ec-e2a2-4 ... S 1 D 0 F 1 5毫秒 1 9e5282ec-e2a2-4 ... S 1 D 0 F 0 5毫秒 1 9e5282ec-e2a2-4 ... S 1 D 1 F 3 63毫秒 9 9e5282ec-e2a2-4265-8276-6dbb50fdae37 S 1 D 1 F 2 37毫秒 9 9e5282ec-e2a2-4265-8276-6dbb50fdae37 S 1 D 1 F 1 29毫秒 9 9e5282ec-e2a2-4265-8276-6dbb50fdae37 S 1 D 1 F 0 22毫秒 9 9e5282ec-e2a2-4265-8276-6dbb50fdae37 S 1 D 2 F 3 30毫秒 1 9e5282ec-e2a2-4 ... S 1 D 2 F 2 10毫秒 1 9e5282ec-e2a2-4 ... S 1 D 2 F 1 10毫秒 1 9e5282ec-e2a2-4 ... S 1 D 2 F 0 12毫秒 1 9e5282ec-e2a2-4 ... S 1 D 3 F 3 73毫秒 9 9e5282ec-e2a2-4265-8276-6dbb50fdae37 S 1 D 3 F 2 40毫秒 9 9e5282ec-e2a2-4265-8276-6dbb50fdae37 S 1 D 3 F 1 33毫秒 9 9e5282ec-e2a2-4265-8276-6dbb50fdae37 S 1 D 3 F 0 30毫秒 9 9e5282ec-e2a2-4265-8276-6dbb50fdae37 S 2 D 0 F 3 10毫秒 1 0 ** 634226552821 ... S 2 D 0 F 2 109毫秒 1 0 ** 634226552821 ... S 2 D 0 F 1 5毫秒 1 0 ** 634226552821 ... S 2 D 0 F 0 127毫秒 1 0 ** 634226552821 ... S 2 D 1 F 3 184ms 21 0 ** 634226552821 ...-0 ** 634226552821 ...-0 ** 634226552821 ...-0 ** 634226 552821 ...-0 ** 634226552821 ...- S 2 D 1 F 2 364毫秒 21 0 ** 634226552821 ...-0 ** 634226552821 ...-0 ** 634226552821 ...-0 ** 634226 552821 ...-0 ** 634226552821 ...- S 2 D 1 F 1 134毫秒 21 0 ** 634226552821 ...-0 ** 634226552821 ...-0 ** 634226552821 ...-0 ** 634226 552821 ...-0 ** 634226552821 ...- S 2 D 1 F 0 517毫秒 20 0 ** 634226552821 ...-0 ** 634226552821 ...-0 ** 634226552821 ...-0 ** 634226 552821 ...-0 ** 634226552821 ...- S 2 D 2 F 3 688毫秒 201 0 ** 634226552821217 ... ** 634226552821217 ... ** 634226552821217 ... ** 6 34226552821217 ... ** S 2 D 2 F 2 2404毫秒 201 0 ** 634226552821217 ... ** 634226552821217 ... ** 634226552821217 ... ** 6 34226552821217 ... ** S 2 D 2 F 1 874毫秒 201 0 ** 634226552821217 ... ** 634226552821217 ... ** 634226552821217 ... ** 6 34226552821217 ... ** S 2 D 2 F 0 717毫秒 201 0 ** 634226552821217 ... ** 634226552821217 ... ** 634226552821217 ... ** 6 34226552821217 ... ** S 2 D 3 F 3 1205ms 221 0 ** 634226552821217 ... ** 634226552821217 ... ** 634226552821217 ... ** 6 34226552821217 ... ** S 2 D 3 F 2 3471ms 221 0 ** 634226552821217 ... ** 634226552821217 ... ** 634226552821217 ... ** 6 34226552821217 ... ** S 2 D 3 F 1 1008毫秒 221 0 ** 634226552821217 ... ** 634226552821217 ... ** 634226552821217 ... ** 6 34226552821217 ... ** S 2 D 3 F 0 1095毫秒 220 0 ** 634226552821217 ... ** 634226552821217 ... ** 634226552821217 ... ** 6 34226552821217 ... **
我比较了结果,这是我发现的结果:
结束本主题,我建议使用Regex,它相当快。 如果性能至关重要,我希望使用Guffa的实现。
尽管您不愿使用正则表达式,但实际上它可以通过使用组和Regex.Split方法来很好地保留定界符:
Regex.Split
string input = "123xx456yy789"; string pattern = "(xx|yy)"; string[] result = Regex.Split(input, pattern);
如果使用just从模式中除去括号"xx|yy",则不会保留定界符。如果您使用任何在正则表达式中具有特殊含义的元字符,请确保在模式上使用Regex.Escape。字符包括`\, *, +, ?, |, {, [, (,), ^, $,.,
"xx|yy"
。例如,
应转义的定界符
。给定定界符列表,您需要使用竖线
var delimiters = new List<string> { ".", "xx", "yy" }; string pattern = "(" + String.Join("|", delimiters.Select(d => Regex.Escape(d)) .ToArray()) + ")";
括号是连接起来的,而不是包含在模式中的,因为出于您的目的它们会被错误地转义。
编辑: 此外,如果delimiters列表碰巧是空的,则最终模式将错误地是(),这将导致空白匹配。为了防止这种情况,可以使用定界符检查。考虑到所有这些,代码片段变成:
delimiters
()
string input = "123xx456yy789"; // to reach the else branch set delimiters to new List(); var delimiters = new List<string> { ".", "xx", "yy", "()" }; if (delimiters.Count > 0) { string pattern = "(" + String.Join("|", delimiters.Select(d => Regex.Escape(d)) .ToArray()) + ")"; string[] result = Regex.Split(input, pattern); foreach (string s in result) { Console.WriteLine(s); } } else { // nothing to split Console.WriteLine(input); }
如果您需要不区分大小写的分隔符匹配,请使用以下RegexOptions.IgnoreCase选项:Regex.Split(input, pattern, RegexOptions.IgnoreCase)
RegexOptions.IgnoreCase
Regex.Split(input, pattern, RegexOptions.IgnoreCase)
编辑#2: 到目前为止的解决方案匹配可能是较大字符串的子字符串的拆分标记。如果拆分标记应完全匹配,而不是子字符串的一部分,例如将句子中的单词用作分隔符的情况,\b则应在模式周围添加单词边界元字符。
\b
例如,考虑以下句子(是的,这很老套): "Welcome to stackoverflow... where the stack never overflows!"
"Welcome to stackoverflow... where the stack never overflows!"
如果定界符为{ "stack", "flow" }当前解决方案,则将拆分“ stackoverflow”并返回3个字符串{ "stack", "over", "flow" }。如果需要精确匹配,则该拆分的唯一位置是句子后面的“堆栈”一词,而不是“ stackoverflow”。
{ "stack", "flow" }
{ "stack", "over", "flow" }
要实现完全匹配行为,请更改模式,使其包含\b在中\b(delim1|delim2|delimN)\b:
\b(delim1|delim2|delimN)\b
string pattern = @"\b(" + String.Join("|", delimiters.Select(d => Regex.Escape(d))) + @")\b";
最后,如果需要在定界符之前和之后修剪空格,请\s*像一样在模式周围添加\s*(delim1|delim2|delimN)\s*。可以结合\b如下:
\s*
\s*(delim1|delim2|delimN)\s*
string pattern = @"\s*\b(" + String.Join("|", delimiters.Select(d => Regex.Escape(d))) + @")\b\s*";