bash script conditional assignment

Brandon Rozek

PhD Student @ RPI studying Automated Reasoning in AI and Linux Enthusiast.

Conditional Assignment in Bash

Published on June 19, 2022

Updated on February 9, 2023

Many programming languages include an quick way to perform a conditional assignment. That is, assigning a variable with a value based on some condition. Normally this is done through a ternary operator. For example, here is how to write it in Javascript

The variable ageType is dependent upon the value of age . If it is above 18 then ageType = "Adult" otherwise ageType = "Child" .

A more verbose way of accomplishing the same thing is the following:

How do we do conditional assignment in Bash? One way is to make use of subshells and echoing out the values.

A common programming feature called short-circuiting makes it so that if the first condition ( [ $AGE -gt 18 ] ) is false, then it will skip the right side of the AND ( && ) expression. This is because False && True is always False . However, False || True is equal to True , so the language needs to evaluate the right part of an OR ( || ) expression.

Published a response to this? Let me know the URL :

Table of contents

Bash test commands, compounding comparison operators, integer comparison operators, string evaluation operators, file evaluating operators, if statements, if-else statements, if-elif-else statements, nested if statements, case statements, handling script failures using conditionals, storing script output.

• ‣ Loops In Bash
• ‣ Understanding Bash Shell
• ‣ Bash Variables Explained
• ‣ Shell Script Functions Guide
• ‣ Bash File Reading

Using Conditionals in Bash

In this Series

Table of Contents

Understand Bash conditionals with our new article. Earthly ensures consistent builds in different environments. Learn more about Earthly .

Bash (bourne again shell) has been around since 1989 and owes its longevity to its usefulness and flexibility. While it’s the default login and command shell for most Linux distros, its value extends beyond that.

Bash can be used as a fully-fledged programming language and as a tool to automate repetitive and complex computational tasks. However, as with any other programming language, you need to understand how to manage Bash’s control flow to truly get the most out of it.

Whether you’re a power user writing simple scripts to help organize your files or a data scientist curating large sets of data, efficiently performing these tasks is nearly impossible without a conditional statement or two.

The following guide will introduce you to Bash’s collection of conditionals and will teach you how to become proficient in their uses.

What Are Bash Conditionals

Bash conditionals let you write code that performs different tasks based on specified checks. These checks can be based on a simple assessment that results in a true or false result. Alternatively, a conditional may be in the form of a multiple case check where a number of values are assessed before an operation is performed.

Conditionals make programmers’ lives easier and help prevent and handle errors and failures. Without them, you’d have to manually perform checks before running a script or program. However, to build functioning conditionals and test expressions in Bash, you need a working knowledge of its test commands and operators. Before you review all the conditionals available, you need to learn how to build proper tests, starting with Bash’s test commands.

Bash can be a very loose and flexible language. Many concrete concepts you’d find in other programming languages are absent, and you have to use conventional design patterns to make Bash work the same way other programming languages do.

For instance, conditionals assess the exit status of a command. If you want Bash to mimic Boolean evaluations, you’ll need to use a specialized command. There are three ways you can test an expression in Bash:

• test : takes an expression as its argument and evaluates it ( ie it exits with a status code dictated by the expression). It returns 0 to indicate that an expression is true. A value other than 0 ( ie 1 ) would indicate that it’s false. For instance, test $n -gt 5 evaluates if the value of the variable $n , is greater than five, and returns an exit code of 0 if true.

You can use the $? variable to see the return value of the last executed command ( ie to see if the test command evaluated its expression to true or false).

