If you have looked at some of our Bash script examples across our website, or seen some others online to learn from, you may have noticed that all of the Bash scripts begin with a shebang.
A shebang is on the first line and starts with two characters
#!. Following these characters is the path to the interpreter that should be used to parse the rest of the script. In most cases, this will be the Bash shell, which has a default path of
/bin/bash on Linux systems. But there are other interpreters that can be used, or even flags that we can use with them.
In this tutorial, we will go over shebang usage in Bash scripting. We will cover some best practices and show you examples of how to use shebangs in your own shell scripts.
In this tutorial you will learn:
- How to use a shebang in a Bash script
- How to use environment variable instead of direct path in shebang
- How to add flags to shebang
- How to use other interpreters in shebang besides Bash
|Category||Requirements, Conventions or Software Version Used|
|System||Any Linux distro|
|Software||Bash shell (installed by default)|
|Other||Privileged access to your Linux system as root or via the
# – requires given linux commands to be executed with root privileges either directly as a root user or by use of
$ – requires given linux commands to be executed as a regular non-privileged user
Bash script: Shebang usage and best practices
If you are writing a Bash script, then you will be using the Bash shell to interpret your script. On Linux, systems, the path to the Bash shell is
Here is how you would put a shebang at the top of your Bash script:
#!/bin/bash # the rest of the script echo "testing..."
The shebang on the first line of our script is how we can immediately tell that this is a Bash script.
If you are executing this script from the Bash shell, then it is not necessary to specify the Bash interpreter with the shebang. However, it is certainly recommended that you specify it anyway. If someone executes your script from a different shell, then the script could be parsed with an unintended interpreter.
Shebang usage examples
Let’s look at a few other examples of how shebangs can be used.
- The usual way to use a shebang in a Bash script:
- A technically better way to use a shebang is by specifying the environment variable to the intentended interpreter. That is because
/bin/bashis not always the path to the Bash shell. It is only a different path in very rare cases, though, so it does not usually matter. At any rate, here is how you would use the environment variable to specify the Bash shell.
- We can also add flags to the interpreter. For example, the
-vflag is used to print shell input lines as they are read. This is great for debugging or troubleshooting a script to figure out how exactly it is processing the file.
- This tutorial is particularly about Bash scripts, but let’s not forget that there are many other shells out there, and you therefore may see some different shebangs. This one uses the
/bin/shshell, which is also a very common interpreter.
- Another extremely common interpreter to use in scripts is Python.
#!/usr/bin/env python OR #!/usr/bin/python
- Another trick you should know about is how to override the shebang in a script. Just specify the shell you would like to interpret a script with when you are executing the script on the command line. For example, let’s say that
#!/bin/shshebang on its first line, but you want to interpret the file with Bash instead.
$ bash my_script
In this tutorial, we saw how to use a shebang in a Bash script on Linux. You also learned about best practices, such as using the environment variable instead of the direct path to an interpreter. Finally, we covered various examples of using flags with the shebang and other types of interpreters, so you will be armed with all the necessary knowledge regardless of what type of script you come across.