bash variable assignment exit code

How-To Geek

How to work with variables in bash.

Want to take your Linux command-line skills to the next level? Here's everything you need to know to start working with variables.

Hannah Stryker / How-To Geek

Quick Links

Variables 101, examples of bash variables, how to use bash variables in scripts, how to use command line parameters in scripts, working with special variables, environment variables, how to export variables, how to quote variables, echo is your friend, key takeaways.

• Variables are named symbols representing strings or numeric values. They are treated as their value when used in commands and expressions.
• Variable names should be descriptive and cannot start with a number or contain spaces. They can start with an underscore and can have alphanumeric characters.
• Variables can be used to store and reference values. The value of a variable can be changed, and it can be referenced by using the dollar sign $ before the variable name.

Variables are vital if you want to write scripts and understand what that code you're about to cut and paste from the web will do to your Linux computer. We'll get you started!

Variables are named symbols that represent either a string or numeric value. When you use them in commands and expressions, they are treated as if you had typed the value they hold instead of the name of the variable.

To create a variable, you just provide a name and value for it. Your variable names should be descriptive and remind you of the value they hold. A variable name cannot start with a number, nor can it contain spaces. It can, however, start with an underscore. Apart from that, you can use any mix of upper- and lowercase alphanumeric characters.

Here, we'll create five variables. The format is to type the name, the equals sign = , and the value. Note there isn't a space before or after the equals sign. Giving a variable a value is often referred to as assigning a value to the variable.

We'll create four string variables and one numeric variable,

my_name=Dave

my_boost=Linux

his_boost=Spinach

this_year=2019

To see the value held in a variable, use the echo command. You must precede the variable name with a dollar sign $ whenever you reference the value it contains, as shown below:

echo $my_name

echo $my_boost

echo $this_year

Let's use all of our variables at once:

echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"

The values of the variables replace their names. You can also change the values of variables. To assign a new value to the variable, my_boost , you just repeat what you did when you assigned its first value, like so:

my_boost=Tequila

If you re-run the previous command, you now get a different result:

So, you can use the same command that references the same variables and get different results if you change the values held in the variables.

We'll talk about quoting variables later. For now, here are some things to remember:

• A variable in single quotes ' is treated as a literal string, and not as a variable.
• Variables in quotation marks " are treated as variables.
• To get the value held in a variable, you have to provide the dollar sign $ .
• A variable without the dollar sign $ only provides the name of the variable.

You can also create a variable that takes its value from an existing variable or number of variables. The following command defines a new variable called drink_of_the_Year, and assigns it the combined values of the my_boost and this_year variables:

drink_of-the_Year="$my_boost $this_year"

echo drink_of_the-Year

Scripts would be completely hamstrung without variables. Variables provide the flexibility that makes a script a general, rather than a specific, solution. To illustrate the difference, here's a script that counts the files in the /dev directory.

Type this into a text file, and then save it as fcnt.sh (for "file count"):

#!/bin/bashfolder_to_count=/devfile_count=$(ls $folder_to_count | wc -l)echo $file_count files in $folder_to_count

Before you can run the script, you have to make it executable, as shown below:

chmod +x fcnt.sh

Type the following to run the script:

This prints the number of files in the /dev directory. Here's how it works:

• A variable called folder_to_count is defined, and it's set to hold the string "/dev."
• Another variable, called file_count , is defined. This variable takes its value from a command substitution. This is the command phrase between the parentheses $( ) . Note there's a dollar sign $ before the first parenthesis. This construct $( ) evaluates the commands within the parentheses, and then returns their final value. In this example, that value is assigned to the file_count variable. As far as the file_count variable is concerned, it's passed a value to hold; it isn't concerned with how the value was obtained.
• The command evaluated in the command substitution performs an ls file listing on the directory in the folder_to_count variable, which has been set to "/dev." So, the script executes the command "ls /dev."
• The output from this command is piped into the wc command. The -l (line count) option causes wc to count the number of lines in the output from the ls command. As each file is listed on a separate line, this is the count of files and subdirectories in the "/dev" directory. This value is assigned to the file_count variable.
• The final line uses echo to output the result.