• [ : is a shorthand alternative version of the test command. It does exactly what the test command does but with a slightly different syntax: [ $n -gt 5 ] .

Note: The [ built-in requires at least a single space after the opening bracket and one before the closing bracket.

• [[ : is an improved version of the [ built-in. It also evaluates an expression but with a few improvements and caveats. For instance, Bash doesn’t perform glob expansion or word splitting when parsing the command’s argument. This makes it a more versatile command. [[ is also slightly more lenient on syntax and allows you to run more modernized tests and conditions.

For instance, you can compare integers using the < and > operators. [[ $n > 10 ]] tests if the value of the n variable is greater ( -gt ) than ten. It will return an exit code based on this test. On the other hand, [ $n > 10 ] creates a (empty) file called 10 , and in most cases, it will return an exit status of 0 (barring that nothing stops it from creating the file).

Again, because the [[ command skips glob expansion and word splitting, it makes testing regular expressions easier. For instance, the arguments of the command [[ $n =~ [1-10] ]] will cause the [ command to fail. For this reason, many use cases require using this command over the test keyword or [ built-in.

Bash Test Operators

Now that you, hopefully, understand how Bash’s test commands work, you can learn how to form test expressions. The core of the expressions is test operators . If you want to take full advantage of conditionals, you need to have a healthy understanding of them.

Bash has a large variety of test operators that apply to different variable types and situations. These operators are just flags passed to the test commands and include the following:

Compounding comparison operators allow you to combine test expressions. They return a value based on a test performed on multiple expressions:

• -a : is the and operator. It lets you test multiple conditions and returns true if all conditions are true ( ie if [ $n -gt 10 -a $n -lt 15 ] ).
• -o : is the or operator. It lets you test multiple conditions and returns true if one or more conditions are true ( ie if [ $n -gt 10 -o $n -lt 15 ] ).

Integer comparison operators let you build expressions that compare whole numbers in Bash:

• -eq : tests if two values/variables are equal ( = or == )
• -ne : checks if two values/variables are not equal ( != )
• -gt : checks if one value is greater than another ( > )
• -ge : checks if one value is greater than or equal to another ( >= )
• -lt : checks if one value is less than another ( < )
• -le : checks if one value is equal or less than another ( <= )

You can use the symbols ( < , > , = , != , etc.) in place of the above word-based operators when using the [[ built-in.

String evaluation operators let you compare and evaluate strings of text in Bash:

• == or = : checks if two strings are equal
• != : checks if two strings are not equal to each other
• < : checks if one string is less than another using the ASCII sorting order
• > : checks if one string is greater than another using the ASCII sorting order
• -z : returns true if the string is empty or null (has a length of zero)
• -n : returns true if a string is not null

These advanced operators let you assess and compare files in Bash:

• -e : validates the existence of a file (returns true if a file exists)
• -f : validates if the variable is a regular file (not a folder, directory, or device)
• -d : checks if the variable is a directory
• -h (or -L ): validates if the variable is a file that is a symbolic link
• -b : checks if a variable is a block special file
• -c : verifies if a variable is a character special file
• -p : checks if a file is a pipe
• -S : checks if a file is a socket
• -s : verifies if the size of the file is above zero (returns true if the file is greater than 0 bytes)
• -t : validates if the file is associated with a terminal device
• -r : checks if the file has read permissions
• -w : verifies if the file has write permissions
• -x : checks if the file has execute permissions
• -g : checks if the SGID flag is set on a file
• -u : verifies if the SUID flag is set on a file
• -k : checks if the sticky bit is set on a file
• -O : verifies if you’re the owner of a file
• -G : validates if the group ID is the same as yours
• -N : validates if a file was modified since it was last read
• -nt : compares the creation dates of two files to see if one file (file 1) is newer than the other (file 2)
• -ot : compares the creation dates of two files to verify if one file (file 1) is older than the other (file 2)
• -ef : checks if two variables are hard links to the same file

Conditional Statements

The first category of conditionals you’ll look at is known as conditional statements. Each statement assesses a singular condition (which can be compounded from multiple conditions) and performs an action (or list of actions).

The if statement is the most commonly used conditional in any programming language. The structure of a simple if statement is as follows:

The first line assesses a condition (any command). The fi indicates the end of the if statement (along with its body). Bash evaluates a command’s exit code before performing (or skipping) an action (or set of actions). If a command returns an exit code of 0 , it has run successfully. In that case, the if statement will run the command(s) between the then and fi keywords.

A status code with any other value (1–255) denotes a failure and will cause the if statement to skip over the statements between the if’s body. While Bash doesn’t have true built-in conditions, you can co-opt and use its command status codes as a makeshift boolean, where 0 is true and any other value is false. You also have true and false , which are actual commands that return 0 and 1 , respectively.

Take a look at the following example:

The code here first assigns the number of files in the current directory to a variable ( n ). It then uses the test operator -lt to test if the number count is less than ten. If the test condition is true, the command ( [ $n -lt 10 ] ) will exit with a status of 0 , returning an exit code of 0 . Then it displays a message informing the user that there are less than ten files in this particular directory.

Of course, this sample can be repurposed and used for more practical applications, like deleting files in a folder when they exceed a certain number.

An if-else statement allows you to call an alternative command when an if statement’s condition evaluates to false ( ie when its command returns an error status code). In most cases, the else portion of the statement provides you a chance to perform some cleanup. For instance, you can use it to exit the script or inform the user that a condition has not been met. The syntax of the if-else statement is as follows:

You can modify the previous example:

This time, the if-else informs the user that there are more than ten files instead of just exiting the script when it doesn’t meet the first condition.

The if-elif-else statement lets you add more functionality to the basic if and if-else statements. You can test multiple conditions and run separate commands when a condition is met.

Because things in the real world aren’t always limited to two alternatives, you need conditionals with more nuance to suit complex use cases. The if-elif-else statement provides this subtlety. Its structure is as follows:

Again, you can modify the last example:

elif is essentially a shorthand of an else-if statement that you may recognize from other fully formed programming languages. In the example above, you check if there are less than ten files. If there are more than ten files, your else-if conditional expression will check if there are less than fifteen files. If both conditions are not met—in this case, the directory has more than fifteen files—then the script will display a message indicating this.

If you want to add more refinement to your if and elif conditionals, you can use a nested or embedded if statement. A nested if lets you perform an additional check after a condition is met by an if statement. The structure looks like this:

Of course, Bash doesn’t require you to indent code. However, it’s easier to read the above syntax if you do. Here’s how the nested if looks in action:

Here, you’ve added a nested if to your previous example. To start, it checks if the current directory has less than ten files. If the command runs successfully, it performs another check to see if there are more than five files and then displays a message accordingly.

Case statements are one of the most important control flow tools for advanced programming. They work similarly to if-elif-else statements, but when employed correctly, they can help produce cleaner code. The syntax for a case statement is as follows:

Here, rather than using a condition, you test a variable that will be compared against the patterns, and when a match is found, the corresponding action(s) will be performed.

The structure may be a little hard for beginners to understand, but the more you use it, the more comfortable you’ll become. Again, you can modify the previous examples with case statements:

This time, the example takes the file count and assesses it against twelve different patterns, which are all simple numbers. It displays a message with every pattern it suits. The pattern * acts as a catchall and will match if none of the other patterns match.

You can also combine multiple patterns with | :

As you may have noted, the command list associated with each pattern ends in ;; . However, you can also use ;& or ;;& . If you use ;& , the execution will continue with the next clause even if the next pattern doesn’t match (a fall through).

If you use ;;& , the execution will continue with the next clause, only if the pattern matches:

As this guide has discussed, each command returns an exit code. Conditionals use these exit codes to determine which code should be executed next. If a function, command, or script should fail, a well-placed conditional can catch and handle this failure.

Bash has more sophisticated tools for error handling ; however, if you’re performing quick and dirty script failure handling, simple if or case statements should be sufficient.

When troubleshooting or keeping a record of successful and failed scripts, you can output the results to an external file. The above guide has already touched on how you can output the results of a command using the > operator. You can also keep a record of script errors by using a combination of exit code tests, conditionals, and this operator. Here’s an example:

The above snippet will check if the current directory has less than ten files. If it does, it will output a success message to a file named success.txt . If it fails, it will redirect the echo command’s output and place it in a file named fail.txt .

The > redirection operator will create a new file and write the output on that new file if the file doesn’t exist. However, if the file does exist, the command will overwrite its contents. Thus, you should use the >> operator if you want to append contents to an existing file. These are the simplest ways to redirect output from Bash and place it on an external file.

Learning conditionals could be your final hurdle to truly understanding Bash and mastering it. Up until now, you may have underestimated Bash’s true capabilities. You may even find that learning about Bash’s various conditional statements, expressions, and operations inspires you to rewrite old scripts and improve them with better flow control.

But if you do, remember to utilize the correct syntax. Bash (especially sh) is case- and space-sensitive. Then you can transfer what you’ve learned from Bash and use it with Earthly . Earthly lets you define and deploy your build using a Git-aware syntax that is strikingly similar to Bash.

Because Earthly’s builds are neatly encapsulated and language-independent, they’re easier to initiate and manage. If you’re trying to build and deploy repeatable multiplatform software, Earthly is a great solution.

Earthly Cloud: Consistent, Fast Builds, Any CI Consistent, repeatable builds across all environments. Advanced caching for faster builds. Easy integration with any CI. 6,000 build minutes per month included.

Get Started Free

12 minute read

Learn how to use loops in Bash to control the flow of your programs. This article covers the different types of loops in Bash, including `while`, `until`, an...

19 minute read

Learn the ins and outs of bash scripting and how it can make your life easier. From understanding shebangs to error handling and variable naming, this articl...

9 minute read

Learn the basics of bash variables and how they work in the UNIX shell. Discover how to define and access local shell variables, work with arrays, handle com...

13 minute read

Learn the fundamentals of shell scripting functions and arguments in this comprehensive guide. Discover how to create functions, pass arguments, use variable...

8 minute read

Learn how to use Bash to read files line by line, use custom delimiters, assign variables, and more. This article provides step-by-step instructions and exam...

11 minute read

Learn how to manipulate strings in bash with this informative tutorial. From concatenating strings to replacing parts of a string, you'll discover useful tec...

Learn why using YAML for control flow configuration can lead to complex and hard-to-understand code, and why it's better to use existing programming language...

27 minute read

Learn how to automate common tasks in software development using shell scripts. From file backups to log analysis and system maintenance, this article provid...

18 minute read

Learn fifteen essential Linux terminal commands that will supercharge you as a Linux user. From searching for patterns in files to managing permissions and s...

Learn how to use the `echo` command in Linux to display text, format output, add and overwrite text in files, display variables, search for files, and more. ...

• IT Management
• Infrastructure
• High Performance

Conditional Statements In Bash Explained With Examples

This guide explains how to work with conditional statements in bash scripting, and how to write compact conditional statements with examples.

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends, & analysis

CachyOS’s May Release Adds Bcachefs File System Support

How to migrate centos 7 to oracle linux 8 with ease, red hat unveils enterprise-ready ai distribution, debian’s decision to cut keepassxc features sparked debate, immich 1.104 brings direct editing and email notifications.

LinuxToday is a trusted, contributor-driven news resource supporting all types of Linux users. Our thriving international community engages with us through social media and frequent content contributions aimed at solving problems ranging from personal computing to enterprise-level IT operations. LinuxToday serves as a home for a community that struggles to find comparable information elsewhere on the web.

• Privacy Policy
• California – Do Not Sell My Information

Advertiser Disclosure: Some of the products that appear on this site are from companies from which TechnologyAdvice receives compensation. This compensation may impact how and where products appear on this site including, for example, the order in which they appear. TechnologyAdvice does not include all companies or all types of products available in the marketplace.

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 do I write a conditional assignment in a Linux script?

I need to create a formula in a Linux shell script. If this was DOS, I'd (probably) be fine, but I've made the change and need to learn....!

D1 = a 5-digit number between 40500 and 49500 (this is atmospheric pressure data from an airport SYNOP report)

D2 = the last four digits of D1 (I can do that)

D3 = the first digit of D2 (I can do that as well)

D4 will be D2 divided by 10, to which 1000 is added only if D3=0.

I'm looking for something like: IF D3=0 THEN D4=((D2/10)+1000) ELSE D4=(D2/10)

Thanks, Nigel.

• shell-script
• conditional-statements

• The tools sh , bash and others, they are far harder to master than Microsoft batches. Start from here: The GNU bash documentation –  174140 Dec 13, 2013 at 11:46

You've pretty much got it down already, and it's down only to minor syntax problems.

What you have, in pseudocode, is pretty much this:

which translates to, in bash (which is what you'd be most likely to use for shell scripting in Linux):

You need the fi to end the if statement, and $(( ... )) is arithmetic expansion in bash. Note that $( ... ) is completely different; that is process substitution which takes the output of the given command and returns it. Highly useful, but not really what you are after here.

The above assumes that $d2 , $d3 and $d4 are already set to the correct values, and that there are no environment variables with conflicting names set.

If you know for a fact that $d3 will never contain anything but digits you can do away with the quoting in the parameters to test , but I like to keep it in as a safety net. To learn more about what you can do with test (in bash), have a look at man bash under the Shell builtin commands heading. Other shells may use the external command, in which case man test applies (you can use the external command in bash e.g. through if command test ...; then if you prefer that for some reason).

The semicolon before the then is needed because then really is a separate command in bash; you could also put then on a separate line and omit the semicolon, which is another way of formatting exactly the same thing.

• Michael, many thanks. In my code, D2 appears to assume the actual formula 'cut -c2-5 D1.txt' rather than the output of that formula. –  user277524 Dec 16, 2013 at 21:23
• In my script I have: D2='cut -c2-5 D1.txt' $D2 # D3=first digit of D2 D3='cut -c2-2 D1.txt' $D3 if test "$D3" -eq "0"; then D4=$(( ( $D2 / 10 ) + 1000 )) else D4=$(( $D2 / 10 )) fi $D4 The variables echo their correct values, but the test function fails with: /home/pi/update-pressure-db.sh: line 13: test: cut -c2-2 D1.txt: integer expression expected /home/pi/update-pressure-db.sh: line 16: cut -c2-5 D1.txt / 10 : syntax error: invalid arithmetic operator (error token is ".txt / 10 ") It looks as though the value of D3 is literally 'cut -c2-2 D1.txt' . Help! –  user277524 Dec 19, 2013 at 23:08
• @user277524 You have d3='cut -c2-2 D1.txt' but want d3=$(cut -c2-2 D1.txt) . It's the difference between literal assignment and assignment of the output of process substitution. If that does not help, I strongly suggest that you ask a new question about that problem rather than posting in a comment. –  user Dec 20, 2013 at 9:01

You must log in to answer this question.

Not the answer you're looking for browse other questions tagged linux shell-script conditional-statements ..

• The Overflow Blog
• Why do only a small percentage of GenAI projects actually make it into...
• Spreading the gospel of Python
• Featured on Meta
• Our Partnership with OpenAI
• Imgur image URL migration: Coming soon to a Stack Exchange site near you!

Hot Network Questions

• How to track PBKDF2 progress?
• Where can I find a Jehovah's Witnesses version of a Hebrew Interlinear Old Testament?
• Must a domain of discourse always be specified in universally quantified statements?
• Can I cite the results from my unpublished manuscript which is included in my PhD thesis?
• Is it illegal for a company to cross out the "To the order of" line on a check and change companies being paid?
• Editing/viewing a password protected file?
• Brocard's Conjecture Candidate Finder
• In a GLM model with a gamma log link, how to interpret a negative coefficent of a dummy variable with a continuous response?
• Where did Jesus perform the “Feeding of the 4,000"?
• Number of ways a positive integer n can be expressed as a sum of k natural numbers under a certain ordering condition
• As 'beiseiteschieben' did not officially exist before 2006, why do we treat this (official) new form as primary and call it a "separable" verb?
• Mtg: attacking effect, but the creature dies
• Fully electric flamethrower
• Can somebody explain to me how this circuit actually works? (Linear voltage regulator and PNP transistor as current boost)
• Bubbly foamed cone with insect inside
• Allow commercial use, but require removal of company name
• Is it common to win a war with a strictly defensive posture?
• Civicrm install on Drupal 10 -- packages downloaded but cv command not found for installation
• How’s the interest adjusted for additional Principal payment?
• Why divide data into 4 parts for IQR, and not into parts of 20 or 10 percentages each?
• Estne in lingua Latina verbum pro die ante heri?
• Simple or Complicated mechanics, what benefits they have and should I be worried about overcomplication?
• How to change default "and" in amsart title
• Proverb for someone who mistakenly assumes he has found the right answer and is unwilling to accept his error?

Home > Bash Scripting Tutorial > Bash Conditional Statements > If Statement in Bash > How to Use Flags in Bash If Condition? [With Example]

How to Use Flags in Bash If Condition? [With Example]

Flags refer to the options, or switches in Bash that specify and customize various settings and change the behavior of commands, scripts, or functions accordingly. Generally, flags are prefixed with a hyphen (-) or double hyphen (- -) . For example, ls -l ; where the -l flag/option instructs the ls command to list files in long format.

In Bash, you can use flags or options to control the behavior of your script. These flags are typically passed as arguments when executing the script. You can then check for the presence of these flags using conditional statements like ‘if’. Explore the following article to learn about Bash flags and their versatile usage.

What are the Types of Flags in Bash?

There are two main types of flags in Bash. They are:

• Short Flags: Short flags consist of single characters, hence they are also known as single-letter flags. Short flags are usually prefixed with a single hyphen (-). For example, -l, -f, -v, etc.
• Long Flags: Long flags are represented by a double hyphen (- -) followed by a descriptive name (a whole word or phrase). These flags are more descriptive and readable. For example, – -list, – -force, – -version, etc.

What are If Flags?

If flags are the structures in Bash where the if statement uses different flags within the test expression and performs conditional executions based on the conditions. The basic syntax of Bash if flags is:

Benefits of Using Flags for Complex If Conditions

The benefits of using flags are:

• Clarifies the conditions within complex if statements.
• Breaks down complex conditions into small and manageable portions.
• Provides flexibility to modify conditions per needs.
• Aids in debugging by identifying issues within conditions.
• Enhances efficiency by enabling reusability of conditions across different parts of the code.

Uses of Flags in If Condition

The use cases of flags are so versatile that they allow users to customize the execution of a script or command by specifying certain parameters or settings. Here are some basic use cases of different Bash flags including simple conditional testing, nested conditional execution and command-line arguments.

1. Flags in Single If Block

Bash flags combined with conditional statements allow users to execute different parts of the script conditionally or to modify its behavior based on user inputs or system conditions. Here’s an example of a simple condition execution of Bash flags:

Here, the -f flag within the if [ -f $filename ] syntax checks whether the file defined in the $filename variable exists and is a regular file. If the condition is true, the script echoes a successful message displaying the contents of the file.

2. Flags in Nested If Block for Handling Multiple Conditions

Nested-if flags involve using multiple if statements within each other to check various conditions based on the presence or absence of certain flags.

Review the following script to handle multiple conditions using nested if flags:

First, the outer if statement if [ -e $1 ] checks if the file or directory specified by $1 exists using the -e flag/option. If the condition is true, it prints a message showing its existence. Then, the inner if statement if [ -d $1 ] checks if the existing one is a directory using the -d flag. If the condition evaluates to true, it prints a message. Otherwise, elif [ -f $1 ] using the -f flag checks if the existing one is a regular file. If it is a regular file, the script prints a message.

If the outer if condition evaluates to false, the script executes the else block and prints a corresponding message.

In the image, you can see that ‘my_dir’ exists in my system and is a directory.

3. Flags as Command-line Arguments

You can pass flags as command line arguments in a Bash script. For example, to display usage information with “-h” or “–help” flag, go through the following script:

Here, if [ "$1" = "-h" ] || [ "$1" = "--help" ] checks if the first argument ( $1 ) passed to the script is equal to either -h or –help . If the condition is true, echo "Usage: $0 [-h] [-f] [-v]" prints the usage message where $0 returns the name of the script. Then, echo "Options:" prints the header for the list of options. Next, the echo command prints the usage instructions along with the available options. Finally, exit 0 exits the script with a status code of 0, indicating successful completion.

From the image, you can see that when I run the script with the “-h” or “–help” flag as the first argument, it displays the usage information.

What are the Flags for Error Handling?

To avoid unexpected errors, using the effective Bash flags is necessary. This section interprets some must-know Bash flags that aid in debugging and error handling.

1. “-e” Flag

The ‘-e’ flag when enabled using ‘set’, i.e. set -e , instructs the script to terminate immediately whenever a command returns non-zero output, indicating failure. This option is also known as errexit and is used at the beginning of the script to catch errors earlier.

Check out the following script to handle errors using the set -e option:

From the image, it is clear that the script terminates as soon as the rm command fails to remove the file ‘distro.txt’ from the given path. Even it doesn’t print the message within the echo command.

2. “-u” Flag

The set -u option is referred to as the nounset option. The “-u” flag here helps catch unset variables, treat them as errors, and make the script terminate immediately. This is useful to avoid accidentally misusing uninitialized variables.

In the image, when the -u flag is enabled, the script treats the unset variable as an unbound variable error and exits immediately.

3. “-o” Flag

To enable the -o flag, use the set -o pipefail option. This option makes the script fail if any of the commands within the pipeline fail. In this effort, the script by default considers the exit status of the last command in the pipeline. Here’s an example:

In the image, when the set -o pipefail option is enabled, the script terminates because of the failure of the cat command. Even, the script doesn’t continue to the grep command.

4. “-x” Flag

Using the set -x option (also known as xtrace ) enables the -x flag in a script. It displays every command before its execution which helps in debugging. Following is such a script:

The image shows the commands (the highlighted parts) along with their respective outputs.

How to Set Flag Values in Bash?

The getopts  is a shell built-in command that allows users to parse command-line options and arguments. So, to set and handle flag values, use the ‘getopts’ command with a case block. The following script shows how:

First, while getopts ":i:o:" choice; do initiates a while loop that uses the getopts command to parse command line options. Here, :i:o: specifies two flags ( -i for input directory and -o for output file) that the script expects and choice is the variable that stores the processed option flags.

Inside the case statement, when the flags -i and -o are provided, the variables input_dir and output_file store the values of the respective arguments accordingly. Finally, the script echoes the values of the parsed options.

From the image, you can see that when the -i flag is provided, the script outputs its value ‘bash’. When the -o flag is provided, the script prints its value ‘distro.txt’. And when both flags are provided, the script echoes both values.

How to Set the Prompt Input into a Flag?

To set an input from a prompt into a flag, use the read command with a case statement. Let’s see how:

First, the script prompts users with an input message. Then, the construct case $answer in ... esac performs conditional branching based on the value of the variable $answer . Next, [Yy]*) flag=true ;; checks if the input starts with either ‘Y’ or ‘y’. If it does, it sets the variable flag to true. Again, *) flag=false ;; checks if the input doesn’t match ‘Y’ or ‘y’, it sets the variable flag to false.

In conclusion, mastering the usage of Bash if flags opens up a plethora of opportunities for shell scripting enthusiasts and system administrators, I hope this article has provided you the strength and adaptability of conditional statements in regulating a script’s flow according to different circumstances.

People Also Ask

What are bash flags.

Bash flags are switches or options preceded by a hyphen (-) or double hyphen (–) that change the behavior of the commands or scripts. For example, -v or --verbose enables verbose mode (prints additional information), and -f or --force enables force mode (operates without confirmation).

How do I use bash flags?

To use Bash flags, you can either use the built-in getopts command or directly check the value of the positional parameters ($1, $2, etc.).

Can I nest if statements with bash if flags?

Yes , you can nest if statements with Bash If Flags. It allows one to perform complex conditional checking based on specific flag conditions. Here’s the basic structure of a nested if statement using Bash flags:

How to check the presence of a specific flag in Bash?

To check if a specific flag is present in Bash, compare command line arguments with the flag within an if statement. For example, the below script checks if the ‘-v’ flag is present in the first argument.

How can I handle flags in Bash scripts?

You can handle flags in Bash scripts using the built-in getopts command. Generally, getopts parses command-line options and processes them based on the specified flags. In addition, you can process flags manually by checking the values of positional parameters ($1, $2, etc.) or using conditional statements.

Related Articles

• Mastering 10 Essential Options of If Statement in Bash
• How to Check a Boolean If True or False in Bash [Easy Guide]
• Bash Test Operations in ‘If’ Statement
• Check If a Variable is Empty/Null or Not in Bash [5 Methods]
• Check If a Variable is Set or Not in Bash [4 Methods]
• Check If Environment Variable Exists in Bash [6 Methods]
• Bash Modulo Operations in “If” Statement [4 Examples]
• How to Use “OR”, “AND”, “NOT” in Bash If Statement [7 Examples]
• Evaluate Multiple Conditions in Bash “If” Statement [2 Ways]
• Using Double Square Brackets “[[ ]]” in If Statement in Bash
• 6 Ways to Check If a File Exists or Not in Bash
• How to Check If a File is Empty in Bash [6 Methods]
• 7 Ways to Check If Directory Exists or Not in Bash
• Negate an “If” Condition in Bash [4 Examples]
• Check If Bash Command Fail or Succeed [Exit If Fail]
• How to Write If Statement in One Line? [2 Easy Ways]
• Different Loops with If Statements in Bash [5 Examples]
• Learn to Compare Dates in Bash [4 Examples]

<< Go Back to If Statement in Bash | Bash Conditional Statements | Bash Scripting Tutorial

Nadiba Rahman

Hello, This is Nadiba Rahman, currently working as a Linux Content Developer Executive at SOFTEKO. I have completed my graduation with a bachelor’s degree in Electronics & Telecommunication Engineering from Rajshahi University of Engineering & Technology (RUET).I am quite passionate about crafting. I really adore exploring and learning new things which always helps me to think transparently. And this curiosity led me to pursue knowledge about Linux. My goal is to portray Linux-based practical problems and share them with you. Read Full Bio

Leave a Comment Cancel reply

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

Get In Touch!

Legal Corner

Copyright © 2024 LinuxSimply | All Rights Reserved.

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.

Next: Shell Arithmetic , Previous: Interactive Shells , Up: Bash Features   [ Contents ][ Index ]

6.4 Bash Conditional Expressions

Conditional expressions are used by the [[ compound command (see Conditional Constructs ) and the test and [ builtin commands (see Bourne Shell Builtins ). The test and [ commands determine their behavior based on the number of arguments; see the descriptions of those commands for any other command-specific actions.

Expressions may be unary or binary, and are formed from the following primaries. Unary expressions are often used to examine the status of a file. There are string operators and numeric comparison operators as well. Bash handles several filenames specially when they are used in expressions. If the operating system on which Bash is running provides these special files, Bash will use them; otherwise it will emulate them internally with this behavior: If the file argument to one of the primaries is of the form /dev/fd/ N , then file descriptor N is checked. If the file argument to one of the primaries is one of /dev/stdin , /dev/stdout , or /dev/stderr , file descriptor 0, 1, or 2, respectively, is checked.

When used with [[ , the ‘ < ’ and ‘ > ’ operators sort lexicographically using the current locale. The test command uses ASCII ordering.

Unless otherwise specified, primaries that operate on files follow symbolic links and operate on the target of the link, rather than the link itself.

True if file exists.

True if file exists and is a block special file.

True if file exists and is a character special file.

True if file exists and is a directory.

True if file exists and is a regular file.

True if file exists and its set-group-id bit is set.

True if file exists and is a symbolic link.

True if file exists and its "sticky" bit is set.

True if file exists and is a named pipe (FIFO).

True if file exists and is readable.

True if file exists and has a size greater than zero.

True if file descriptor fd is open and refers to a terminal.

True if file exists and its set-user-id bit is set.

True if file exists and is writable.

True if file exists and is executable.

True if file exists and is owned by the effective group id.

True if file exists and has been modified since it was last read.

True if file exists and is owned by the effective user id.

True if file exists and is a socket.

True if file1 and file2 refer to the same device and inode numbers.

True if file1 is newer (according to modification date) than file2 , or if file1 exists and file2 does not.

True if file1 is older than file2 , or if file2 exists and file1 does not.

True if the shell option optname is enabled. The list of options appears in the description of the -o option to the set builtin (see The Set Builtin ).

True if the shell variable varname is set (has been assigned a value).

True if the shell variable varname is set and is a name reference.

True if the length of string is zero.

True if the length of string is non-zero.

True if the strings are equal. When used with the [[ command, this performs pattern matching as described above (see Conditional Constructs ).

‘ = ’ should be used with the test command for POSIX conformance.

True if the strings are not equal.

True if string1 sorts before string2 lexicographically.

True if string1 sorts after string2 lexicographically.

OP is one of ‘ -eq ’, ‘ -ne ’, ‘ -lt ’, ‘ -le ’, ‘ -gt ’, or ‘ -ge ’. These arithmetic binary operators return true if arg1 is equal to, not equal to, less than, less than or equal to, greater than, or greater than or equal to arg2 , respectively. Arg1 and arg2 may be positive or negative integers. When used with the [[ command, Arg1 and Arg2 are evaluated as arithmetic expressions (see Shell Arithmetic ).