Как разбить строку на строки и включить разделители с помощью .NET?

Ответ 1

Несмотря на нежелание использовать регулярное выражение, он действительно красиво сохраняет разделители, используя группу вместе с методом Regex.Split:

string input = "123xx456yy789";
string pattern = "(xx|yy)";
string[] result = Regex.Split(input, pattern);

Если вы удалите круглые скобки из шаблона, используя только "xx|yy", разделители не будут сохранены. Обязательно используйте Regex.Escape в шаблоне, если вы используете какие-либо метасимволы, которые имеют особое значение в регулярном выражении. Символы включают \, *, +, ?, |, {, [, (,), ^, $,., #. Например, разделитель . должен быть экранирован \.. Учитывая список разделителей, вам нужно "ИЛИ" использовать их с помощью символа pipe |, и это тоже символ, который сбрасывается. Для правильной сборки шаблона используйте следующий код (благодаря @gabe для указания этого):

var delimiters = new List<string> { ".", "xx", "yy" };
string pattern = "(" + String.Join("|", delimiters.Select(d => Regex.Escape(d))
                                                  .ToArray())
                  + ")";

Скобки скопированы, а не включены в шаблон, поскольку они были бы неправильно экранированы для ваших целей.

EDIT: Кроме того, если список 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)

РЕДАКТИРОВАТЬ № 2: решение до сих пор соответствует разным токенам, которые могут быть подстрокой большей строки. Если разделительный токен должен быть полностью сопоставлен, а не часть подстроки, например сценарий, в котором слова в предложении используются в качестве разделителей, тогда метасимвол текста \b должен быть добавлен вокруг шаблона.

Например, рассмотрим это предложение (да, оно банально): "Welcome to stackoverflow... where the stack never overflows!"

Если разделители были { "stack", "flow" }, текущее решение разделило бы "stackoverflow" и вернет 3 строки { "stack", "over", "flow" }. Если вам нужно точное совпадение, тогда единственное место, которое было бы разделено, было бы в слове "стек" позже в предложении, а не "stackoverflow".

Чтобы добиться точного совпадения, измените шаблон, включив \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 следующим образом:

string pattern = @"\s*\b("
                + String.Join("|", delimiters.Select(d => Regex.Escape(d)))
                + @")\b\s*";

Ответ 2

Хорошо, извините, может быть, этот:

    string source = "123xx456yy789";
    foreach (string delimiter in delimiters)
        source = source.Replace(delimiter, ";" + delimiter + ";");
    string[] parts = source.Split(';');

Ответ 3

Здесь решение, которое не использует регулярное выражение и не делает больше строк, чем необходимо:

public static List<string> Split(string searchStr, string[] separators)
{
    List<string> result = new List<string>();
    int length = searchStr.Length;
    int lastMatchEnd = 0;
    for (int i = 0; i < length; i++)
    {
        for (int j = 0; j < separators.Length; j++)
        {
            string str = separators[j];
            int sepLen = str.Length;
            if (((searchStr[i] == str[0]) && (sepLen <= (length - i))) && ((sepLen == 1) || (String.CompareOrdinal(searchStr, i, str, 0, sepLen) == 0)))
            {
                result.Add(searchStr.Substring(lastMatchEnd, i - lastMatchEnd));
                result.Add(separators[j]);
                i += sepLen - 1;
                lastMatchEnd = i + 1;
                break;
            }
        }
    }
    if (lastMatchEnd != length)
        result.Add(searchStr.Substring(lastMatchEnd));
    return result;
}

Ответ 4

Я придумал решение для чего-то похожего назад. Чтобы эффективно разбить строку, вы можете сохранить список следующего события каждого разделителя. Таким образом, вы минимизируете время, необходимое для поиска каждого разделителя.

Этот алгоритм будет хорошо работать даже для длинной строки и большого количества разделителей:

string input = "123xx456yy789";
string[] delimiters = { "xx", "yy" };

int[] nextPosition = delimiters.Select(d => input.IndexOf(d)).ToArray();
List<string> result = new List<string>();
int pos = 0;
while (true) {
  int firstPos = int.MaxValue;
  string delimiter = null;
  for (int i = 0; i < nextPosition.Length; i++) {
    if (nextPosition[i] != -1 && nextPosition[i] < firstPos) {
      firstPos = nextPosition[i];
      delimiter = delimiters[i];
    }
  }
  if (firstPos != int.MaxValue) {
    result.Add(input.Substring(pos, firstPos - pos));
    result.Add(delimiter);
    pos = firstPos + delimiter.Length;
    for (int i = 0; i < nextPosition.Length; i++) {
      if (nextPosition[i] != -1 && nextPosition[i] < pos) {
        nextPosition[i] = input.IndexOf(delimiters[i], pos);
      }
    }
  } else {
    result.Add(input.Substring(pos));
    break;
  }
}

(С резервированием для любых ошибок я просто бросил эту версию вместе сейчас, и я не тестировал ее полностью).

Ответ 5

Наивная реализация

public IEnumerable<string> SplitX (string text, string[] delimiters)
{
    var split = text.Split (delimiters, StringSplitOptions.None);

    foreach (string part in split) {
        yield return part;
        text = text.Substring (part.Length);

        string delim = delimiters.FirstOrDefault (x => text.StartsWith (x));
        if (delim != null) {
            yield return delim;
            text = text.Substring (delim.Length);
        }
    }
}

Ответ 6

Это будет иметь идентичную семантику в режиме String.Split по умолчанию (поэтому не включая пустые токены).

Это можно сделать быстрее, используя небезопасный код для итерации по исходной строке, хотя для этого требуется написать механизм итерации самостоятельно, а не использовать возврат доходности. Он выделяет абсолютный минимум (подстрока на токен без разделителя плюс обтекающий перечислитель), так что реально повысить производительность, которую вам нужно:

• используйте еще более небезопасный код (используя "CompareOrdinal", я действительно есть)
  • главным образом, во избежание накладных расходов на поиск символов в строке с буфером char
• использовать знания, специфичные для домена, о входных источниках или токенах.
  • вы можете быть счастливы устранить нулевую проверку разделителей
  • вы можете знать, что разделители почти не являются индивидуальными символами.

Код записывается как метод расширения

public static IEnumerable<string> SplitWithTokens(
    string str,
    string[] separators)
{
    if (separators == null || separators.Length == 0)
    {
        yield return str;
        yield break;
    }
    int prev = 0;
    for (int i = 0; i < str.Length; i++)
    {
        foreach (var sep in separators)
        {
            if (!string.IsNullOrEmpty(sep))
            {
                if (((str[i] == sep[0]) && 
                          (sep.Length <= (str.Length - i))) 
                     &&
                    ((sep.Length == 1) || 
                    (string.CompareOrdinal(str, i, sep, 0, sep.Length) == 0)))
                {
                    if (i - prev != 0)
                        yield return str.Substring(prev, i - prev);
                    yield return sep;
                    i += sep.Length - 1;
                    prev = i + 1;
                    break;
                }
            }
        }
    }
    if (str.Length - prev > 0)
        yield return str.Substring(prev, str.Length - prev);
}

Ответ 7

Мой первый пост/ответ... это рекурсивный подход.

    static void Split(string src, string[] delims, ref List<string> final)
    {
        if (src.Length == 0)
            return;

        int endTrimIndex = src.Length;
        foreach (string delim in delims)
        {
            //get the index of the first occurance of this delim
            int indexOfDelim = src.IndexOf(delim);
            //check to see if this delim is at the begining of src
            if (indexOfDelim == 0)
            {
                endTrimIndex = delim.Length;
                break;
            }
            //see if this delim comes before previously searched delims
            else if (indexOfDelim < endTrimIndex && indexOfDelim != -1)
                endTrimIndex = indexOfDelim;
        }
        final.Add(src.Substring(0, endTrimIndex));
        Split(src.Remove(0, endTrimIndex), delims, ref final);
    }