But this only works for the "/dev" directory. How can we make the script work with any directory? All it takes is one small change.

Many commands, such as ls and wc , take command line parameters. These provide information to the command, so it knows what you want it to do. If you want ls to work on your home directory and also to show hidden files , you can use the following command, where the tilde ~ and the -a (all) option are command line parameters:

Our scripts can accept command line parameters. They're referenced as $1 for the first parameter, $2 as the second, and so on, up to $9 for the ninth parameter. (Actually, there's a $0 , as well, but that's reserved to always hold the script.)

You can reference command line parameters in a script just as you would regular variables. Let's modify our script, as shown below, and save it with the new name fcnt2.sh :

#!/bin/bashfolder_to_count=$1file_count=$(ls $folder_to_count | wc -l)echo $file_count files in $folder_to_count

This time, the folder_to_count variable is assigned the value of the first command line parameter, $1 .

The rest of the script works exactly as it did before. Rather than a specific solution, your script is now a general one. You can use it on any directory because it's not hardcoded to work only with "/dev."

Here's how you make the script executable:

chmod +x fcnt2.sh

Now, try it with a few directories. You can do "/dev" first to make sure you get the same result as before. Type the following:

./fnct2.sh /dev

./fnct2.sh /etc

./fnct2.sh /bin

You get the same result (207 files) as before for the "/dev" directory. This is encouraging, and you get directory-specific results for each of the other command line parameters.

To shorten the script, you could dispense with the variable, folder_to_count , altogether, and just reference $1 throughout, as follows:

#!/bin/bash file_count=$(ls $1 wc -l) echo $file_count files in $1

We mentioned $0 , which is always set to the filename of the script. This allows you to use the script to do things like print its name out correctly, even if it's renamed. This is useful in logging situations, in which you want to know the name of the process that added an entry.

The following are the other special preset variables:

• $# : How many command line parameters were passed to the script.
• $@ : All the command line parameters passed to the script.
• $? : The exit status of the last process to run.
• $$ : The Process ID (PID) of the current script.
• $USER : The username of the user executing the script.
• $HOSTNAME : The hostname of the computer running the script.
• $SECONDS : The number of seconds the script has been running for.
• $RANDOM : Returns a random number.
• $LINENO : Returns the current line number of the script.

You want to see all of them in one script, don't you? You can! Save the following as a text file called, special.sh :

#!/bin/bashecho "There were $# command line parameters"echo "They are: $@"echo "Parameter 1 is: $1"echo "The script is called: $0"# any old process so that we can report on the exit statuspwdecho "pwd returned $?"echo "This script has Process ID $$"echo "The script was started by $USER"echo "It is running on $HOSTNAME"sleep 3echo "It has been running for $SECONDS seconds"echo "Random number: $RANDOM"echo "This is line number $LINENO of the script"

Type the following to make it executable:

chmod +x special.sh

Now, you can run it with a bunch of different command line parameters, as shown below.

Bash uses environment variables to define and record the properties of the environment it creates when it launches. These hold information Bash can readily access, such as your username, locale, the number of commands your history file can hold, your default editor, and lots more.

To see the active environment variables in your Bash session, use this command:

If you scroll through the list, you might find some that would be useful to reference in your scripts.

When a script runs, it's in its own process, and the variables it uses cannot be seen outside of that process. If you want to share a variable with another script that your script launches, you have to export that variable. We'll show you how to this with two scripts.

First, save the following with the filename script_one.sh :

#!/bin/bashfirst_var=alphasecond_var=bravo# check their valuesecho "$0: first_var=$first_var, second_var=$second_var"export first_varexport second_var./script_two.sh# check their values againecho "$0: first_var=$first_var, second_var=$second_var"

This creates two variables, first_var and second_var , and it assigns some values. It prints these to the terminal window, exports the variables, and calls script_two.sh . When script_two.sh terminates, and process flow returns to this script, it again prints the variables to the terminal window. Then, you can see if they changed.

