How can I join elements of an array in Bash?


If I have an array like this in Bash:

FOO=( a b c )

How do I join the elements with commas? For example, producing a,b,c.


A 100% pure Bash function that supports multi-character delimiters is:

function join_by { local d=${1-} f=${2-}; if shift 2; then printf %s "$f" "${@/#/$d}"; fi; }

For example,

join_by , a b c #a,b,c
join_by ' , ' a b c #a , b , c
join_by ')|(' a b c #a)|(b)|(c
join_by ' %s ' a b c #a %s b %s c
join_by $'n' a b c #a<newline>b<newline>c
join_by - a b c #a-b-c
join_by '' a b c #abc
join_by '-n' '-e' '-E' '-n' #-e-n-E-n-n
join_by , #
join_by , a #a

The code above is based on the ideas by @gniourf_gniourf, @AdamKatz, @MattCowell, and @x-yuri. It works with options errexit (set -e) and nounset (set -u).

Alternatively, a simpler function that supports only a single character delimiter, would be:

function join_by { local IFS="$1"; shift; echo "$*"; }

For example,

join_by , a "b c" d #a,b c,d
join_by / var local tmp #var/local/tmp
join_by , "${FOO[@]}" #a,b,c

This solution is based on Pascal Pilz’s original suggestion.

A detailed explanation of the solutions previously proposed here can be found in “How to join() array elements in a bash script”, an article by meleu at


Yet another solution:

foo=('foo bar' 'foo baz' 'bar baz')
bar=$(printf ",%s" "${foo[@]}")

echo $bar

Edit: same but for multi-character variable length separator:

separator=")|(" # e.g. constructing regex, pray it does not contain %s
foo=('foo bar' 'foo baz' 'bar baz')
regex="$( printf "${separator}%s" "${foo[@]}" )"
regex="${regex:${#separator}}" # remove leading separator
echo "${regex}"
# Prints: foo bar)|(foo baz)|(bar baz


$ foo=(a "b c" d)
$ bar=$(IFS=, ; echo "${foo[*]}")
$ echo "$bar"
a,b c,d


Maybe, e.g.,


echo "$FOOJOIN"


Surprisingly my solution is not yet given 🙂 This is the simplest way for me. It doesn’t need a function:

IFS=, eval 'joined="${foo[*]}"'

Note: This solution was observed to work well in non-POSIX mode. In POSIX mode, the elements are still joined properly, but IFS=, becomes permanent.


Using no external commands:

