41

This question already has an answer here:

According to this page, $@ and $* do pretty much the same thing:

The $@ holds list of all arguments passed to the script. 
The $* holds list of all arguments passed to the script.

After searching all the top hits in google, I'm not able to find any explanation why there would be 2 seemingly duplicate syntaxes.

They appear to work the same in my scripts.

cat foo.sh
#!/bin/bash
echo The parameters passed in are $@
echo The parameters passed in are $*

./foo.sh herp derp
The parameters passed in are herp derp
The parameters passed in are herp derp
  1. Is one preferred over the other?
  2. Why are there 2 builtin variables to do the exact same thing?

Additional sources
bash.cyberciti.biz

marked as duplicate by glenn jackman, Braiam, manatwork, Karlson, Patrick May 12 '14 at 16:40

This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.

66

They aren't the same. $* is a single string, whereas $@ is an actual array. To see the difference, execute the following script like so:

 > ./test.sh one two "three four"

The script:

#!/bin/bash

echo "Using \"\$*\":"
for a in "$*"; do
    echo $a;
done

echo -e "\nUsing \$*:"
for a in $*; do
    echo $a;
done

echo -e "\nUsing \"\$@\":"
for a in "$@"; do
    echo $a;
done

echo -e "\nUsing \$@:"
for a in $@; do
    echo $a;
done              

The four cases are:

Using "$*":
one two three four

Here, the parameters are regarded as one long quoted string. Unquoted:

Using $*:
one
two
three
four

The string is broken into words by the for loop.

Using "$@":
one
two
three four

This treats each element of $@ as a quoted string.

Using $@:
one
two
three
four

This treats each element as an unquoted string, so the last one is again split by what amounts to for three four.

12

The difference comes in how they are expanded.

$* expands to a single argument with all the elements delimited by spaces (actually the first character of $IFS).
$@ expands to multiple arguments.

For example

#!/bin/bash
echo "With *:"
for arg in "$*"; do echo "<$arg>"; done
echo
echo "With @:"
for arg in "$@"; do echo "<$arg>"; done

 

$ /tmp/test.sh 1  2 "3  4"
With *:
<1 2 3  4>

With @:
<1>
<2>
<3  4>
  • The OP want to know difference between $* and $@, not "$*" and "$@". – cuonglm May 12 '14 at 16:26
3

You can review Bash Beginners Guide for more information. These to do pretty much the same thing with the difference of how it's separated:

$* - Expands to the positional parameters, starting from one. When the expansion occurs within double quotes, it expands to a single word with the value of each parameter separated by the first character of the IFS special variable.

$@ - Expands to the positional parameters, starting from one. When the expansion occurs within double quotes, each parameter expands to a separate word.

But unless you set IFS to value other then default it could look identical.

0

Is one preferred over the other?

A short answer is "$@".

If you use them without double quote, they are the same. There is no one preferred over the other in this case. But I suggest you to always use them with double quote, except you know what exactly you want.

Why are there 2 builtin variables to do the exact same thing?

There are no difference between $* and $@, but "$@" and "$*" have.

You can see my answer in this post to see how are they different.

Not the answer you're looking for? Browse other questions tagged or ask your own question.