if I write,
#!/bin/bash echo "foo"
#!/bin/sh echo "foo"
both yields same. I have seen some scripts starting with
#!/bin/bash. Is there any difference between them?
sh are two different shells. Basically
sh, with more features and better syntax. Most commands work the same, but they are different.
Having said that, you should realize
/bin/sh on most systems will be a symbolic link and will not invoke
sh. In Ubuntu
/bin/sh used to link to
bash, typical behavior on Linux distributions, but now has changed to linking to another shell called dash. I would use
bash, as that is pretty much the standard (or at least most common, from my experience). In fact, problems arise when a bash script will use
#!/bin/sh because the script-maker assumes the link is to
bash when it doesn't have to be.
On Linux and other Unix-like systems you have a choice of multiple shells.
The shell is responsible not only for drawing your little prompt, but interpreting your commands, especially if you put in complicated logic like pipes, conditionals and so on.
bash is the most common shell used as a default shell for users of Linux systems. It is a spiritual descendent of other shells used throughout Unix history. Its name, bash is an abbreviation of Bourne-Again Shell, an homage to the Bourne shell it was designed to replace, though it also incorporates features from the C Shell and the Korn Shell.
It's run, these days, from
/bin/bash - any system with bash will have it accessible here.
It's not just users that use shells, though. Scripts (shell scripts) need shells to interpret them. When you run a shell script, your system needs to start up a shell process to execute your script.
The problem is, different shells have tiny little inconsistencies between them, and when it comes to running scripts, these can be a real problem. bash has quite a lot of scripting features that are unique only to bash, and not to other shells. This is fine, if you're always going to use bash to run those scripts. Other shells may try to either emulate bash, or adhere to the POSIX standard, which bash supports pretty well (though adds its own extensions to).
It's possible to specify at the top of a shell script which shell it should be run with using a shebang. A script may specify
#!/bin/bash on the first line, meaning that the script should always be run with bash, rather than another shell.
/bin/sh is an executable representing the system shell. Actually, it is usually implemented as a symbolic link pointing to the executable for whichever shell is the system shell. The system shell is kind of the default shell that system scripts should use. In Linux distributions, for a long time this was usually a symbolic link to bash, so much so that it has become somewhat of a convention to always link /bin/sh to bash or a bash-compatible shell. However, in the last couple of years Debian (and Ubuntu) decided to switch the system shell from bash to dash - a similar shell - breaking with a long tradition in Linux (well, GNU) of using bash for /bin/sh. Dash is seen as a lighter, and much faster, shell which can be beneficial to boot speed (and other things that require a lot of shell scripts, like package installation scripts).
Dash is fairly well compatible with bash, being based on the same POSIX standard. However, it doesn't implement the bash-specific extensions. There are scripts in existence that use
#!/bin/sh (the system shell) as their shebang, but which require bash-specific extensions. This is currently considered a bug that should be fixed by Debian and Ubuntu, who require /bin/sh to be able to work when pointed to dash.
Even though Ubuntu's system shell is pointing to dash, your login shell as a user continues to be bash at this time. That is, when you log in to a terminal emulator anywhere in Linux, your login shell will be bash. Speed of operation is not so much a problem when the shell is used interactively, and users are familiar with bash (and may have bash-specific customisations in their home directory).
What you should use when writing scripts
If your script requires features only supported by bash, use
But if at all possible, it would be good to make sure your script is POSIX-compatible, and use
#!/bin/sh, which should always, quite reliably, point to the preferred POSIX-compatible system shell in any installation.
In addition to the previous answers, even if
/bin/sh is a symbolic link to
#!/bin/sh is not totally equivalent to
From the bash(1) man page :
"If bash is invoked with the name sh, it tries to mimic the startup behavior of historical versions of sh as closely as possible, while conforming to the POSIX standard as well."
For example the bash specific syntax :
exec > >(tee logfile.txt)
gives an error in a shell beginning with
#!/bin/sh, even with the sh->bash symbolic link in place.