How to "expand" a bash variable (Included code works for bash but not zsh)

Question

An answer such as this does a good job explaining how to control passing all variables through to a command.

I wanted to explore how to do this on a per-argument basis. Observe (this was tested in zsh):

$ program() { echo 1: $1 2: $2 3: $3; }

$ run() { program "$@"; }

$ run2() { echo `run $1`; }

$ run2 'a b' c
1: a b 2: 3:

I want a way to pass a first arg which is a string that has spaces in it, and have that spliced $@style into another command. e.g. run2 "a b" c should produce 1: a 2: b 3:

At this point I have solved my immediate problem because although my test code breaks when I tested it in zsh, once implemented into an actual bash script, it works.

This does indicate that maybe this relies on some intricacies in string and argument handling that are not "safe". So this is more of a request for comment on a more robust way to achieve this behavior reliably.

Answer 1

The difference between bash and zsh that matters here is in the way run2 calls run, specifically the effect of leaving $1 unquoted.

• In zsh, run $1 applies the “remove-if-empty” operator to $1, i.e. calls run with the first argument that was passed to run2, except that if the first argument to run2 was empty (or if run2 was called with no argument), then run is called with no argument.
• In other Bourne-style shells such as bash, run $1 applies the “split+glob” operator to $1, i.e. it splits the first argument to run2 into whitespace-separated chunks¹, interprets each piece as a wildcard pattern², and replaces each wildcard pattern that matches one or more file by the list of matches.

Thus run2 'a b' c calls run with the argument a b in zsh (the argument is passed unchanged), but calls run with the two arguments a and b in bash (split into whitespace-delimited pieces).

I want a way to pass a first arg which is a string that has spaces in it, and have that spliced $@style into another command. e.g. run2 "a b" c should produce 1: a 2: b 3:

Your description and your example say different things. If you want to pass the first argument to the other command, use run "$1" to make sure that the argument is not split. Passing arguments unchanged is the whole point of "$@".

It appears that what you actually want to do is break up the first argument to run2 into whitespace-delimited chunks. In bash, you can do this by turning off wildcard expansion and then (assuming that IFS isn't changed from the default) using an unquoted expansion.

run2 () ( set -f; run $1; )

(echo "$(somecommand)" is essentially equivalent to running somecommand in a subshell, and it appears that this is what you meant rather than echo $(somecommand) which applies split+glob on the output of the command, so I removed the redundant echo-command-substitution.)

In zsh, you can use the = character in a parameter substitution to perform world splitting (and no globbing) on the value.

run2 () { run $=1; }

The syntax of zsh is not compatible with that of plain sh. If you want to source an sh script from zsh, you can use the emulate builting:

emulate sh -c '. myscript.sh'

Use emulate ksh to emulate (some features of) ksh. This doesn't emulate all bash features, but it allows you to use arrays.

¹ _{More generally, based on the value of IFS.}
² _{Unless this has been turned off with set -f.}

Answer 2

Welcome to the world of quoting and quoting surprises.

The main issue is that zsh doesn't split on IFS characters by default.
In that: it is different from all other shells.

To test how quoting change the way shells work we need code that tests both quoted and unquoted versions of your code.

Your code (adding a couple of variables):

program() { printf '%02d-1: %6s   2: %6s    3: %6s' "$i" "$1" "$2" "$3"; }
runa()  { program  "$@" ; }
run1()  { echo "`runa  $1 $2 $3 `"; }
run1    'a b' c

---

Let me expand on the details.

Let's assume that you create a local sh link pointing to where zsh lives:

ln -s "/usr/bin/zsh" ./sh

And, also, let's assume you copy the following script to a so file.

An script repeating each function with quoted and unquoted variables:

program() { printf '%02d-1: %6s   2: %6s    3: %6s' "$i" "$1" "$2" "$3"; }
runa() { program "$@"; }
runb() { program  $@ ; }

run1() { echo "`runa  "$1" "$2" "$3"`"; }
run2() { echo "`runb  "$1" "$2" "$3"`"; }
run3() { echo "`runa  $1 $2 $3`"; }
run4() { echo "`runb  $1 $2 $3`"; }

for i in `seq 4`; do
    run"$i" 'a b' c
done

Then, On execution, we get this printed:

# Any shell (except zsh) results.
01-1:    a b   2:      c    3:
02-1:      a   2:      b    3:      c
03-1:      a   2:      b    3:      c
04-1:      a   2:      b    3:      c

Only the first run (run1), where all is quoted, keeps 'a b' joined.

However, zsh acts as if all has been quoted all the time:

# ZSH results.
01-1:    a b   2:      c    3:
02-1:    a b   2:      c    3:
03-1:    a b   2:      c    3:
04-1:    a b   2:      c    3:

---

zsh in emulation.

It is supposed that zsh will emulate older shells if called as sh or ksh.
But in practice this is not always true:

$ ./sh ./so   # emulated sh
01-1:    a b   2:      c    3:
02-1:    a b   2:      c    3:
03-1:      a   2:      b    3:      c
04-1:      a   2:      b    3:      c

The second line is different than the second line for any other shell.

It is a good idea to read the answers to this question