我可以使用 LINQ 从字符串中去除重复的空格吗？

Question

快速脑筋急转弯：给定一个字符串

This  is a string with  repeating   spaces

LINQ 的最终表达方式是什么

This is a string with repeating spaces

谢谢！

作为参考，这是一种非 LINQ 方式：

private static IEnumerable<char> RemoveRepeatingSpaces(IEnumerable<char> text)
{
  bool isSpace = false;
  foreach (var c in text)
  {
    if (isSpace && char.IsWhiteSpace(c)) continue;

    isSpace = char.IsWhiteSpace(c);
    yield return c;
  }
}

Answer 1

这不是 linq 类型的任务，使用正则表达式

string output = Regex.Replace(input," +"," ");

当然，您可以使用 linq 将其应用于字符串集合。

Answer 2

public static string TrimInternal(this string text)
{
  var trimmed = text.Where((c, index) => !char.IsWhiteSpace(c) || (index != 0 && !char.IsWhiteSpace(text[index - 1])));
  return new string(trimmed.ToArray());
}

Answer 3

由于似乎没有人给出令人满意的答案，我想出了一个。这是一个基于字符串的解决方案（.Net 4）：

public static string RemoveRepeatedSpaces(this string s)
{
    return s[0] + string.Join("",
           s.Zip(
               s.Skip(1),
               (x, y) => x == y && y == ' ' ? (char?)null : y));
}

但是，这只是从序列中删除重复元素的一般情况，所以这里是通用版本：

public static IEnumerable<T> RemoveRepeatedElements<T>(
                             this IEnumerable<T> s, T dup)
{
    return s.Take(1).Concat(
            s.Zip(
                s.Skip(1),
                (x, y) => x.Equals(y) && y.Equals(dup) ? (object)null : y)
            .OfType<T>());
}

当然，这实际上只是一个更具体的函数版本，可以从输入流中删除所有连续重复项：

public static IEnumerable<T> RemoveRepeatedElements<T>(this IEnumerable<T> s)
{
    return s.Take(1).Concat(
            s.Zip(
                s.Skip(1),
                (x, y) => x.Equals(y) ? (object)null : y)
            .OfType<T>());
}

显然你可以根据第二个函数来实现第一个函数：

public static string RemoveRepeatedSpaces(this string s)
{
    return string.Join("", s.RemoveRepeatedElements(' '));
}

顺便说一句，我将我的最后一个函数与正则表达式版本 (Regex.Replace(s, " +", " ")) 进行了基准测试，它们之间的时间相差不到几纳秒，因此与额外的正则表达式开销相比，额外的 LINQ 开销可以忽略不计。当我将它概括为删除所有连续的重复字符时，等效的正则表达式 (Regex.Replace(s, "(.)\\1+", "$1")) 比我的 LINQ 版本 (string.Join("", s.RemoveRepeatedElements())) 慢 3.5 倍。

我也尝试了“理想”的程序解决方案：

public static string RemoveRepeatedSpaces(string s)
{
    StringBuilder sb = new StringBuilder(s.Length);
    char lastChar = '\0';
    foreach (char c in s)
        if (c != ' ' || lastChar != ' ')
            sb.Append(lastChar = c);
    return sb.ToString();
}

这比正则表达式快 5 倍以上！

Answer 4

在实践中，我可能只会使用您的原始解决方案或正则表达式（如果您想要一个快速简单的解决方案）。使用 lambda 函数的一种极客方法是定义一个定点运算符：

T FixPoint<T>(T initial, Func<T, T> f) {
   T current = initial;
   do { 
     initial = current;
     current = f(initial);
   } while (initial != current);
   return current;
}

这会不断调用操作f，直到操作返回与作为参数相同的值。您可以将该操作视为一个通用循环 - 它非常有用，尽管我认为它太令人讨厌而无法包含在 .NET BCL 中。然后你可以写：

string res = FixPoint(original, s => s.Replace("  ", " "));

它不如你的原始版本高效，但除非有太多空格，否则它应该可以正常工作。

Answer 5

根据定义，Linq 与可枚举（即集合、列表、数组）相关。您可以将字符串转换为 char 集合并选择非空格的，但这绝对不是 Linq 的工作。

Answer 6

Paul Creasey's answer 是要走的路。

如果您也想将制表符视为空白，请使用：

text = Regex.Replace(text, "[ |\t]+", " ");

---

更新：

Hasan 和Ani 都提出了在满足“使用 LINQ”要求的同时解决此问题的最合乎逻辑的方法。但是，请注意，这些解决方案涉及通过索引访问字符串中的字符。

LINQ 方法的精神在于它可以应用于任何可枚举的序列。因为对这个问题的任何合理有效的解决方案都需要维护某种状态（使用 Ani 和 Hasan 的解决方案很容易忽略这个事实，因为状态已经在字符串本身中维护），接受任何项目序列的通用方法可能会使用过程代码更直接地实现。

然后，这个过程代码可能会被抽象成一个看起来像LINQ风格的方法的方法，当然。但我不建议从一开始就抱着“我想在这个解决方案中使用 LINQ”的态度来解决这样的问题，因为它会对你的代码施加非常尴尬的限制。

对于它的价值，这是我将如何实现总体想法的方式。

public static IEnumerable<T> StripConsecutives<T>(this IEnumerable<T> source, T value, IEqualityComparer<T> comparer)
{
    // null-checking omitted for brevity

    using (var enumerator = source.GetEnumerator())
    {
        if (enumerator.MoveNext())
        {
            yield return enumerator.Current;
        }
        else
        {
            yield break;
        }

        T prev = enumerator.Current;
        while (enumerator.MoveNext())
        {
            T current = enumerator.Current;
            if (comparer.Equals(prev, value) && comparer.Equals(current, value))
            {
                // This is a consecutive occurrence of value --
                // moving on...
            }
            else
            {
                yield return current;
            }
            prev = current;
        }
    }
}

Answer 7

拆分为列表，过滤，然后重新加入，2 行代码...

var test = "  Alpha      Beta     Tango    ";

var l = test.Split(' ').Where(s => !string.IsNullOrEmpty(s));
var result = string.Join(" ", l);

// result = "Alpha Beta Tango"

重构为扩展方法：

using Extensions;
void Main()
{
    var test = " Alpha    Beta   Tango    ";
    var result = test.RemoveRepeatedSpaces();
    // result = "Alpha Beta Tango";
}

static class Extentions 
{
    public static string RemoveRepeatedSpaces(this string s)
    {
        if (s == null) 
           return string.Empty;

        var l = s.Split(' ').Where(a => !string.IsNullOrEmpty(a));
        return string.Join(" ", l);
    }
}