Присоединитесь к строке с помощью разделителей

Ява (из решения Джона):

    StringBuilder sb = new StringBuilder();
    String delimiter = "";
    for (String item : items) {
        sb.append(delimiter).append(item);
        delimeter = ", ";
    }
    return sb.toString();

В Clojure вы можете просто использовать clojure.contrib.str-utils / str-join:

(str-join ", " list)

Но для фактического алгоритма:

(reduce (fn [res cur] (str res ", " cur)) list)

Из http://dogsblog.softwarehouse.co.zw/post/2009/02/11/IEnumerable-to-Comma-Separated-List- (и более) .aspx

Моя любимая ненависть при разработке состоит в создании списка идентификаторов, разделенных запятыми, это НАСТОЛЬКО просто, но всегда имеет уродливый код .... Обычные решения - циклически проходить и ставить запятую после каждого элемента, а затем удалять последний символ или иметь оператор if, чтобы проверить, есть ли у вас начало или конец списка. Ниже приведено решение, которое вы можете использовать в любом IEnumberable, то есть в List, Array и т. Д. Я также считаю, что это наиболее эффективный способ сделать это, так как он основан на присваивании, которое лучше, чем редактирование строки или использование if.

public static class StringExtensions
{
    public static string Splice<T>(IEnumerable<T> args, string delimiter)
    {
        StringBuilder sb = new StringBuilder();
        string d = "";
        foreach (T t in args)
        {
            sb.Append(d);
            sb.Append(t.ToString());
            d = delimiter;
        }
        return sb.ToString();
    }
}

Теперь его можно использовать с любым IEnumerable, например.

StringExtensions.Splice (billingTransactions.Select (t => t.id), ",")

, чтобы получить 31,32,35

это - то, как Python решает проблему:

','.join(list_of_strings)

я, никогда не имею не мог понимать потребность в 'алгоритмах' в тривиальных случаях хотя

string result = "";
foreach(string item in list)
{
    result += delimiter + item;
}
result = result.Substring(1);

Редактировать: Конечно, вы не будете использовать этот или любой из ваших алгоритмов для объединения строк. С C # / .NET вы, вероятно, будете использовать StringBuilder:

StringBuilder sb = new StringBuilder();
foreach(string item in list)
{
    sb.Append(delimiter);
    sb.Append(item);
}
string result = sb.ToString(1, sb.Length-1);

И вариант этого решения:

StringBuilder sb = new StringBuilder(list[0]);
for (int i=1; i<list.Count; i++)
{
    sb.Append(delimiter);
    sb.Append(list[i]);
}
string result = sb.ToString();

Оба решения не включают каких-либо проверок ошибок.

Вы могли записать Вашему собственному методу AppendTostring (строка, разделитель), который добавляет разделитель, если и только если строка не пуста. Тогда Вы просто называете тот метод в любом цикле, не имея необходимость волновать, когда добавить и если не добавлять.

Редактирование: еще лучше, конечно, использовать некоторый StringBuffer в методе при наличии.

В.NET я использовал бы метод String.join, если это возможно, который позволяет Вам определять разделитель и массив строк. Список может быть преобразован в массив с ToArray, но я не знаю, каков хит производительности этого был бы.

три алгоритма, которые Вы упоминаете, - то, что я использовал бы (мне нравится второе, потому что это не имеет, если оператор в нем, но если бы длина не известна, я использовал бы третье, потому что это не копирует код). Второе будет только работать, если список не будет пуст, так, чтобы мог бы взять другого если оператор.

А четвертый вариант мог бы быть должен поместить разделитель перед каждым элементом, который связывается, и затем удалите первый разделитель из результата.

при конкатенации строк в цикле обратите внимание, что для не тривиальные случаи использование stringbuilder значительно превзойдет повторенные конкатенации строк по характеристикам.

Это - Рабочее решение в C# в Java, можно использовать подобный для каждого на итераторе.

        string result = string.Empty; 

        // use stringbuilder at some stage.
        foreach (string item in list)
            result += "," + item ;

        result = result.Substring(1);
        // output:  "item,item,item"

При использовании.NET, Вы могли бы хотеть использовать дополнительный метод так, чтобы можно было сделать список. ToString ("") для получения дополнительной информации, выезд Разделитель, Разграниченные ToString для Массива, Списка, Словаря, Универсальных причин производительности IEnumerable

// contains extension methods, it must be a static class.
public static class ExtensionMethod
{
    // apply this extension to any generic IEnumerable object.
    public static string ToString<T>(this IEnumerable<T> source,
      string separator)
    {
        if (source == null)
           throw new ArgumentException("source can not be null.");

        if (string.IsNullOrEmpty(separator))
           throw new ArgumentException("separator can not be null or empty.");

        // A LINQ query to call ToString on each elements
        // and constructs a string array.
        string[] array =
         (from s in source
          select s.ToString()
          ).ToArray();

        // utilise builtin string.Join to concate elements with
        // customizable separator.
        return string.Join(separator, array);
    }
}

EDIT:For, заменяют код конкатенации строковым разработчиком решение, которое упомянуло в этом потоке.

Видел ответ Питона как 3 раза, но без Ruby?!?!?

первая часть Код объявляет новый массив. Затем вы можете просто вызвать метод .join () и передать разделитель, и он вернет строку с разделителем в середине. Я полагаю, что метод join вызывает метод .to_s для каждого элемента перед его конкатенацией.

["ID", "Description", "Active"].join(",")
>> "ID, Description, Active"

это может быть очень полезно при сочетании метапрограммирования с взаимодействием с базой данных.

