How-to: Run a bash shell script

A shell script is a text file containing one or more commands.

# My example bash script
echo "Hello World"

The first line contains a shebang #! followed by the path to the shell, in this case bash - this acts as an interpreter directive and ensures that the script is executed under the correct shell.

The "#" character indicates a comment, so the shebang line is ignored by bash when running the script.

Next you need to make the script executable with chmod

$ chmod u+x

You can now run the script by prefixing it with ./

$ ./

Naming the file with an .sh extension is not required, but you may find it a helpful reminder that the file is a shell script.

If you will be writing a few shell scripts then it's worth creating a folder, perhaps called "scripts" and adding that to the system path:

$ mkdir -p $HOME/scripts
$ export PATH="$PATH:~/scripts"

Even better is to edit your .bash_profile file to include export PATH="$PATH:~/scripts" that will keep the "scripts" folder in your path every time you log in.

With the script saved in the folder, you can now run it with just:


If this returns an error like #: bad interpreter: No such file or directory that is typically an indication that the File encoding or line endings are wrong, use an editor like VI or just make sure the text is plain ASCII/Unicode and the line endings are classic UNIX LF (not Windows CR/LF or Mac CR)

Passing parameters to a shell script:

$ cat
echo 'Welcome' $0 'says' $1 $2

$ chmod a+x
$ Hello world
Welcome says Hello world

Running scripts from the system path

A shell script is a text file containing shell commands. When such a file is used as the first non-option argument when invoking Bash, and neither the '-c' nor '-s' option is supplied, Bash reads and executes commands from the file, then exits. This mode of operation creates a non-interactive shell.

A shell script can be made executable by using the chmod command to turn on the execute bit. When Bash finds such a file while searching the $PATH for a command, it spawns a subshell to execute it.

In other words, executing

filename arguments

is equivalent to executing

bash filename arguments

if filename is an executable shell script. This subshell reinitializes itself, so that the effect is as if a new shell had been invoked to interpret the script, with the exception that the locations of commands remembered by the parent are retained by the child.

Most versions of Unix make this a part of the operating system's command execution mechanism. If the first line of a script begins with the two characters '#!', the remainder of the line specifies an interpreter for the program. Thus, you can specify Bash, awk, Perl, or some other interpreter and write the rest of the script file in that language.

The arguments to the interpreter consist of a single optional argument following the interpreter name on the first line of the script file, followed by the name of the script file, followed by the rest of the arguments. Bash will perform this action on operating systems that do not handle it themselves. Note that some older versions of Unix limit the interpreter name and argument to a maximum of 32 characters.

Bash scripts often begin with the shebang #!/bin/bash (assuming that Bash has been installed in /bin ), since this ensures that Bash will be used to interpret the script, even if it is executed under another shell.
If you run the script on a different computer running a different version of linux or unix, you may need to adjust the shebang so that it still finds the bash shell, before doing this consider all the other dependencies in your script. In some cases it may be better for the script not to run at all than run and fail because other programs are missing on the new machine.

When Bash runs a shell script, it sets the special parameter $0 to the name of the file, rather than the name of the shell, and the positional parameters are set to the remaining arguments, if any are given. If no additional arguments are supplied, the positional parameters are unset.

Adding the following two set options to your scripts can be useful to catch undefined variables ("") and to exit if a command fails:

set -o nounset
set -o errexit


/bin/bash^M: bad interpreter: no such file or directory
This usually means the file has been edited and has Windows <CR-LF> instead of unix <LF> line endings

Related linux commands

BASH Syntax
exec - Execute a command.
set - Manipulate shell variables and functions.
Windows equivalent command: CMD - Start a new CMD shell / Start-Process.

Copyright © 1999-2023
Some rights reserved