Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== BASH - Brackets ======

What is the difference between single and double square brackets in bash?

<code bash>
[ $STRING != foo ]
</code>

and

<code bash>
[[ $STRING != foo ]]
</code>

Both **<nowiki>[</nowiki>** and **<nowiki>[[</nowiki>** are used to evaluate expressions.

  * **<nowiki>[</nowiki>** is a "test" command, available in POSIX shells.

  * **<nowiki>[[</nowiki>** is a "newer test" command; and works only in more modern shells, such as Bash, Zsh and the Korn shell, and is more powerful.

----

===== [ =====

<code bash>
[
</code>

**[** is a builtin in Bash and many other modern shells.

The builtin **[** is similar to **test** with the additional requirement of a closing **]**.

The builtins [ and test imitate the functionality /bin/[ and /bin/test along with their limitations so that scripts would be backwards compatible.

The original executables still exist mostly for POSIX compliance and backwards compatibility.

----

==== Examples ====

<code bash>
[ "$variable" ] || echo 'variable is unset or empty!' >&2
[ -f "$filename" ] || printf 'File does not exist or is not a regular file: %s\n' "$filename" >&2
</code>


----

==== Use BASH to check [ ====

Running the command:

<code bash>
type [
</code>

returns:

<code bash>
[ is a shell builtin
</code>

This indicates that **[** is interpreted as a builtin by default.

<WRAP info>
**NOTE:**  [ only looks for executables on the PATH and is equivalent to **type -p [**
</WRAP>

----

===== [[ =====

<code bash>
[[
</code>

**<nowiki>[[</nowiki>** is not as compatible, it won't necessarily work with whatever /bin/sh points to.

So <nowiki>[[</nowiki> is the more modern Bash / Zsh / Ksh option.

Because <nowiki>[[</nowiki> is built into the shell and does not have legacy requirements, you don't need to worry about word splitting based on the IFS variable to mess up on variables that evaluate to a string with spaces.  Therefore, you don't really need to put the variable in double quotes.

----

==== Example ====

<code bash>
if [[ ! -e $file ]]; then
    echo "File doesn't exist or is in an inaccessible directory or is a symlink to a file that doesn't exist: $file" >&2
fi

if [[ $file0 -nt $file1 ]]; then
    printf 'file %s is newer than %s\n' "$file0" "$file1"
fi
</code>

----

==== Use BASH to check [[ ====

Running the command 

<code bash>
type [[
</code>

returns:

<code bash>
[[ is a shell keyword
</code>

<WRAP info>
**NOTE:**  Because <nowiki>[[</nowiki> is built into the shell and does not have legacy requirements, you don't need to worry about word splitting based on the IFS variable to mess up on variables that evaluate to a string with spaces.  Therefore, you don't really need to put the variable in double quotes.
</WRAP>



----

===== Comparisons between [ and [[ =====

----

Although <nowiki>[</nowiki> and <nowiki>[[</nowiki> have much in common and share many expression operators like "-f", "-s", "-n", and "-z", there are some notable differences.

Here is a comparison list:

^Feature^new test <nowiki>[[</nowiki>^old test <nowiki>[</nowiki>^Example^
|string comparison|>|\> (*)|<nowiki>[[ a > b ]] || echo "a does not come after b"</nowiki>|
| |<|\< (*)|<nowiki>[[ az < za ]] && echo "az comes before za"</nowiki>|
| |<nowiki>= (or ==)</nowiki>|=|<nowiki>[[ a = a ]] && echo "a equals a"</nowiki>|
| |!=|!=|<nowiki>[[ a != b ]] && echo "a is not equal to b"</nowiki>|
|integer comparison|-gt|-gt|<nowiki>[[ 5 -gt 10 ]] || echo "5 is not bigger than 10"</nowiki>|
| |-lt|-lt|<nowiki>[[ 8 -lt 9 ]] && echo "8 is less than 9"</nowiki>|
| |-ge|-ge|<nowiki>[[ 3 -ge 3 ]] && echo "3 is greater than or equal to 3"</nowiki>|
| |-le|-le|<nowiki>[[ 3 -le 8 ]] && echo "3 is less than or equal to 8"</nowiki>|
| |-eq|-eq|<nowiki>[[ 5 -eq 05 ]] && echo "5 equals 05"</nowiki>|
| |-ne|-ne|<nowiki>[[ 6 -ne 20 ]] && echo "6 is not equal to 20"</nowiki>|
|conditional evaluation|&&|<nowiki>-a (**)</nowiki>|<nowiki>[[ -n $var && -f $var ]] && echo "$var is a file"</nowiki>|
| |<nowiki>||</nowiki>|<nowiki>-o (**)</nowiki>|<nowiki>[[ -b $var || -c $var ]] && echo "$var is a device"</nowiki>|
|expression grouping|<nowiki>(...)</nowiki>|<nowiki>\( ... \) (**)</nowiki>|<nowiki>[[ $var = img* && ($var = *.png || $var = *.jpg) ]] &&
echo "$var starts with img and ends with .jpg or .png"</nowiki>|
|Pattern matching|<nowiki>= (or ==)</nowiki>|(not available)|<nowiki>[[ $name = a* ]] || echo "name does not start with an 'a': $name"</nowiki>|
|RegularExpression matching|<nowiki>=~</nowiki>|(not available)|<nowiki>[[ $(date) =~ ^Fri\ ...\ 13 ]] && echo "It's Friday the 13th!"</nowiki>|

  * **<nowiki>(*)</nowiki>** This is an extension to the POSIX standard; some shells may have it, others may not.
  * **<nowiki>(**)</nowiki>** The -a and -o operators, and ( ... ) grouping, are defined by POSIX but only for strictly limited cases, and are marked as deprecated.
    * Use of these operators is discouraged; you should use multiple <nowiki>[</nowiki> commands instead:
      *  if [ "$a" = a ] && [ "$b" = b ]; then ...
      *  if [ "$a" = a ] || { [ "$b" = b ] && [ "$c" = c ];}; then ... 

----

Special primitives that <nowiki>[[</nowiki> is defined to have, but [ may be lacking (depending on the implementation):

^Description^Primitive^Example^
|entry (file or directory) exists|-e|<nowiki>[[ -e $config ]] && echo "config file exists: $config"</nowiki>|
|file is newer/older than other file|-nt / -ot|<nowiki>[[ $file0 -nt $file1 ]] && echo "$file0 is newer than $file1"</nowiki>|
|two files are the same|-ef|<nowiki>[[ $input -ef $output ]] && { echo "will not overwrite input file: $input"; exit 1; }</nowiki>|
|negation|!|<nowiki>[[ ! -u $file ]] && echo "$file is not a setuid file"</nowiki>|

----

===== More subtle differences. =====

==== Quoting of arguments ====

No WordSplitting or glob expansion will be done for <nowiki>[[</nowiki> (and therefore many arguments need not be quoted):

<code bash>
file="file name"
[[ -f $file ]] && echo "$file is a regular file"
</code>

will work even though <nowiki>$file</nowiki> is not quoted and contains whitespace.

----

With <nowiki>[</nowiki> the variable needs to be quoted:

<code bash>
file="file name"
[ -f "$file" ] && echo "$file is a regular file"
</code>

This makes <nowiki>[[</nowiki> easier to use and less error-prone.

----

==== Escaping of Parentheses ====

Parentheses in <nowiki>[[</nowiki> do not need to be escaped:

<code bash>
[[ -f $file1 && ( -d $dir1 || -d $dir2 ) ]]
[ -f "$file1" -a \( -d "$dir1" -o -d "$dir2" \) ]
</code>

As of bash 4.1, string comparisons using < or > respect the current locale when done in **<nowiki>[[</nowiki>**, but not in **<nowiki>[</nowiki>** or test.

In fact, **<nowiki>[</nowiki>** and test have never used locale collating order even though past man pages said they did.

Bash versions prior to 4.1 do not use locale collating order for **<nowiki>[[</nowiki>** either. 

----

===== Rule of Thumb =====

As a rule of thumb, **[[** is used for strings and files.

If you want to compare numbers, use an ArithmeticExpression, e.g.

<code bash>
# Bash
i=0
while (( i < 10 )); do ...
</code>

When should the new test command <nowiki>[[</nowiki> be used, and when the old one <nowiki>[</nowiki>?

  * If portability/conformance to POSIX or the Bourne Shell is a concern, the old syntax should be used.
  * If on the other hand the script requires BASH, Zsh, or KornShell, the new syntax is usually more flexible, but not necessarily backwards compatible.

<WRAP info>
**NOTE:**  Any problem with an operator used with **<nowiki>[[</nowiki>** resulting in an unhandleable parse-time error will cause bash to terminate, even if the command is never evaluated.
</WRAP>