Joining bash arguments into single string with spaces

Question

I'm trying to join all of the arguments to a Bash function into one single string with spaces separating each argument. I also need to have the string include single quotes around the whole string.

Here is what I have so far...

$array=("$@")
str="\'"
for arg in "${array[@]}"; do
    let $str=$str+$arg+" "
done
let $str=$str+"\'"

Obviously this does not work but I'm wondering if there is a way to achieve this?

Answer 1

I believe that this does what you want. It will put all the arguments in one string, separated by spaces, with single quotes around all:

str="'$*'"

$* produces all the scripts arguments separated by the first character of $IFS which, by default, is a space.

Inside a double quoted string, there is no need to escape single-quotes.

Example

Let us put the above in a script file:

$ cat script.sh 
#!/bin/sh
str="'$*'"
echo "$str"

Now, run the script with sample arguments:

$ sh script.sh one two three four 5
'one two three four 5'

This script is POSIX. It will work with bash but it does not require bash.

A variation: concatenating with slashes instead of spaces

We can change from spaces to another character by adjusting IFS:

$ cat script.sh 
#!/bin/sh
old="$IFS"
IFS='/'
str="'$*'"
echo "$str"
IFS=$old

For example:

$ sh script.sh one two three four       
'one/two/three/four'

Answer 2

It's easier than you think:

#!/bin/bash
array="${@}"

echo $array

chmod +x that, and run it:

$ ./example.sh --foo bar -b az 
--foo bar -b az

Answer 3

update Tl;dr, use

"'${array[*]}'"

To be clear, I don't intend to replicate this answer. I just found there are minor differences to use @ and * to dereference all values from an array.

Under the hood, $* and $@ are all arrays, referring to the argv list.

From the question,

I'm trying to join all of the arguments to a Bash function into one single string with spaces separating each argument.

It has 2 sub-questions:

1. concatenate the array input arguments into a string.
2. pass the concatenated string as a single argument for the shell function.

First, concat array into a string,

array=("$@")
str="'${array[@]}'"
# or
str="'${array[*]}'"
# or
str=\'"${array[*]}"\'

Second, when you pass str to a function, let's count the number of arguments that function received,

#!/usr/bin/env bash

arr=(a b c d)

function count_args() {
  echo '$#' $#
}

count_args "'${arr[@]}'"
count_args \'"${arr[@]}"\'
count_args "'${arr[*]}'"
count_args \'"${arr[*]}"\'

output is

$# 4
$# 4
$# 1
$# 1

only arr[*] wraps the array into 1 argument for the shell function, why?

Cite from How to use arrays in bash script, which I found it's useful for me,

echo ${array[*]}
echo ${array[@]}

Both syntax let us access all the values of the array and produce the same results, unless the expansion it's quoted. In this case a difference arises: in the first case, when using @, the expansion will result in a word for each element of the array.

Whereas using * will group the entire array into one single argument during expansion.

Answer 4

This is what I use:

_shlexjoin() {
  echo ${*@Q}
}

Bash feature	Action
Special parameter $*, unquoted	"Each positional parameter expands to a separate word"
${parameter@operator} using Q operator	Each parameter is "quoted in a format that can be reused as input"

Creating shell command strings

Useful for joining multiple arguments into a single string when you want to run them through a sh -c command.

Before:

cat 'aw ful".txt'
# Output: Hello world!

After:

command_string=$(_shlexjoin cat 'aw ful".txt')
sh -c "${command_string}"
# Output: Hello world!

Printing runnable commands or writing commands to scripts

Before printing ${command_string} to your terminal or writing it to a script, you'll need to escape it again, which you can do by running it through the same function:

inception=$(_shlexjoin "${command_string}")
echo "sh -c ${inception}"
# Output: sh -c ''\''cat'\'' '\''aw ful".txt'\'''

Ugly. Reliable. Just how I like it. :-)

Debugging

If, on the other hand, you just need to see how the arguments are being split, it's way easier to use something like this:

_dumpargs() {
  printf '[%s]' "$@"
  printf '\n'
} >&2

_dumpargs one two three                      # [one][two][three]
_dumpargs one 'two three'                    # [one][two three]
_dumpargs one two\ three                     # [one][two three]
_dumpargs cat 'aw ful".txt'                  # [cat][aw ful".txt]
_dumpargs "$(_shlexjoin cat 'aw ful".txt')"  # ['cat' 'aw ful".txt']
                          # One arg, looks like two ^

Non-Bash alternatives

You mention bash, but if you want a functionally equivalent solution that is not bash-specific and you don't mind creating processes, you can use printf's %q format:

_shlexjoin_pr() {
  printf ' %q' "$@" | cut -b2-
}

Or if python's handy, you could do this:

_shlexjoin_py() {
  python3 -c 'import sys,shlex;print(shlex.join(sys.argv[1:]))' "$@"
}

They each work differently, but they are functionally equivalent:

_shlexjoin    one 'two three'  # Output: 'one' 'two three'
_shlexjoin_pr one 'two three'  # Output: one two\ three
_shlexjoin_py one 'two three'  # Output: one 'two three'