Shell Builtin – Why `[` is a Shell Builtin and `[[` is a Shell Keyword

shellshell-builtin

As far as I know, [[ is an enhanced version of [, but I am confused when I see [[ as a keyword and [ being shown as a builtin.

[root@server ~]# type [
[ is a shell builtin
[root@server ~]# type [[
[[ is a shell keyword

TLDP says

A builtin may be a synonym to a system command of the same name, but
Bash reimplements it internally. For example, the Bash echo command is
not the same as /bin/echo, although their behavior is almost
identical.

and

A keyword is a reserved word, token or operator. Keywords have a
special meaning to the shell, and indeed are the building blocks of
the shell's syntax. As examples, for, while, do, and ! are keywords.
Similar to a builtin, a keyword is hard-coded into Bash, but unlike a
builtin, a keyword is not in itself a command, but a subunit of a
command construct. [2]

Shouldn't that make both [ and [[ a keyword? Is there anything that I am missing here?
Also, this link re-affirms that both [ and [[ should belong to the same kind.

Best Answer

The difference between [ and [[ is quite fundamental.

[ is a command. Its arguments are processed just the way any other commands arguments are processed. For example, consider:
```
[ -z $name ]
```
The shell will expand $name and perform both word splitting and filename generation on the result, just as it would for any other command.

As an example, the following will fail:
```
$ name="here and there"
$ [ -n $name ] && echo not empty
bash: [: too many arguments
```
To have this work correctly, quotes are necessary:
```
$ [ -n "$name" ] && echo not empty
not empty
```
[[ is a shell keyword and its arguments are processed according to special rules. For example, consider:
```
[[ -z $name ]]
```
The shell will expand $name but, unlike any other command, it will perform neither word splitting nor filename generation on the result. For example, the following will succeed despite the spaces embedded in name:
```
$ name="here and there"
$ [[ -n $name ]] && echo not empty
not empty
```

Summary

[ is a command and is subject to the same rules as all other commands that the shell executes.

Because [[ is a keyword, not a command, however, the shell treats it specially and it operates under very different rules.

Related Solutions

Bash – Capture Multi-Line Output of a Bash Builtin

There seems to be some ambiguity in the way that you worded your question. You said:

but in the script only first line end up in the variable

and then your comments suggest that you are writing a shell function - not a script.

I suspect you know that scripts are useless for changing directories, since any cd within a script does not propagate out to the superior shell. If indeed you are trying to develop your directory changer in a script, you'll have a tough time as the directory stack is not inherited by subordinate shells:

$ dirs -l
/home/msw /home/msw/Ubuntu One /home/msw /usr/bin /usr/local /bin /usr/local
$ cat > dirs.sh
dirs -l 
$ bash dirs.sh
/home/msw

You could get a function to help out:

$ function passdirs() { bash ndirs.sh `dirs -l -p`; }
$ cat > ndirs.sh
echo $#
echo "$@"
$ passdirs
8
/home/msw /usr/local /usr/bin /bin /usr/local /usr/bin /bin /home/msw

but, of course you'd need the function to also effect the cd in the current shell in which case wrapping and unwrapping arguments through the command line is a quoting chore so you are best just doing it all in the function

$ function cd_pattern() {
   cd $(dirs -l -p | grep --max-count=1 -e "$1") ; dirs
}
$ dirs
~ /usr/local /bin /usr/share/doc/evince ~/Ubuntu One
$ cd_pattern v..c
/usr/share/doc/evince /usr/local /bin /usr/share/doc/evince ~/Ubuntu One

which also switched to using $(...) as a synonym for backticks to reduce quoting confusion.

Bash Shell – Use System Command Instead of Bash Builtin Without Full Path

Assuming env is in your path:

env kill -p http

env runs the executable file named by its first argument in a (possibly) modified environment; as such, it does not know about or work with shell built-in commands.

This produces some shell job control cruft, but doesn't rely on an external command:

exec kill -p bash &

exec requires an executable to replace the current shell, so doesn't use any built-ins. The job is run in the background so that you replace the forked background shell, not your current shell.

Best Answer

Summary

Related Solutions

Bash – Capture Multi-Line Output of a Bash Builtin

Bash Shell – Use System Command Instead of Bash Builtin Without Full Path

Related Question