为什么用`printf`加入数组会在终端和脚本中给出不同的结果？

Question

I was trying to write a script which involved printing an array with a delimiter. Unfortunately, the printf command that worked typing into the command line did not work when run as a script. It also seems that bash and zsh handle things differently.

This gives the intended output, it works if I just paste directly into the terminal like this:

➜  ~ array=()
array+=a
array+=b
array+=c
array+=d
printf -v tmp '%s\n' "${array[@]}"
echo "$tmp"
a
b
c
d

However, when run as a script, the output was not what I wanted:

➜  ~ echo 'array=()
array+=a
array+=b
array+=c
array+=d
printf -v tmp '%s\n' "${array[@]}"
echo "$tmp"' > test1.sh
➜  ~ bash test1.sh 
abcdn

Then I remembered that zsh is my default shell, so I tried running it explicitly with zsh. The results were closer to what I wanted (there was something in between each array element), but still not what I got when pasting into the terminal. Why is the \ in \n ignored in this case?

➜  ~ zsh test1.sh
anbncndn

Also, is there a handy table somewhere of the key differences in basic commands like echo and printf between shells and in scripts vs the terminal?

EDIT:

I noticed that my example was flawed in that when I created the script test.sh file, the echo left out the backslash before the n.

➜  ~ echo '
array=()
array+=a
array+=b
array+=c
array+=d
printf -v tmp '%s\n' "${array[@]}"
echo "$tmp"
'

array=()
array+=a
array+=b
array+=c
array+=d
printf -v tmp %sn "${array[@]}"
echo "$tmp"

But what threw me off was that zsh -c showed the same behavior. Is it also stripping out backslashes?

➜  ~ zsh -c 'array=()
array+=a
array+=b
array+=c
array+=d
printf -v tmp '%s\n' "${array[@]}"
echo "$tmp"'
anbncndn

Edit 2: It's that escape characters work in each of these situations. three preceding backslashes turn in back into a good ol' newline.

zsh -c 'array=()
array+=a
array+=b
array+=c
array+=d
printf -v tmp '%s\\\\n' "${array[@]}"
echo "$tmp"'
a
b
c
d

EDIT3: So the escaping in a script works differently from '-c'

The script:

#!/bin/zsh
array=()
array+=a
array+=b
array+=c
array+=d
printf -v tmp '%s\\n' "${array[@]}"
echo "$tmp"

the result:

➜  ~ zsh test.sh     
a
b
c
d

Answer 1

zsh handles arrays differently than bash . In zsh (your interactive shell), array+=b really does append the string b as a new array element.

In bash , however, the same command only appends the string b to the first element of the array; to append a new element, you need to use array+=(b) .

Answer 2

zsh -c 'array=()
array+=a
array+=b
array+=c
array+=d
printf -v tmp '%s\n' "${array[@]}"
echo "$tmp"'
anbncndn

In this, the argument to -c is split into three parts:

'array=()
array+=a
array+=b
array+=c
array+=d
printf -v tmp '

%s\n

and

' "${array[@]}"
echo "$tmp"'

which are all concatenated together. The sections inside single quotes aren't subject to substitutions, expansions, special handling of backslashes, etc. The middle section is , and becomes %sn before it's passed to zsh for execution. When you add extra backslashes, %s\\\\n becomes %s\\n , and the double backslash is turned into a single one by the zsh executing the command.

In your script, because you're not trying to quote the entire thing to make it a single argument, printf -v tmp '%s\\n' "${array[@]}" is split and treated the way you want. However, because you're doubling up the backslash there, $tmp is set to a\nb\nc\nd\n . Then when you echo it, the default zsh behavior is to expand backslash escape sequences in the string being printed, so it looks right. This can be disabled with the BSD_ECHO shell option, or using echo -E . If you want actual newlines, use a single backslash inside single quotes, or a double one inside double quotes or unquoted.

Demonstration:

$ printf -v tmp '%s\\n' a b c d
$ echo "$tmp"
a
b
c
d
$ echo -E "$tmp"
a\nb\nc\nd\n
$ setopt BSD_ECHO
$ echo "$tmp"
a\nb\nc\nd\n
$ printf -v tmp '%s\n' a b c d
$ echo "$tmp"
a
b
c
d