Logo

Programming-Idioms

This language bar is your friend. Select your favorite languages!

Idiom #53 Join a list of strings

Concatenate elements of string list x joined by the separator ", " to create a single string y.

Turning the strings "eggs", "butter", "milk" into the string "eggs, butter, milk" 
(setf y (format nil "~{~a~^,~}" x))
(defvar y (format nil "~{~A~^, ~}" x))
(setf y (reduce (lambda (a b)
                   (concatenate 'string a ", " b))
                 x))
with Ada.Containers.Indefinite_Vectors; use Ada.Containers;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
declare
   Last : Cursor := X.Last;
   Y : Unbounded_String;
         
begin
   for C in X.Iterate loop
      Y := Y & Element (C) & (if C = Last then "" else ", ");
   end loop;
end;
#include <string.h>
#define DELIM ", "
#define L 64

char y[L] = {'\0'};

for (int i = 0; i < N; ++i)
{
    if (i && x[i][0])
        strcat(y, DELIM);
    
    strcat(y, x[i]);
}
(clojure.string/join "," '("abc" "def" "ghi") )
#include <numeric>
#include <string>
string d {", "};
auto f = [&d] (auto& a, auto& b) {
    return a + d + b;
};
string y {
    x[0] +
    reduce(begin(x) + 1, end(x), ""s, f)
};
#include <string>
#include <vector>
#include <ranges>
using namespace std::ranges;
y = x | views::join_with(',') | to<std::string>();
#include <string>
#include <vector>
#include <sstream>
#include <iterator>
std::vector<std::string> x;
std::string y;
const char* const delim = ", ";

switch (x.size())
{
	case 0: y = "";   break;
	case 1: y = x[0]; break;
	default:
		std::ostringstream os;
		std::copy(x.begin(), x.end() - 1,
			std::ostream_iterator<std::string>(os, delim));
		os << *x.rbegin();
		y = os.str();
}
string y = string.Join(", ", x);
import std.array;
string y = x.join(", ");
y = x.join(', ');
y = Enum.join(x, ", ")
Y = string:join(X, ",").
  write (unit=y,fmt='(*(A,:,", "))') x


import "strings"
y := strings.Join(x, ", ")
String y = x.join(', ')
import Data.List
y = intercalate ", " x
import qualified Data.Text as T
{-# LANGUAGE OverloadedStrings #-}
y :: T.Text
y = T.intercalate ", " x
y = x.join(", ");
String y = x.stream()
    .reduce((a, b) -> a + ", " + b)
    .get();
String y = x.get(0);
int i = 1, n = x.size();
while (i < n)
    y = y + ", " + x.get(i++);
String y = String.join(", ", x);
val y = listOf(x).joinToString(", ")
y = table.concat(x, ", ")
@import Foundation;
NSString y=[x componentsJoinedByString:@", "];
$y = implode(', ', $x);
var
  _x: Array of string;
  _y: String;
  i: Integer;
begin
  _y := ''; //initialize result to an empy string
  // assume _x is initialized to contain some values
  for i := Low(_x) to High(_x) do
  begin
    _y := _y + _x[i];
    if i < High(_x) then _y := _y + ';';
  end;
end;
$y = join(", ", @x)
y = ', '.join(map(str, x))
from functools import reduce
y = reduce(lambda y, x: f'{y}, {x}', x)
y = ', '.join(x)

def join(array, sep=', '):
    def f(value, *args):
        if not args:
            return str(value)
        return f'{value}{sep}' + f(*args)
    return f(*array)
y = join(x)
y = x.join(", ")
let y = x.join(", ");
val y = x.mkString(",")
(define y
  (foldr (lambda (a b)
           (if (string=? b "")
               a
               (string-append a ", " b)))
         ""
         x))
y := x joinSeparatedBy: ', '.
', ' join: #('abc' 'def' 'ghi')
Dim x = {"a", "b", "c", "d"}.ToList
Dim y = String.Join(",", x)
New implementation...
< > ⌨
programming-idioms.org 
(setf y (format nil "~{~a~^,~}" x))
(defvar y (format nil "~{~A~^, ~}" x))
(setf y (reduce (lambda (a b)
                   (concatenate 'string a ", " b))
                 x))
declare
   Last : Cursor := X.Last;
   Y : Unbounded_String;
         
begin
   for C in X.Iterate loop
      Y := Y & Element (C) & (if C = Last then "" else ", ");
   end loop;
end;
#define DELIM ", "
#define L 64

char y[L] = {'\0'};

for (int i = 0; i < N; ++i)
{
    if (i && x[i][0])
        strcat(y, DELIM);
    
    strcat(y, x[i]);
}
(clojure.string/join "," '("abc" "def" "ghi") )
string d {", "};
auto f = [&d] (auto& a, auto& b) {
    return a + d + b;
};
string y {
    x[0] +
    reduce(begin(x) + 1, end(x), ""s, f)
};
y = x | views::join_with(',') | to<std::string>();
std::vector<std::string> x;
std::string y;
const char* const delim = ", ";

switch (x.size())
{
	case 0: y = "";   break;
	case 1: y = x[0]; break;
	default:
		std::ostringstream os;
		std::copy(x.begin(), x.end() - 1,
			std::ostream_iterator<std::string>(os, delim));
		os << *x.rbegin();
		y = os.str();
}
string y = string.Join(", ", x);
string y = x.join(", ");
y = x.join(', ');
y = Enum.join(x, ", ")
Y = string:join(X, ",").
  write (unit=y,fmt='(*(A,:,", "))') x


y := strings.Join(x, ", ")
String y = x.join(', ')
y = intercalate ", " x
{-# LANGUAGE OverloadedStrings #-}
y :: T.Text
y = T.intercalate ", " x
y = x.join(", ");
String y = x.stream()
    .reduce((a, b) -> a + ", " + b)
    .get();
String y = x.get(0);
int i = 1, n = x.size();
while (i < n)
    y = y + ", " + x.get(i++);
String y = String.join(", ", x);
val y = listOf(x).joinToString(", ")
y = table.concat(x, ", ")
NSString y=[x componentsJoinedByString:@", "];
$y = implode(', ', $x);
var
  _x: Array of string;
  _y: String;
  i: Integer;
begin
  _y := ''; //initialize result to an empy string
  // assume _x is initialized to contain some values
  for i := Low(_x) to High(_x) do
  begin
    _y := _y + _x[i];
    if i < High(_x) then _y := _y + ';';
  end;
end;
$y = join(", ", @x)
y = ', '.join(map(str, x))
y = reduce(lambda y, x: f'{y}, {x}', x)
y = ', '.join(x)

def join(array, sep=', '):
    def f(value, *args):
        if not args:
            return str(value)
        return f'{value}{sep}' + f(*args)
    return f(*array)
y = join(x)
y = x.join(", ")
let y = x.join(", ");
val y = x.mkString(",")
(define y
  (foldr (lambda (a b)
           (if (string=? b "")
               a
               (string-append a ", " b)))
         ""
         x))
y := x joinSeparatedBy: ', '.
', ' join: #('abc' 'def' 'ghi')
Dim x = {"a", "b", "c", "d"}.ToList
Dim y = String.Join(",", x)