Кто-нибудь знает, если в c # есть что-то похожее на этот синтаксис sugar ?

Так как вы пометили этот языковой агностик,

Вот как вы это сделаете в python

# delimiter can be multichar like "| trlalala |"
delimiter = ";"
# sequence can be any list, or iterator/generator that returns list of strings
result = delimiter.join(sequence)
#result will NOT have ending delimiter 

Редактировать: Я вижу, что получил ответ несколькими людьми. Извините за дублирование

В C# можно просто использовать Строка. Соединение (разделитель, string_list)

Проблема в том, что компьютерные языки редко имеют строковые логические значения, то есть методы типа string, которые делают что-нибудь полезное. По крайней мере, SQL Server имеет значение [not] null и nullif, что при объединении решает проблему с разделителем, кстати: isnotnull (nullif (columnvalue, ""), "," + columnvalue))

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

concatstring = string1 + "," + string2; if (fubar) concatstring + = string3 concatstring + = string4 и т. д.

Я очень старался избежать всего этого уродства, играя в запятые и объединяясь с соединениями, но я все еще остаюсь с некоторыми из них, включая Ошибки SQL Server, когда я пропустил одну из запятых, а переменная пуста.

Джонатан

Я бы выразил это рекурсивно.

• Проверьте, равно ли число строковых аргументов 1. Если это так, верните его.
• В противном случае рекурсивно, но объедините первые два аргумента с разделителем между ними.

Пример в Common Lisp:

(defun join (delimiter &rest strings)
  (if (null (rest strings))
      (first strings)
      (apply #'join
             delimiter
             (concatenate 'string
                          (first strings)
                          delimiter
                          (second strings))
             (cddr strings))))

Более идиоматический способ - использовать reduce, но это расширяет почти до тех же самых инструкций, что и выше:

(defun join (delimiter &rest strings)
  (reduce (lambda (a b)
            (concatenate 'string a delimiter b))
          strings))

Я всегда добавлял бы разделитель и затем удалял бы его в конце при необходимости. Таким образом, Вы не выполняетесь, если оператор для каждого повторения цикла, когда Вы только заботитесь о выполнении работы однажды.

StringBuilder sb = new StringBuilder();

foreach(string item in list){
    sb.Append(item);
    sb.Append(delimeter);
}

if (list.Count > 0) {
    sb.Remove(sb.Length - delimter.Length, delimeter.Length)
}

В PHP's интегрируются () :

$string = implode($delim, $array);

Для Python быть уверенными у Вас есть список строк, еще', '.join (x) перестанет работать. Для надежного метода с помощью 2,5 +

delimiter = '","'
delimiter.join(str(a) if a else '' for a in list_object)

"ул. (a), если еще' '" не хорошо ни для Одного, вводит иначе ул. (), заканчивает тем, что не делал тогда 'Ни один', что не хорошо;)

Существует мало причины сделать это агностиком языка, когда некоторые языки оказывают поддержку для этого в одной строке, например, Python

",".join(sequence)

Видит документация соединения для большего количества информации

В.NET можно использовать эти Строка. Метод соединения :

string concatenated = String.Join(",", list.ToArray());

Используя Отражатель.NET , мы можем узнать, как он делает это:

public static unsafe string Join(string separator, string[] value, int startIndex, int count)
{
    if (separator == null)
    {
        separator = Empty;
    }
    if (value == null)
    {
        throw new ArgumentNullException("value");
    }
    if (startIndex < 0)
    {
        throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_StartIndex"));
    }
    if (count < 0)
    {
        throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NegativeCount"));
    }
    if (startIndex > (value.Length - count))
    {
        throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_IndexCountBuffer"));
    }
    if (count == 0)
    {
        return Empty;
    }
    int length = 0;
    int num2 = (startIndex + count) - 1;
    for (int i = startIndex; i <= num2; i++)
    {
        if (value[i] != null)
        {
            length += value[i].Length;
        }
    }
    length += (count - 1) * separator.Length;
    if ((length < 0) || ((length + 1) < 0))
    {
        throw new OutOfMemoryException();
    }
    if (length == 0)
    {
        return Empty;
    }
    string str = FastAllocateString(length);
    fixed (char* chRef = &str.m_firstChar)
    {
        UnSafeCharBuffer buffer = new UnSafeCharBuffer(chRef, length);
        buffer.AppendString(value[startIndex]);
        for (int j = startIndex + 1; j <= num2; j++)
        {
            buffer.AppendString(separator);
            buffer.AppendString(value[j]);
        }
    }
    return str;
}

Я думаю, что лучший способ сделать что-то подобное (я буду использовать псевдокод, поэтому мы сделаем его по-настоящему независимым от языка):

function concat(<array> list, <boolean> strict):
  for i in list:
    if the length of i is zero and strict is false:
      continue;
    if i is not the first element:
      result = result + separator;
    result = result + i;
  return result;

второй аргумент для concat() , strict, является флагом, чтобы знать, нужно ли рассматривать возможные пустые строки в конкатенации или нет.

Я привык не рассматривать добавление окончательного разделителя; с другой стороны, если для параметра false задано значение false, то в результирующей строке может отсутствовать что-то вроде «A, B ,,, F», при условии, что разделитель является запятой, но вместо этого будет представлен как «A, B, F».

Для java очень полный ответ был дан в этом вопросе или в этом вопросе .

То есть используйте StringUtils.join в Apache Commons

String result = StringUtils.join(list, ", ");

Groovy также имеет метод String Object.join (String).