将字符串拆分为最大长度的行而不破坏单词的最佳方法

Question

如果可能的话，我想将一个字符串分成指定最大长度的行，而不拆分任何单词（如果有一个单词超过了最大行长度，则必须对其进行拆分）。

与往常一样，我非常清楚字符串是不可变的，最好使用 StringBuilder 类。我已经看到将字符串拆分为单词然后使用 StringBuilder 类构建行的示例，但下面的代码对我来说似乎“更整洁”。

我在描述中提到了“最好”而不是“最有效”，因为我也对代码的“雄辩”感兴趣。字符串永远不会很大，通常分为 2 或 3 行，并且不会发生数千行。

下面的代码真的很糟糕吗？

private static IEnumerable<string> SplitToLines(string stringToSplit, int maximumLineLength)
{
    stringToSplit = stringToSplit.Trim();
    var lines = new List<string>();

    while (stringToSplit.Length > 0)
    {
        if (stringToSplit.Length <= maximumLineLength)
        {
            lines.Add(stringToSplit);
            break;
        }

        var indexOfLastSpaceInLine = stringToSplit.Substring(0, maximumLineLength).LastIndexOf(' ');
        lines.Add(stringToSplit.Substring(0, indexOfLastSpaceInLine >= 0 ? indexOfLastSpaceInLine : maximumLineLength).Trim());
        stringToSplit = stringToSplit.Substring(indexOfLastSpaceInLine >= 0 ? indexOfLastSpaceInLine + 1 : maximumLineLength);
    }

    return lines.ToArray();
}

Answer 1

即使这篇文章已经发布了 3 年，我也想使用 Regex 提供更好的解决方案来完成同样的任务：

如果你想分割字符串然后使用要显示的文本，你可以使用这个：

public string SplitToLines(string stringToSplit, int maximumLineLength)
{
    return Regex.Replace(stringToSplit, @"(.{1," + maximumLineLength +@"})(?:\s|$)", "$1\n");
}

另一方面，如果你需要一个集合，你可以使用这个：

public MatchCollection SplitToLines(string stringToSplit, int maximumLineLength)
{
    return Regex.Matches(stringToSplit, @"(.{1," + maximumLineLength +@"})(?:\s|$)");
}

注意事项

记得导入正则表达式（using System.Text.RegularExpressions;）

您可以在比赛中使用字符串插值：
$@"(.{{1,{maximumLineLength}}})(?:\s|$)"

MatchCollection 的工作方式几乎与Array 相似

匹配示例与解释here

Answer 2

如何解决这个问题：

IEnumerable<string> SplitToLines(string stringToSplit, int maximumLineLength)
{
    var words = stringToSplit.Split(' ').Concat(new [] { "" });
    return
        words
            .Skip(1)
            .Aggregate(
                words.Take(1).ToList(),
                (a, w) =>
                {
                    var last = a.Last();
                    while (last.Length > maximumLineLength)
                    {
                        a[a.Count() - 1] = last.Substring(0, maximumLineLength);
                        last = last.Substring(maximumLineLength);
                        a.Add(last);
                    }
                    var test = last + " " + w;
                    if (test.Length > maximumLineLength)
                    {
                        a.Add(w);
                    }
                    else
                    {
                        a[a.Count() - 1] = test;
                    }
                    return a;
                });
}

---

我更喜欢这个：

IEnumerable<string> SplitToLines(string stringToSplit, int maximumLineLength)
{
    var words = stringToSplit.Split(' ');
    var line = words.First();
    foreach (var word in words.Skip(1))
    {
        var test = $"{line} {word}";
        if (test.Length > maximumLineLength)
        {
            yield return line;
            line = word;
        }
        else
        {
            line = test;
        }
    }
    yield return line;
}

Answer 3

我不认为你的解决方案太糟糕了。但是，我确实认为您应该将三元组分解为 if else，因为您要测试相同的条件两次。您的代码也可能有错误。根据您的描述，您似乎需要行

这是我的解决方案。

private static IEnumerable<string> SplitToLines(string stringToSplit, int maxLineLength)
    {
        string[] words = stringToSplit.Split(' ');
        StringBuilder line = new StringBuilder();
        foreach (string word in words)
        {
            if (word.Length + line.Length <= maxLineLength)
            {
                line.Append(word + " ");
            }
            else
            {
                if (line.Length > 0)
                {
                    yield return line.ToString().Trim();
                    line.Clear();
                }
                string overflow = word;
                while (overflow.Length > maxLineLength)
                {
                    yield return overflow.Substring(0, maxLineLength);
                    overflow = overflow.Substring(maxLineLength);
                }
                line.Append(overflow + " ");
            }
        }
        yield return line.ToString().Trim();
    }

它比您的解决方案长一点，但应该更简单。它还使用 StringBuilder，因此对于大字符串来说要快得多。我对 20,000 个单词进行了基准测试，单词范围从 1 到 11 个字符，每个单词分成 10 个字符宽度的行。我的方法在 14 毫秒内完成，而您的方法是 1373 毫秒。

Answer 4

试试这个（未经测试）

    private static IEnumerable<string> SplitToLines(string value, int maximumLineLength)
    {
        var words = value.Split(' ');
        var line = new StringBuilder();

        foreach (var word in words)
        {
            if ((line.Length + word.Length) >= maximumLineLength)
            {
                yield return line.ToString();
                line = new StringBuilder();
            }

            line.AppendFormat("{0}{1}", (line.Length>0) ? " " : "", word);
        }

        yield return line.ToString();
    }

Answer 5

我的要求是在 30 个字符限制之前的最后一个空格处换行。 所以这就是我是如何做到的。希望这对任何寻找的人都有帮助。

 private string LineBreakLongString(string input)
        {
            var outputString = string.Empty;
            var found = false;
            int pos = 0;
            int prev = 0;
            while (!found)
                {
                    var p = input.IndexOf(' ', pos);
                    {
                        if (pos <= 30)
                        {
                            pos++;
                            if (p < 30) { prev = p; }
                        }
                        else
                        {
                            found = true;
                        }
                    }
                    outputString = input.Substring(0, prev) + System.Environment.NewLine + input.Substring(prev, input.Length - prev).Trim();
                }

            return outputString;
        }

Answer 6

一种使用递归方法和ReadOnlySpan（已测试）的方法

public static void SplitToLines(ReadOnlySpan<char> stringToSplit, int index, ref List<string> values)
{
   if (stringToSplit.IsEmpty || index < 1) return;
   var nextIndex = stringToSplit.IndexOf(' ');
   var slice = stringToSplit.Slice(0, nextIndex < 0 ? stringToSplit.Length : nextIndex);

   if (slice.Length <= index)
   {
      values.Add(slice.ToString());
      nextIndex++;
   }
   else
   {
      values.Add(slice.Slice(0, index).ToString());
      nextIndex = index;
   }

   if (stringToSplit.Length <= index) return;
   SplitToLines(stringToSplit.Slice(nextIndex), index, ref values);
}