The second script we'll use is script_two.sh . This is the script that script_one.sh calls. Type the following:

#!/bin/bash# check their valuesecho "$0: first_var=$first_var, second_var=$second_var"# set new valuesfirst_var=charliesecond_var=delta# check their values againecho "$0: first_var=$first_var, second_var=$second_var"

This second script prints the values of the two variables, assigns new values to them, and then prints them again.

To run these scripts, you have to type the following to make them executable:

chmod +x script_one.shchmod +x script_two.sh

And now, type the following to launch script_one.sh :

./script_one.sh

This is what the output tells us:

• script_one.sh prints the values of the variables, which are alpha and bravo.
• script_two.sh prints the values of the variables (alpha and bravo) as it received them.
• script_two.sh changes them to charlie and delta.
• script_one.sh prints the values of the variables, which are still alpha and bravo.

What happens in the second script, stays in the second script. It's like copies of the variables are sent to the second script, but they're discarded when that script exits. The original variables in the first script aren't altered by anything that happens to the copies of them in the second.

You might have noticed that when scripts reference variables, they're in quotation marks " . This allows variables to be referenced correctly, so their values are used when the line is executed in the script.

If the value you assign to a variable includes spaces, they must be in quotation marks when you assign them to the variable. This is because, by default, Bash uses a space as a delimiter.

Here's an example:

site_name=How-To Geek

Bash sees the space before "Geek" as an indication that a new command is starting. It reports that there is no such command, and abandons the line. echo shows us that the site_name variable holds nothing — not even the "How-To" text.

Try that again with quotation marks around the value, as shown below:

site_name="How-To Geek"

This time, it's recognized as a single value and assigned correctly to the site_name variable.

It can take some time to get used to command substitution, quoting variables, and remembering when to include the dollar sign.

Before you hit Enter and execute a line of Bash commands, try it with echo in front of it. This way, you can make sure what's going to happen is what you want. You can also catch any mistakes you might have made in the syntax.

Home > Bash Scripting Tutorial > Bash Process and Signal Handling > Exit Codes in Bash

Exit Codes in Bash

Exit codes are pivotal elements for the successful handling of command-line operations and Bash scripts with effective error handling, debugging, and script control flow–providing success or failure status of the commands or scripts. This guide will provide a comprehensive view of Bash exit codes discussing their basics, and usage in practical scenarios. It will shed light on several frequently encountered exit codes with meanings for successful adoption in command operations and Bash scripts.

What is an Exit Code in Bash?

Exit code , also called “ exit status” or “return code” is an integer value from 0-255 used by a command or script to indicate its success or failure during execution. It typically denotes whether a program has run successfully or has encountered any error condition or failure. Exit code is a traditional way of handling errors in Bash in the execution of scripts or commands in the terminal.

When a program finishes running, it returns an exit code to the calling process to indicate success or failure for further decision-making. For example, the exit code 0 typically means that the last executed command or script has run successfully while the exit status of 1 or any non-zero numerical value means that the process has encountered an error condition.

How to Get Bash Exit Codes Using the Terminal?

Get Exit Codes Using Bash Scripts

Alternatively, you can find the exit codes using Bash scripts after executing commands within the scripts employing echo $? . Here’s a simple example:

The above script first runs the date command and prints the exit code using echo $? . The value of 0 denotes the successful execution of the date command. In addition, after running the cp command , the exit code is returned as 1 which indicates that the cp command is missing arguments. That’s how it is possible to get the exit codes of the executed command using Bash scripts.

Common Bash Exit Codes with Meaning

The table below shows 7 commonly encountered exit codes along with mentioning their meanings and typical examples of where one might encounter such codes:

7 Examples to Use Exit Codes on the Command Line

This section will shed light on 7 examples to show how to use the exit codes on the command line. These examples will cover the most common exit codes (0, 1, 2, 126, 127, 130, 255) with their basic meanings and command-specific manipulations.

