[Explained] What Are “exit 0” and “exit 1” in Bash?

A Complete Guide for Beginners Enroll Course Now

In Bash, using exit codes for effective script execution with robust error handling is a crucial step. Commands like exit 0 and exit 1 use the status codes 0 and 1 (non-zero) respectively, denoting whether the script ran successfully or not. This guide discusses the commands “exit 0” and “exit 1” in Bash with details. Through illustrative examples, it sheds light on the use of these codes in different approaches for successful script development with error management.

What is the Meaning of “exit 0” in Bash?

The “exit 0” is a command in Bash that utilizes the exit command followed by the exit code 0. It denotes that the command or steam of commands has been successfully executed, as defined in the Bash script. When the script executes without errors, it terminates successfully after getting the exit 0 command and returns the success code 0 to the calling process.

Look at the example below to see how to use exit 0 in scripts:

# read a number from user input
read -p "Enter a number:" a
# checks if number is 1 
if [ $a -eq 1 ]
echo "The entered number is correct"
exit 0  # exit 0 denotes successful termination
echo "The entered number is not correct"

The above Bash script uses the read command to take a number from the user input. Then it uses if [ $a -eq 1 ] to check whether the number equals 1 and exits with exit 0 after printing a success message using the echo command. In that case, the script terminates and the last echo command does not execute. Otherwise, the else block is executed.

Bash script exits with exit 0 command

As you see, the script terminates successfully using the exit 0 command since the user entered the number 1 accordingly.

To verify whether the script exits successfully with exit code 0, run the below command after the script’s execution:

echo $?

verifying exit 0 after execution

Here, $? is a special Bash variable that stores the exit code of the last executed process and the value 0 verifies that the script above indeed exited with success.

What Does “exit 1” Mean in Bash?

The command “exit 1” means that the script has encountered an error condition. Codes other than 0 are commonly associated with various error conditions. Thus, the nonzero Bash exit code 1, denotes that an error or failure has occurred during the script’s execution. Here’s an example to demonstrate the situation:


# Run a command
if ls example.txt; then
    echo "Command 'ls example.txt' ran successfully."
    echo "Command 'ls example.txt' did not run successfully."
    exit 1  # Exit the script with a failure status 1

# Proceed with further operations if the command runs successfully
echo "Performing additional operations..."

First, the above script attempts to execute the command ls example.txt. If it succeeds, the if condition evaluates to true and the echo command prints “Command ‘ls example.txt’ ran successfully.” and performs additional operations such as printing “Performing additional operations…”  Otherwise, the script executes the else block and exits with code 1 indicating an error.

exit 1 command denotes error and terminates script

Since the example.txt file does not exist, the above script encounters an error and terminates further execution with exit 1 which is seen after printing the value of $? Variable.

What is the Difference Between Bash “exit 0” and “exit 1”?

The primary difference between exit 0 and exit 1 is they return 2 different exit codes to denote success and failure status. The command exit 0 terminates the script by returning code 0 to the calling process. This exit code 0 means that the script has been executed successfully.

On the other hand, exit 1 returns code 1 after script termination to denote failure. It signifies that the script has encountered an error condition.

See the below example for a robust understanding that uses both exit 0 and exit 1 conditions:

#alert user with a message to enter a username
echo "enter the username:"

# read the username to check from user using read command 
read username

# Check if the username exists in /etc/passwd
if cat /etc/passwd | grep -q "$username"; then
    echo "User '$username' is valid."
    exit 0  # Exit script with success status
    echo "User '$username' is invalid."
    exit 1  # Exit script with failure status

The script above first takes a username as input and checks if the username exists by employing an if-else statement. If yes, it executes the message of the if block and exits with “exit 0”. Otherwise, the else block executes and the script terminates with status 1 using “exit 1” denoting the error condition of the “username” is invalid.

showing difference between exit 0 and exit 1

The terminal output above shows how exit 0 differs from “exit 1”.

Reversing Conventions: “exit 0” for Error and “exit 1” for Success

Usually, exit code 0 denotes success, and code 1 indicates any error condition the script encounters. However, it is possible to use them in conditions opposite to the conventional scope. Elaborately, using exit code 0 to denote failure and using code 1 to denote the successful execution of scripts. Here’s how:


