Shebang (Unix)

From Wikipedia, the free encyclopedia

For other uses, see Shebang (disambiguation).

In computing, a shebang (also called a hashbang) refers to a specific pair of characters that, when used as the first two characters on the first line of a script, causes Unix-like operating systems to execute that script using the interpreter specified by the rest of that line.

More precisely, a shebang line consists of a number sign and an exclamation point character ("#!"), followed by the (full) path to the interpreter program that will provide the interpretation. The shebang is looked for and used when a script is invoked directly (as you would a regular executable), and largely to the end of making scripts look and act similarly to regular executables, to the operating system and to the user.

The name shebang comes from an inexact contraction of SHArp bang or haSH bang, referring to the two typical Unix names of the two characters. Unix jargon uses sharp or hash to refer to the number sign character and bang to refer to the exclamation point, hence shebang. Another theory on sh in shebang's name is from default shell sh, usually invoked with shebang.

Because the "#" character is often used as the comment marker in scripting languages, the contents of the shebang line will be automatically ignored by the interpreter itself; the shebang line only exists to specify the correct interpreter to be used.

1 History
2 Limitations
3 Shebang as magic number
4 Example shebang lines
- 4.1 Solving shebang problems with the env program
5 See also
6 References
7 External links

[edit] History

The shebang was introduced by Dennis Ritchie between Version 7 Unix and 8 at Bell Labs. It was then also added to the BSD line at Berkeley (present in 4BSD and activated per default in 4.2BSD)^[1]. As Version 8 and later versions were not released to the public, the first widely known appearance of this feature was on BSD.

[edit] Limitations

While many common shebangs use system executables which have fairly standard paths, it is quite possible for different variants of even the same operating system to have different locations for the desired interpreter.

In the absence of rigidly standardised locations for each interpreter, the shebang would on some systems try to execute something that doesn't exist where the shebang says it is. Shebangs can therefore limit the portability of the file.

Because of this it is not uncommon to need to edit the shebang line after copying a script from one computer to another because the path that was coded into the script may not apply on a new machine, depending on the consistency in past convention of placement of the interpreter. For this and other reasons, POSIX does not standardize the feature.

Often the program /usr/bin/env can be used to circumvent this limitation.

[edit] Shebang as magic number

The shebang is actually a human-readable instance of a magic number in the executable file, the magic byte string being 0x23 0x21, the two characters' encoding in ASCII. (Executable files that do not require an interpreter program start with other magic combinations. See File format for more details of magic numbers.)

There have been rumours that some old versions of UNIX look for the normal shebang followed by a space and a slash ("#! /"), but this appears to be untrue^[2].

[edit] Example shebang lines

Some typical interpreters for shebang lines:

#!/bin/bash — Execute using bash program in the /bin/ directory
#!/bin/csh — Execute using csh, the C shell instead
#!/bin/ksh — Execute using the Korn shell
#!/bin/awk — Execute using awk program in the /bin/ directory
#!/bin/sh — On some systems, such as Solaris, this is the Bourne shell. On Linux systems there is usually no Bourne shell and this is a link to another shell, such as bash. According to the Single UNIX Specification's requirements for /bin/sh, such a shell will usually mimic the Bourne shell's behaviour, but be aware that using #!/bin/sh in shell scripts may invoke different shells on different systems.
#!/usr/bin/perl — Execute using Perl
#!/usr/bin/php — Execute using PHP
#!/usr/bin/python — Execute using Python
#!/usr/bin/env — Invocation of some other program using env program in /usr/bin directory

Shebang lines can also include specific options that will be passed to the interpreter; see the examples below. However, implementations differ widely on how options are parsed.

This file is a shell script, the Unix equivalent of a DOS batch file:

#!/bin/sh
# The rest of the shell script
...

This file is an AWK script:

#!/bin/awk -f
# The rest of the AWK script.
...

This file is a Perl script, to be run with 'warnings' enabled (-w):

#!/usr/bin/perl -w
#
# The rest of the Perl script
...

This file is also a Perl script, but it assumes that the Perl interpreter is in a different place. Also, the Perl interpreter is run without extra warnings being enabled.

#!/usr/local/bin/perl
#
# The rest of the Perl script
...

This is a different way of invoking a bash script, telling it to print each command before it executes it:

#!/bin/bash -x
#
# The rest of a perhaps long-running or importantly-timed Bash script
...

This file is a quine (though an illegal one):

#!/bin/cat
Any text can be placed below the shebang.

[edit] Solving shebang problems with the env program

Invocation via the env program is useful for two purposes:

...searching for a program via the PATH environment variable:

#!/usr/bin/env python
#
# The rest of the Python script
...

...and invoking a program which is itself a #! script:

#!/usr/bin/env /usr/local/bin/compileAndGo "$@"
...

Beware that while this method does increase portability, it is not foolproof. While env is almost always /usr/bin/env a small number of platforms have it at /bin/env^[3].