Example 1: Exit Code 0

The typical exit code after the successful run of a command is zero (0). For example, run the following command in the terminal:

Example 2: Exit Code 1

As stated in the table above, the exit code 1 signifies generic errors such as missing operands. To see this in action, execute the command below:

Example 3: Exit Code 2

The exit code 2 denotes failure such as the “no such file or directory error” when a user attempts to access a file or directory that is not present in the system. For instance, to list the items of a directory named players that does not exist, run the following command:

Example 4: Exit Code 126

When the system encounters an issue related to permission, Bash returns an exit code of 126.

Run the following command in the terminal to create a script named file.sh:

Example 5: Exit Code 127

The exit code 127 is returned by the system if the command to be executed doesn’t exist or is even not present in the PATH environment variable. For example, you can run the below line of code on the terminal to get a hands-on illustration:

Example 6: Exit Code 130

If any command or process execution is terminated by pressing CTRL+C , then the system returns exit code 130. Here’s an example:

Example 7: Exit Code 255

The exit code of 255 also refers to an error condition but the nature of the error varies on the context in which it occurs. To produce the exit code 255, you can run the following command:

How to Use Exit Codes in Bash Scripts

In Bash scripting , one can utilize exit codes to determine whether a set of commands has been executed successfully or encountered issues. These codes can be employed directly or stored in a variable for later evaluation.

Below is an example script to use exit codes directly:

The above script takes two commands (date and mkdir) to execute and also uses the command echo $? to get the respective exit statuses. After executing the script, the date command returns 0 since it runs successfully within the script. However, the mkdir command has no arguments; so it is executed but with the missing operand error. That’s why its exit status is 1.

1. Control Bash Script Flow Using Exit Codes

The exit codes are very useful in Bash scripts to control the flow of execution depending on the success or failure of the previous command. This can be done easily by using if-else conditional statements and exit codes as conditions. Here’s how:

The above script uses the command cd polash to change the directory to polash and stores the exit code in the status variable using the special variable $? . Then it decides to proceed further or not by checking the existence of the polash directory using the if conditionals with exit code value as a condition and selects to execute either the if block or the else block. This is how the above script controls its execution flow using exit codes.  

2. Check if a User is Valid Using Exit Codes

You can make use of Bash exit codes to check if a user exists in the system as a valid user or not. See the below scripting example to see exit codes in action to check whether a user is valid:

The script above prompts the user to enter a username, then searches for that username in the /etc/passwd file. If the username is found, it prints “Valid user” and attempts to switch to that user using the su command and with the provided user password. If the username is not found, it prints “Invalid user”.

Custom Exit Codes in Bash

In working with Bash scripts, you can also define your exit codes to control the execution flow of the script. To do so, use the Bash exit command with the status code afterward. The syntax is exit [n] where n is the custom exit code you want to assign. Here’s an example:

The above script checks if a file exists at the specified path /path/to/somefile . If the file is found, it prints “File found” to the standard output and exits with a custom exit code of 0, indicating success. If the file is not found, it prints “File not found” to the standard output and exits with a custom exit code of 1, indicating failure. That’s how the exit command with the custom exit codes denotes success or failure.

How to Use Logical Operators with Exit Codes in Bash

The logical operators (and) && and || (or) can be used with exit codes to control the execution flow of a process. For example, open the terminal and run the following command to check the validity of the user sowad using exit codes and logical operators:

The above image states that the user sowad is valid (returns exit code 0) and the system uses the su command to switch the user to “sowad” with the use of the && (and) logical operator.

Bash Exit Codes in Piped Commands

Sometimes handling exit codes in piped commands may become necessary in Bash. In the case of the piped commands, the exit code of the entire pipeline is the exit code of the last executed command. Below is an example command to run on the terminal for exploration:

In the above case, the ls no_directory command fails, still the exit code is 0 due to the successful run of the wc -l command.

