Bash script: Shebang usage and best practices

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
How to use a shebang in a Bash script on Linux
How to use a shebang in a Bash script on Linux
Software Requirements and Linux Command Line Conventions
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 sudo command.
Conventions # – requires given linux commands to be executed with root privileges either directly as a root user or by use of sudo command
$ – requires given linux commands to be executed as a regular non-privileged user

Bash script: Shebang usage and best practices



Twitter icon Follow LinuxConfig.org on Twitter for the latest tips and tricks about Linux!


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 /bin/bash.

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.

  1. The usual way to use a shebang in a Bash script:
    #!/bin/bash
    
  2. A technically better way to use a shebang is by specifying the environment variable to the intentended interpreter. That is because /bin/bash is 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.
    #!/usr/bin/env bash
    



  3. We can also add flags to the interpreter. For example, the -v flag 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.
    #!/bin/bash -v
    
  4. 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/sh shell, which is also a very common interpreter.
    #!/bin/sh
    
  5. Another extremely common interpreter to use in scripts is Python.
    #!/usr/bin/env python
    OR
    #!/usr/bin/python
    
  6. 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 my_script has the #!/bin/sh shebang on its first line, but you want to interpret the file with Bash instead.
    $ bash my_script
    

Closing Thoughts




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.



Comments and Discussions
Linux Forum