#check if file exists
if [ -f /etc/passwd ]; then
  echo 'File exists'
  exit 1 # exit with 1 for success
  echo 'File does not exist'
  exit 0 # exit with 0 for failure

The script above checks if a file exists and exits with code 1 using exit 1 if it successfully locates the file. Conversely, the script exits with status 0 if the file does not exist. This is how the codes 0 and 1 can be customized to denote failure and success reversing their usual meanings.

exit 1 denotes successful execution

The output image shows that the exit 1 command denotes successful execution.

On the other hand, the command exit 0 indicates that the script has encountered an error like the following image:Using exit 0 for denoting error condition

Note: It is wise to use “exit 0” and “exit 1” conventionally for effective error handling, and to avoid unwanted confusion. It’s also crucial for accurate status reporting


This article has discussed the meaning and significance of the “exit 0” and “exit 1” commands. By mentioning Bash scripting examples, it shows the use of these 2 useful commands to denote the success and failure of scripts. Moreover, it sheds light on the key differences between the commands “exit 0” and “exit 1” for a clearer understanding. I hope this article assists you in mastering these commands and allows for effective error handling, process management, and controlled script development in Bash.

Frequently Asked Questions

What does exit 2 mean in a Bash script?

“exit 2” is a command that uses the nonzero value 2 to denote error conditions in Bash scripts. One instance of its occurrence is when the script cannot find the targeted file or folder. For example, if a script attempts to execute the command ls players where the folder player does not exist. Then the script can terminate with exit 2 to denote “no such file or directory error”.

Can I return nonzero exit codes to denote success in Bash?

Yes. you can use a nonzero code to denote success in Bash. For instance, you can use the command exit 40 to denote the success. After the execution, the script will return code 40 to the calling process to indicate success. However, it is recommended to use code 0 to handle the successful execution of scripts since nonzero codes are more significant in denoting different error conditions or failures.

What does the “exit 0” command do in Bash?

The command exit 0 in bash is a useful tool that terminates the script with an exit status 0. This denotes that the Bash script executes successfully; not encountering any errors. It is typically used at the end of the script to indicate the successful execution. In addition, the exit 0 command is also used within a Bash function denoting its execution and termination with the successful status code 0.

What is the difference between the commands exit 0 and return 0 in Bash?

The command exit 0 generally terminates the script in Bash by returning the exit code 0 to the calling process. It denotes that the script executes successfully without facing error conditions or failures. On the other hand, the return 0 command is used within a function to exit the function with the status code 0. This, in turn, signifies the successful execution of that function. In summary, “exit 0” indicates successful script execution while return 0 signifies successful execution of a Bash function.

Can I use “exit 0” and “exit 1” in the same Bash script?

Yes, you can. You can handle different execution outcomes and status reporting using both the commands exit 0 and exit 1 in the same Bash script. “exit 0” denotes successful execution by commonly placing it at the end of the script. Contrarily, “exit 1” stands for any error condition encountered by the script. Thus, using both commands ensures a clear communication script status facilitating smooth error detection and handling.

Is it possible to use “exit 0” inside a Bash function?

Yes, it is possible to use exit 0 inside a Bash function. When used within a Bash function, it terminates the function immediately with the success status 0 and returns control to the calling process. However, the return 0 command is more popular to use inside a function than the exit 0 command.

What do exit 0 and exit 1 signify in Bash scripting?

The command exit 0 signifies the successful execution of a script in Bash. On the other hand, exit 1 indicates failures or error conditions. When used with the exit command, the status codes 0 and 1 terminate the script; denoting whether the script executes successfully. This facilitated error handling and debugging for effective process management.

Related Articles

<< Go Back to Exit Codes in Bash | Bash Process and Signal Handling | Bash Scripting Tutorial

Rate this post
Md Masrur Ul Alam

Assalamu Alaikum, I’m Md Masrur Ul Alam, currently working as a Linux OS Content Developer Executive at SOFTEKO. I completed my Bachelor's degree in Electronics and Communication Engineering (ECE)from Khulna University of Engineering & Technology (KUET). With an inquisitive mind, I have always had a keen eye for Science and Technolgy based research and education. I strongly hope this entity leverages the success of my effort in developing engaging yet seasoned content on Linux and contributing to the wealth of technical knowledge. Read Full Bio

Leave a Comment