In addition, the PIPESTATUS array is useful in working with piped commands in Bash since it stores the exit codes of all the commands used in the pipeline. For example, to check for the exit code of the first command (ls no_directory) that failed in the previous pipeline, use the below code:

This article discusses exit codes in Bash that play an integral part in command-line operations or scripts by facilitating error handling, debugging, conditional execution, etc. It has mentioned some common exit codes with their usual meanings. It also discusses multiple examples to provide a clearer view of the exit code concept for both command and scripting-based scenarios.

People Also Ask

What does the exit code do in bash.

The exit code in Bash notifies if a command or script has run with success or not. It is a numerical value returned by Bash for any command executed in the terminal. The value can be either zero or non-zero to indicate success or any failure after execution. For instance, a command or script which typically succeeds in execution, has an exit code of zero. On the other hand, any non-zero exit code (1-255) indicates failure.

What does $? mean in Bash?

The $? mark (dollar question mark) is a special variable that holds the exit code or exit status of the last executed command. It is a specific shell variable reserved to find out if the command has been executed with success or not. You can use the command echo $? to print the code held by $? on the screen.

How to check the exit code of the last executed command?

To check the exit code of the last executed command, open the terminal and run the command echo $? . This returns the proper exit status of the very last command you executed.

What does the exit code 0 mean in Bash?

The exit code 0 in Bash means the successful execution of a command or a script. It signifies that the specified command or script has run but without errors. This you can find by running the command echo $? . For instance, after running the command whoami , you can run the command echo $? to get 0 and ensure that it runs with success

How do exit code 0 and exit code 1 differ in Bash?

Exit code 0 and exit code 1 differ primarily in what they indicate after the command or script execution. For example, exit code 0 signifies a successful execution. When a command or script runs without encountering errors, the exit code 0 is returned. On the other hand, exit code 1 is returned when the command fails to execute properly denoting the error condition.

Can I find the exit status of a command?

Yes , you can find the exit status of a command. To find the exit status of a command, use the special variable $? With the echo command after execution. The full syntax is echo $? . For example, after running the pwd command in the terminal, you can use the command echo $? to find the exit status of pwd . This will return a numeric value to indicate whether the “pwd” command has run with success or encountered errors.

Do the terms “exit code” and “exit status” refer to the same meaning in Bash?

Yes . The terms “exit code” and “exit status” typically refer to the same concept. Both terms are used interchangeably to denote a numerical value returned by a command when it terminates. This, in turn, indicates if the command has run successfully or has encountered any errors while executing. Typically the exit code 0 indicates success while a non-zero value indicates an error condition or failure.

Does an exit code display the output of a command?

No . The exit codes do not display the output of a command. It’s a numerical value returned by a command upon its completion to indicate that the command has been executed with success or encountered an error. The code is accessed by $? in Bash and you can run the command echo $? to display the code on the terminal.

Is it possible to store the exit status of a command to a shell variable?

Yes , it is possible to store the exit status of a command to a shell variable. To do so, assign the exit status to a shell variable by using the syntax variable_name=value . For example, after running the ls command, you can use the code status=$? to store the exit status or exit code of the ls command in the status variable.

Are there any alternative methods to handle exit codes in Bash?

Yes . There are commands like set -e and trap that are useful tools to alternatively handle exit codes in Bash.

Related Articles

• 4 Methods to Exit Bash Scripts on Error with Message
• Usage of “exit” Command in Bash [Explained]
• How to Set Exit Codes in Bash? [An Easy Guide]
• How to Set & Use Pipefail in Bash [Explained Guide]
• Bash PIPESTATUS to Handle Exit Codes of Piped Commands
• [4 Methods] How to Check Exit Code in Bash?
• [Explained] What Are “exit 0” and “exit 1” in Bash?

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

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 Cancel reply

Save my name, email, and website in this browser for the next time I comment.

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

How can I get the result of a command and its return code at the same time in a Bash script?

I am playing with Bash scripts. I'd like to assign the result of a command to a variable and its return code to another one.

I tried to use $? as shown above but it captures the return code of the previous assignment itself, which is 0.