$ FOO=( a b c )     # initialize the array
$ BAR=${FOO[@]}     # create a space delimited string from array
$ BAZ=${BAR// /,}   # use parameter expansion to substitute spaces with comma
$ echo $BAZ

Warning, it assumes elements don’t have whitespaces.


This isn’t all too different from existing solutions, but it avoids using a separate function, doesn’t modify IFS in the parent shell and is all in a single line:

arr=(a b c)
printf '%sn' "$(IFS=,; printf '%s' "${arr[*]}")"

resulting in


Limitation: the separator can’t be longer than one character.

This could be simplified to just

(IFS=,; printf '%s' "${arr[*]}")

at which point it’s basically the same as Pascal’s answer, but using printf instead of echo, and printing the result to stdout instead of assigning it to a variable.


Here’s a 100% pure Bash function that does the job:

join() {
    # $1 is return variable name
    # $2 is sep
    # $3... are the elements to join
    local retname=$1 sep=$2 ret=$3
    shift 3 || shift $(($#))
    printf -v "$retname" "%s" "$ret${@/#/$sep}"


$ a=( one two "three three" four five )
$ join joineda " and " "${a[@]}"
$ echo "$joineda"
one and two and three three and four and five
$ join joinedb randomsep "only one element"
$ echo "$joinedb"
only one element
$ join joinedc randomsep
$ echo "$joinedc"

$ a=( $' stuff withnnewlinesn' $'and trailing newlinesnn' )
$ join joineda $'a sep withnnewlinesn' "${a[@]}"
$ echo "$joineda"
 stuff with
a sep with
and trailing newlines


This preserves even the trailing newlines, and doesn’t need a subshell to get the result of the function. If you don’t like the printf -v (why wouldn’t you like it?) and passing a variable name, you can of course use a global variable for the returned string:

join() {
    # $1 is sep
    # $2... are the elements to join
    # return is in global variable join_ret
    local sep=$1 IFS=
    shift 2 || shift $(($#))


I would echo the array as a string, then transform the spaces into line feeds, and then use paste to join everything in one line like so:

tr " " "n" <<< "$FOO" | paste -sd , -



This seems to be the quickest and cleanest to me !


With re-use of @doesn’t matters’ solution, but with a one statement by avoiding the ${:1} substition and need of an intermediary variable.

echo $(printf "%s," "${LIST[@]}" | cut -d "," -f 1-${#LIST[@]} )

printf has ‘The format string is reused as often as necessary to satisfy the arguments.’ in its man pages, so that the concatenations of the strings is documented. Then the trick is to use the LIST length to chop the last sperator, since cut will retain only the lenght of LIST as fields count.


s=$(IFS=, eval 'echo "${FOO[*]}"')


printf solution that accept separators of any length (based on @doesn’t matters answer)

foo=('foo bar' 'foo baz' 'bar baz')

sep=',' # can be of any length
bar=$(printf "${sep}%s" "${foo[@]}")

echo $bar


Shorter version of top answer:

joinStrings() { local a=("${@:3}"); printf "%s" "$2${a[@]/#/$1}"; }


joinStrings "$myDelimiter" "${myArray[@]}"


Thanks @gniourf_gniourf for detailed comments on my combination of best worlds so far. Sorry for posting code not thoroughly designed and tested. Here is a better try.

# join with separator
join_ws() { local d=$1 s=$2; shift 2 && printf %s "$s${@/#/$d}"; }

This beauty by conception is

Additional examples:

$ join_ws '' a b c
$ join_ws ':' {1,7}{A..C}
$ join_ws -e -e
$ join_ws $'33[F' $'nnn'  1.  2.  3.  $'nnnn'
$ join_ws $ 


$ set a 'b c' d

$ history -p "[email protected]" | paste -sd,
a,b c,d


Combine best of all worlds so far with following idea.

# join with separator
join_ws()  { local IFS=; local s="${*/#/$1}"; echo "${s#"$1$1$1"}"; }

This little masterpiece is


$ join_ws , a b c
$ join_ws '' a b c
$ join_ws $'n' a b c
$ join_ws ' / ' A B C
A / B / C


Here’s a single liner that is a bit weird but works well for multi-character delimiters and supports any value (including containing spaces or anything):

ar=(abc "foo bar" 456)
delim=" | "
printf "%sn$delimn" "${ar[@]}" | head -n-1 | paste -sd ''

This would show in the console as

abc | foo bar | 456

Note: Notice how some solutions use printf with ${ar[*]} and some with ${ar[@]}?

The ones with @ use the printf feature that supports multiple arguments by repeating the format template.

The ones with * should not be used. They do not actually need printfand rely on manipulating the field separator and bash’s word expansion. These would work just as well with echo, cat, etc. – these solutions likely use printf because the author doesn’t really understand what they are doing…


x=${arr[*]// /,}

This is the shortest way to do it.


# ZSH:
arr=(1 "2 3" 4 5)
x=${"${arr[*]}"// /,}
echo $x  # output: 1,2,3,4,5

arr=(1 "2 3" 4 5)
x=${a// /,}
echo $x  # output: 1,2,3,4,5


Many, if not most, of these solutions rely on arcane syntax, brain-busting regex tricks, or calls to external executables. I would like to propose a simple, bash-only solution that is very easy to understand, and only slightly sub-optimal, performance-wise.

join_by () {
    # Argument #1 is the separator. It can be multi-character.
    # Argument #2, 3, and so on, are the elements to be joined.
    # Usage: join_by ", " "${array[@]}"
    local SEPARATOR="$1"

    local F=0
    for x in "[email protected]"
        if [[ F -eq 1 ]]
            echo -n "$SEPARATOR"
        echo -n "$x"


$ a=( 1 "2 2" 3 )
$ join_by ", " "${a[@]}"
1, 2 2, 3

I’d like to point out that any solution that uses /usr/bin/[ or /usr/bin/printf is inherently slower than my solution, since I use 100% pure bash. As an example of its performance, Here’s a demo where I create an array with 1,000,000 random integers, then join them all with a comma, and time it.

$ eval $(echo -n "a=("; x=0 ; while [[ x -lt 1000000 ]]; do echo -n " $RANDOM" ; x=$((x+1)); done; echo " )")
$ time join_by , ${a[@]} >/dev/null
real    0m8.590s
user    0m8.591s
sys     0m0.000s


Right now I’m using:

    E201 # Whitespace after '('
    E301 # Expected N blank lines, found M
    E303 # Too many blank lines (pep8 gets confused by comments)
ARGS="--ignore `echo ${TO_IGNORE[@]} | tr ' ' ','`"

Which works, but (in the general case) will break horribly if array elements have a space in them.

(For those interested, this is a wrapper script around


My attempt.

$ array=(one two "three four" five)
$ echo "${array[0]}$(printf " SEP %s" "${array[@]:1}")"
one SEP two SEP three four SEP five


Use perl for multicharacter separators:

function join {
   perl -e '$s = shift @ARGV; print join($s, @ARGV);' "[email protected]"; 

join ', ' a b c # a, b, c

Or in one line:

perl -le 'print join(shift, @ARGV);' ', ' 1 2 3
1, 2, 3


If you build the array in a loop, here is a simple way:

for x in $(some_cmd); do
echo ${arr[*]}


In case the elements you want to join is not an array just a space separated string, you can do something like this:

foo="aa bb cc dd"
bar=`for i in $foo; do printf ",'%s'" $i; done`
echo $bar

for example, my use case is that some strings are passed in my shell script and I need to use this to run on a SQL query:

./my_script "aa bb cc dd"

In my_script, I need to do “SELECT * FROM table WHERE name IN (‘aa’,’bb’,’cc’,’dd’). Then above command will be useful.


Using variable indirection to refer directly to an array also works. Named references can also be used, but they only became available in 4.3.

The advantage of using this form of a function is that you can have the separator optional (defaults to the first character of default IFS, which is a space; perhaps make it an empty string if you like), and it avoids expanding values twice (first when passed as parameters, and second as "[email protected]" inside the function).

This solution also doesn’t require the user to call the function inside a command substitution – which summons a subshell, to get a joined version of a string assigned to another variable.

function join_by_ref {
    local __r=$1[@] __s=${2-' '}
    printf -v __ "${__s//%/%%}%s" "${!__r}"

array=(1 2 3 4)

join_by_ref array
echo "$__" # Prints '1 2 3 4'.

join_by_ref array '%s'
echo "$__" # Prints '1%s2%s3%s4'.

join_by_ref 'invalid*' '%s' # Bash 4.4 shows "invalid*[@]: bad substitution".
echo "$__" # Prints nothing but newline.

Feel free to use a more comfortable name for the function.

This works from 3.1 to 5.0-alpha. As observed, variable indirection doesn’t only work with variables but with other parameters as well.

A parameter is an entity that stores values. It can be a name, a
number, or one of the special characters listed below under Special
Parameters. A variable is a parameter denoted by a name.

Arrays and array elements are also parameters (entities that store value), and references to arrays are technically references to parameters as well. And much like the special parameter @, array[@] also makes a valid reference.

Altered or selective forms of expansion (like substring expansion) that deviate reference from the parameter itself no longer work.


In the release version of Bash 5.0, variable indirection is already called indirect expansion and its behavior is already explicitly documented in the manual:

If the first character of parameter is an exclamation point (!), and
parameter is not a nameref, it introduces a level of indirection.
Bash uses the value formed by expanding the rest of parameter as the
new parameter; this is then expanded and that value is used in the
rest of the expansion, rather than the expansion of the original
parameter. This is known as indirect expansion.

Taking note that in the documentation of ${parameter}, parameter is referred to as “a shell parameter as described (in) PARAMETERS or an array reference“. And in the documentation of arrays, it is mentioned that “Any element of an array may be referenced using ${name[subscript]}“. This makes __r[@] an array reference.

Join by arguments version

See my comment in Riccardo Galli’s answer.


This approach takes care of spaces within the values, but requires a loop:


FOO=( a b c )

for index in ${!FOO[*]}
echo ${BAR:1}


Perhaps I’m missing something obvious, since I’m a newb to the whole bash/zsh thing, but it looks to me like you don’t need to use printf at all. Nor does it get really ugly to do without.

join() {
  arr=${arr:2} # throw away separator and following space
  arr=${arr// /$separator}

At least, it has worked for me thus far without issue.

For instance, join | *.sh, which, let’s say I’m in my ~ directory, outputs|| Good enough for me.

EDIT: This is basically Nil Geisweiller’s answer, but generalized into a function.


Here’s one that most POSIX compatible shells support:

join_by() {
    # Usage:  join_by "||" a b c d
    local arg arr=() sep="$1"
    for arg in "[email protected]"; do
        if [ 0 -lt "${#arr[@]}" ]; then
        arr+=("${arg}") || break
    printf "%s" "${arr[@]}"


Perhaps late for the party, but this works for me:

function joinArray() {
  local delimiter="${1}"
  local output="${2}"
  for param in ${@:3}; do

  echo "${output}"


I believe this is the shortest solution, as Benamin W. already mentioned:

(IFS=,; printf %s "${a[*]}")

Wanted to add that if you use zsh, you can drop the subshell:

IFS=, printf %s "${a[*]}"


a=(1 'a b' 3)
IFS=, printf %s "${a[*]}"
1,a b,3

Leave a Comment