How can I do that?

• bash-scripting

• 1 The commands you show set cmd_return_code to the exit status of the pipeline in the command substitution; i.e., the exit status of the last command in the pipeline ( wc -l ). If that’s what you want, what evidence do you have that it’s doing something different? If you want something different, what is it?  (P.S. Your command features a UUOC (useless of cat ).  line_count=$(wc -l < "$filename") would be more efficient, and might give you the results you want.) –  G-Man Says 'Reinstate Monica' Apr 21, 2018 at 22:14

2 Answers 2

The problem here is that in the pipeline cat "$filename" | wc -l , when the file doesn't exist cat will exit with an error, but wc -l will successfully count the 0 lines of text it receives from cat . The exit status of the last command in the pipeline is treated as the final status of the pipeline as a whole, so the whole pipeline is considered to succeed. Like this:

Normally in bash, you can get the statuses of individual command in a pipeline with the PIPESTATUS array, like this:

...but that doesn't work with a pipeline in a command expansion like $( ) , because that pipeline is going to execute in a subshell, and PIPESTATUS can't propagate from the subshell; only the final status gets passed back to the parent shell:

So, what can you do about this? Well, as l0b0 said, one possibility is to set the pipefail option. You don't have to do this for the entire script, you can set it just for that particular subshell by doing it within the command substitution:

For this particular command, you can also eliminate the pipeline (it's what's called a Useless Use of cat, or UUOC ), and have wc read directly from the file, either by passing the filename as a parameter:

...or by using an input redirection:

There are a couple of differences between these two options: if you pass the filename to wc (and it exists), it'll output the filename as well as the number of lines:

...while with the redirect option it won't. Also, with the second option the shell is responsible for opening the file (and handing the open file handle to the wc command), so if that fails it's the shell that gives an error (note that the error message comes from "-bash", not wc ) and wc never gets run.

The exit code of an assignment of a command substitution is the exit code of the command substitution. See for example the exit code of foo="$(false)" .

To make the exit code of a pipeline the exit code of the the first failing command in the pipeline:

You must log in to answer this question.

Not the answer you're looking for browse other questions tagged bash bash-scripting ..

• The Overflow Blog
• The reverse mullett model of software engineering
• Reshaping the future of API platforms
• Featured on Meta
• Testing a new version of Stack Overflow Jobs
• Our Partnership with OpenAI

Hot Network Questions

• Vertical spacing of argmin subscript
• Can a Forcecage be destroyed with brute force?
• What happens if someone leaves a train to/from Pyongyang at an intermediate stop?
• Are London dispersion forces in xenon tetrafluoride strong enough to make it a solid?
• Why does this vintage DRAM chip enable circuit require such a beefy resistor?
• If gravity is not a force, what makes massive objects spheroid?
• Why are almost all winglets turned upwards?
• Can changelings instantly change their hairstyle?
• What happens when you don't pay your property taxes?
• Why add the word "solid" to the verb "freeze"? — e.g.: "The clothes froze solid on the washing line." — Will the meaning change if we remove "solid"?
• Two passports, one name transliterated slightly differently
• Help choosing right chainset / crankset - commuter looking for a faster top speed
• Colleague Plagiarizes Entire Course Content
• What is the collective name of the four points in the narrative where a roll might be called for?
• Can I splice large wire for long runs?
• Will installing a kernel mode driver onto a PC compromise the entire network it's connected to?
• Does the pre-Laryngeal Brugmannian synthesis of PIE fully explain attested non-Anatolian data?
• Fred closes a stranger's truck door; the truck later burns down. What is Fred's liability?
• An SF novel about monasteries which are isolated from the external world for 1, 10, 100 or 1000 years
• What is the purpose of these fat copper coils wrapped around … something?
• Can Blindness/Deafness Condition caused by Find Familiar etc be removed by Lesser Restoration?
• jq skip iteration over null
• Detergent spilled into lint trap
• Why did Nicodemus visit Jesus at night?