{"id":3038,"date":"2023-12-24T02:30:00","date_gmt":"2023-12-24T07:30:00","guid":{"rendered":"https:\/\/www.both.org\/?p=3038"},"modified":"2024-01-21T11:24:18","modified_gmt":"2024-01-21T16:24:18","slug":"programming-bash-3-logical-operators","status":"publish","type":"post","link":"https:\/\/www.both.org\/?p=3038","title":{"rendered":"Programming Bash #3: Logical Operators"},"content":{"rendered":"
\r\n
\r\n \r\n <\/i>\r\n <\/a>\r\n <\/span>\r\n<\/div><\/div>\n

In this series of articles we are looking at Bash as a programming language. In the second article, we explored some simple command line programming with Bash. We explored using variables and control operators. In this article we explore the five types of Bash file, string, numeric, and miscellaneous logical operators that provide execution flow control logic; different types of shell expansions.<\/p>\n\n\n\n

Logical operators are the basis for making decisions in a program and executing different sets of instructions based on those decisions. This is sometimes called flow control.<\/p>\n\n\n\n

Preparation<\/h2>\n\n\n\n

Before proceeding we need to create some test directories and files that will be used in this article. You should do this on a VM, a non-production computer, or a non-production account on your workstation. Make your home directory the PWD and execute the following instructions as a non-root user.<\/p>\n\n\n\n

[dboth@testvm1 ~]$ for I in 0 1 2 3 4 5 6 7 8 9 ; do echo \"This is testfile$I\" > testfile$I.txt ; done<\/strong>\n[dboth@testvm1 ~]$ mkdir -p .\/testdir1\/testdir2\/testdir3\/testdir4\/testdir5 testdir6 testdir7<\/strong>\n[dboth@testvm1 ~]$ tree<\/strong>\n[dboth@testvm1 ~]$ cd testdir1<\/strong>\n[dboth@testvm1 ~]$ for X in dmesg.txt dmesg1.txt dmesg2.txt dmesg3.txt dmesg4.txt ; do dmesg > $X ; done<\/strong>\n[dboth@testvm1 testdir1]$ touch newfile.txt<\/strong>\n[dboth@testvm1 testdir1]$ df -h > diskusage.txt<\/strong>\n[dboth@testvm1 testdir1]$ for I in 0 1 2 3 4 5 6 7 8 9 ; do dmesg > file$I.txt ; done<\/strong><\/code><\/pre>\n\n\n\n
The -p option for the mkdir command creates the entire specified directory hierarchy if any of them don\u2019t exist. This prevents having to create each directory in the hierarchy individually. I use this fairly frequently and it is a great time-saver.<\/p>\n\n\n\n
This now gives us a few files and directories to work with.<\/p>\n\n\n\n
Logical operators<\/h2>\n\n\n\n
Bash has a large set of logical operators that can be used in conditional expressions. The most basic form of the if control structure is to test for a condition and then execute a list of program statements if the condition is true. There are three types of operators, file, numeric and non-numeric operators. Each operator returns true (0) as its return code if the condition is met and false (1) if the condition is not met.<\/p>\n\n\n\n
The functional syntax of these comparison operators is one or two arguments with an operator that are placed within square braces. Then a list of program statements that are executed if the condition is true.<\/p>\n\n\n\n
if [ arg1 operator arg2 ] ; then list<\/code><\/pre>\n\n\n\n
Or like this with an optional list of program statements if the condition is false.<\/p>\n\n\n\n
if [ arg1 operator arg2 ] ; then list ; else list ; fi<\/code><\/pre>\n\n\n\n
The spaces in the comparison are required as shown. The single square braces, [ and ], are the traditional Bash symbols that are equivalent to the test command.<\/p>\n\n\n\n
if test arg1 operator arg2 ; then list<\/code><\/pre>\n\n\n\n
There is also a more recent syntax that offers a few advantages and which some SysAdmins prefer. This format is a bit less compatible with different versions of Bash and other shells such as ksh (Korn shell).<\/p>\n\n\n\n
if [[ arg1 operator arg2 ]] ; then list<\/code><\/pre>\n\n\n\n
File operators<\/h3>\n\n\n\n
One powerful set of logical operators that are part of Bash are the file operators. Figure 1 lists more than 20 different operators that can be performed on files by Bash. I use thise quite frequently in my scripts to determine the status of various attributes belonging to a file. <\/p>\n\n\n\n
Operator<\/strong><\/td>Description<\/strong><\/td><\/tr><\/thead>
-a filename<\/td>True if the file exists. It can be empty or have some content but so long as it exists this will be true.<\/td><\/tr>
-b filename<\/td>True if file exists and is a block special file such as a hard drive like \/dev\/sda or \/dev\/sda1.<\/td><\/tr>
-c filename<\/td>True if the file exists and is a character special file such as a TTY device like \/dev\/TTY1.<\/td><\/tr>
-d filename<\/td>This is true if the file exists and is a directory.<\/td><\/tr>
-e filename<\/td>True if file exists. This is the same as -a, above.<\/td><\/tr>
-f filename<\/td>True if the file exists and is a regular file as opposed to a directory a device special file or a link, among others.<\/td><\/tr>
-g filename<\/td>True if the file exists and is set-group-id, SETGID.<\/td><\/tr>
-h filename<\/td>This is true if file exists and is a symbolic link.<\/td><\/tr>
-k filename<\/td>True if file exists and its \u201csticky\u201d bit is set.<\/td><\/tr>
-p filename<\/td>True if file exists and is a named pipe (FIFO).<\/td><\/tr>
-r filename<\/td>True if file exists and is readable, i.e., has its read bit set.<\/td><\/tr>
-s filename<\/td>True if file exists and has a size greater than zero. A file that exists but that has a size of zero will return false.<\/td><\/tr>
-t fd<\/td>True if the file descriptor fd is open and refers to a terminal.<\/td><\/tr>
-u filename<\/td>True if file exists and its set-user-id bit is set.<\/td><\/tr>
-w filename<\/td>True if file exists and is writable.<\/td><\/tr>
-x filename<\/td>True if file exists and is executable.<\/td><\/tr>
-G filename<\/td>True if file exists and is owned by the effective group id.<\/td><\/tr>
-L filename<\/td>True if file exists and is a symbolic link.<\/td><\/tr>
-N filename<\/td>True if file exists and has been modified since it was last read.<\/td><\/tr>
-O filename<\/td>True if file exists and is owned by the effective user id.<\/td><\/tr>
-S filename<\/td>True if file exists and is a socket.<\/td><\/tr>
file1 -ef file2<\/td>True if file1 and file2 refer to the same device and iNode numbers.<\/td><\/tr>
file1 -nt file2<\/td>True if file1 is newer (according to modification date) than file2, or if file1 exists and file2 does not.<\/td><\/tr>
file1 -ot file2<\/td>True if file1 is older than file2, or if file2 exists and file1 does not.<\/td><\/tr><\/tbody><\/table>
Figure 1: The Bash file operators.<\/em><\/figcaption><\/figure>\n\n\n\n
Let\u2019s look at some examples. We will start by testing for the existence of a file.<\/p>\n\n\n\n
[dboth@testvm1 testdir1]$ File=\"TestFile1\" ; if [ -e $File ] ; then echo \"The file $File exists.\" ; else echo \"The file $File does not exist.\" ; fi<\/strong>\nThe file TestFile1 does not exist.\n[dboth@testvm1 testdir1]$<\/code><\/pre>\n\n\n\n
Create a file for testing named TestFile1. For now it does not need to contain any data.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ touch TestFile1<\/strong><\/code><\/pre>\n\n\n\n
Note how easy it is to change the value of the $File variable rather than a text string for the file name in multiple locations in this short CLI program.<\/p>\n\n\n\n
[dboth@testvm1 testdir1]$ File=\"TestFile1\" ; if [ -e $File ] ; then echo \"The file $File exists.\" ; else echo \"The file $File does not exist.\" ; fi<\/strong>\nThe file TestFile1 exists.\n[dboth@testvm1 testdir1]$ <\/code><\/pre>\n\n\n\n
Now let\u2019s determine whether a file exists and has a non-zero length which means it contains data. We have three conditions we want to test for so we need a more complex set of tests. The three conditions are; 1, the file does not exist; 2, the file exists and is empty; and 3, the file exists and contains data. To accomplish this we need to use the elif stanza in the if-elif-else construct to test for all of the conditions.<\/p>\n\n\n\n
Because these logic constructs can become complex I find it helpful to build them up one test at a time. In the following examples we will work up to testing for all three conditions. Let\u2019s start by testing to see if the file exists and it contains data.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ File=\"TestFile1\" ; if [ -s $File ] ; then echo \"$File exists and contains data.\" ; fi<\/strong>\n[david@testvm1 testdir1]$<\/code><\/pre>\n\n\n\n
That works but it is only truly accurate for one specific condition out of the three possible ones we have identified. Let\u2019s add an else stanza so we can be somewhat more accurate, and delete the file so that we can fully test this new code.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ File=\"TestFile1\" ; rm $File ; if [ -s $File ] ; then echo \"$File exists and contains data.\" ; else echo \"$File does not exist or is empty.\" ; fi<\/strong>\nTestFile1 does not exist or is empty.<\/code><\/pre>\n\n\n\n
Finally, let\u2019s add some content to the file. and test again.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ File=\"TestFile1\" ; echo \"This is file $File\" > $File ; if [ -s $File ] ; then echo \"$File exists and contains data.\" ; else echo \"$File does not exist or is empty.\" ; fi<\/strong>\nTestFile1 exists and contains data.<\/code><\/pre>\n\n\n\n
Delete the file so we start this next program with a file that doesn\u2019t exist.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ File=\"TestFile1\" ; rm $File<\/strong><\/code><\/pre>\n\n\n\n
Now we add the elif stanza to discriminate between a file that does not exist and one that is empty.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ File=\"TestFile1\" ; touch $File ; if [ -s $File ] ; then echo \"$File exists and contains data.\" ; elif [ -e $File ] ; then echo \"$File exists and is empty.\" ; else echo \"$File does not exist.\" ; fi<\/strong> \nTestFile1 exists and is empty.<\/code><\/pre>\n\n\n\n
Finally add some data to the file.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ File=\"TestFile1\" ; echo \"This is $File\" > $File ; if [ -s $File ] ; then echo \"$File exists and contains data.\" ; elif [ -e $File ] ; then echo \"$File exists and is empty.\" ; else echo \"$File does not exist.\" ; fi<\/strong>\nTestFile1 exists and contains data.\n[david@testvm1 ~]$<\/code><\/pre>\n\n\n\n
Now we have a Bash CLI program that can test for these three different conditions and the possibilities are endless. Experiment with this some more to re-verify the code with all three conditions for the file.<\/p>\n\n\n\n
It is easier to see the logic structure of the more complex compound commands if we arrange the program statements more like we would in a script that we saved in a file. Figure 2 shows how this would look. The indents of the program statements in each stanza of the if-elif-else structure help to clarify the logic.<\/p>\n\n\n\n
File=\"TestFile1\"\necho \"This is $File\" > $File\nif [ -s $File ]\nthen\n   echo \"$File exists and contains data.\"\nelif [ -e $File ]\nthen\n   echo \"$File exists and is empty.\"\nelse\n   echo \"$File does not exist.\"\nfi<\/code><\/pre>\n\n\n\n
Figure 2: The command line program rewritten as it would appear in a script.<\/em><\/p>\n\n\n\n
Logic of some complexity becomes too lengthy for most CLI programs. Although any Linux or Bash built-in commands may be used in CLI programs, as the CLI programs get longer and more complex it makes sense to create a script that is stored in a file and which can be executed at any time now or in the future. We\u2019ll get to that in the next article of this series. But for now, we have more logic operators to explore.<\/p>\n\n\n\n
String comparison operators<\/h3>\n\n\n\n
String comparison operators enable comparison of alphanumeric strings of characters. There are only a few of these operators which are listed in Figure 3.<\/p>\n\n\n\n
Operator<\/strong><\/td>Description<\/strong><\/td><\/tr><\/thead>
-z string<\/td>True if the length of string is zero.<\/td><\/tr>
-n string<\/td>True if the length of string is non-zero.<\/td><\/tr>
string1 == string2 or string1 = string2<\/td>True if the strings are equal. A single = should be used with the test command for POSIX conformance. When used with the [[ command, this performs pattern matching as described above (Compound Commands)<\/td><\/tr>
string1 != string2<\/td>True if the strings are not equal.<\/td><\/tr>
string1 < string2<\/td>True if string1 sorts before string2 lexicographically1<\/sup><\/a>.<\/td><\/tr>
string1 > string2<\/td>True if string1 sorts after string2 lexicographically.<\/td><\/tr><\/tbody><\/table>
Figure 3: Bash string logical operators.<\/em><\/figcaption><\/figure>\n\n\n\n
First, let\u2019s look at string length. Notice that the quotes around $MyVar in the comparison itself must be there for the comparison to work. We are still working in the home directory.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ MyVar=\"\" ; if [ -z \"\" ] ; then echo \"MyVar is zero length.\" ; else echo \"MyVar contains data\" ; fi<\/strong>\nMyVar is zero length.\n[david@testvm1 testdir1]$ MyVar=\"Random text\" ; if [ -z \"\" ] ; then echo \"MyVar is zero length.\" ; else echo \"MyVar contains data\" ; fi<\/strong>\nMyVar is zero length.<\/code><\/pre>\n\n\n\n
We could also do it this way.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ MyVar=\"Random text\" ; if [ -n \"$MyVar\" ] ; then echo \"MyVar contains data.\" ; else echo \"MyVar is zero length\" ; fi<\/strong>\nMyVar contains data.\n[david@testvm1 testdir1]$ MyVar=\"\" ; if [ -n \"$MyVar\" ] ; then echo \"MyVar contains data.\" ; else echo \"MyVar is zero length\" ; fi<\/strong>\nMyVar is zero length<\/code><\/pre>\n\n\n\n
Since we are already talking about strings and whether they are zero length or more than zero, it might make sense that we sometimes need to know the exact length. Although this is not a comparison it is related to them. Unfortunately there is no simple way to determine the length of a string. There are a couple ways to do this but I think using the expr (evaluate expression) is the easiest. Read the man page for expr for more of what it can do. Quotes are required around the string or variable being tested.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ MyVar=\"\" ; expr length \"$MyVar\"<\/strong>\n0\n[david@testvm1 testdir1]$ MyVar=\"How long is this?\" ; expr length \"$MyVar\"<\/strong>\n17\n[david@testvm1 testdir1]$ expr length \"We can also find the length of a literal string as well as a variable.\"<\/strong>\n70<\/code><\/pre>\n\n\n\n
Back to our comparison operators. I use a lot of testing in my scripts to determine whether two strings are equal, that is, identical. I use the non-POSIX version of this comparison operator<\/p>\n\n\n\n
[david@testvm1 testdir1]$ Var1=\"Hello World\" ; Var2=\"Hello World\" ; if [ \"$Var1\" == \"$Var2\" ] ; then echo \"Var1 matches Var2\" ; else echo \"Var1 and Var2 do not match.\" ; fi<\/strong>\nVar1 matches Var2\n[david@testvm1 testdir1]$ Var1=\"Hello World\" ; Var2=\"Hello world\" ; if [ \"$Var1\" == \"$Var2\" ] ; then echo \"Var1 matches Var2\" ; else echo \"Var1 and Var2 do not match.\" ; fi<\/strong>\nVar1 and Var2 do not match.<\/code><\/pre>\n\n\n\n
You can experiment some more on your own to try out these operators.<\/p>\n\n\n\n
Numeric comparison operators<\/h3>\n\n\n\n
These numeric operators make comparisons between two numeric arguments. Like the other operator classes, most of these are easy to understand.<\/p>\n\n\n\n
Operator<\/strong><\/td>Description<\/strong><\/td><\/tr><\/thead>
arg1 -eq arg2<\/td>True if arg1 equals arg2.<\/td><\/tr>
arg1 -ne arg2<\/td>True if arg1 is not equal to arg2.<\/td><\/tr>
arg1 -lt arg2<\/td>True if arg1 is less than arg2.<\/td><\/tr>
arg1 -le arg2<\/td>True if arg1 is less than or equal to arg2.<\/td><\/tr>
arg1 -gt arg2<\/td>True if arg1 is greater than arg2.<\/td><\/tr>
arg1 -ge arg2<\/td>True if arg1 is greater than or equal to arg2.<\/td><\/tr><\/tbody><\/table>
Figure 4: Bash numeric comparison logical operators.<\/em><\/figcaption><\/figure>\n\n\n\n
Here are some simple examples. In the first instance we set the variable $X to 1 and then test to see if $X is equal to 1. In the second instance, X is set to 0 so the comparison is not true.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ X=1 ; if [ $X -eq 1 ] ; then echo \"X equals 1\" ; else echo \"X does not equal 1\" ; fi<\/strong>\nX equals 1\n[david@testvm1 testdir1]$ X=0 ; if [ $X -eq 1 ] ; then echo \"X equals 1\" ; else echo \"X does not equal 1\" ; fi<\/strong>\nX does not equal 1<\/code><\/pre>\n\n\n\n
Try some more experiments on your own.<\/p>\n\n\n\n
Miscellaneous operators<\/h3>\n\n\n\n
These miscellaneous operators allow us to see if a shell option is set or a shell variable has a value but it does not discover the value of the variable, just whether it has one.<\/p>\n\n\n\n
Operator<\/strong><\/td>Description<\/strong><\/td><\/tr><\/thead>
-o optname<\/td>True if the shell option optname is enabled. See the list of options under the description of the -o option to the Bash set<\/strong> builtin in the Bash man page.<\/td><\/tr>
-v varname<\/td>True if the shell variable varname is set (has been assigned a value).<\/td><\/tr>
-R varname<\/td>True if the shell variable varname is set and is a name reference.<\/td><\/tr><\/tbody><\/table>
Figure 5: Miscellaneous Bash logical operators.<\/em><\/figcaption><\/figure>\n\n\n\n
You can also experiment on your own to try out these operators.<\/p>\n\n\n\n
Expansions<\/h2>\n\n\n\n
Bash supports a number of types of expansions and substitutions which can be quite useful. According to the Bash man page, Bash has seven (7) forms of expansions. We will look at tilde (testdir) expansion, arithmetic expansion, and pathname expansion. Unofficially I also consider the dash (-) to be the 8th form of expansion.<\/p>\n\n\n\n
Brace expansion<\/h3>\n\n\n\n
Brace expansion is a method to use for generating arbitrary strings. Let\u2019s start with brace expansion because we will use this tool to create a large number of files to use in experiments with special pattern characters. Brace expansion can be used to generate lists of arbitrary strings and insert them into a specific location within an enclosing static string, or at either end of a static string. This may be hard to visualize so let\u2019s just do it.<\/p>\n\n\n\n
First let\u2019s just see what a brace expansion does.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ echo {string1,string2,string3}<\/strong>\nstring1 string2 string3<\/code><\/pre>\n\n\n\n
Well, that is not very helpful, is it? But look what happens when we use it just a bit differently.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ echo \"Hello \"{David,Jen,Rikki,Jason}.<\/strong>\nHello David. Hello Jen. Hello Rikki. Hello Jason.<\/code><\/pre>\n\n\n\n
That looks like something we might be able to use because it can save a good deal of typing. Now try this.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ echo b{ed,olt,ar}s<\/strong>\nbeds bolts bars<\/code><\/pre>\n\n\n\n
I could go on but you get the idea. We\u2019ll use expansions like this in Episode III<\/p>\n\n\n\n
Tilde expansion<\/h3>\n\n\n\n
Arguably the most common expansion we run into is the tilde (~) expansion. When we use this in a command like cd ~\/Documents, the Bash shell actually expands that shortcut to the full home directory of the user. The tilde uses the value in the $PWD environment variable but the tilde requires less typing than $PWD so all of us lazy sysadmins are very happy about that. The $PWD variable is always set to the home directory of the logged-in user.<\/p>\n\n\n\n
[dboth@testvm1 ~]$ echo $PWD<\/strong>\n\/home\/dboth\n[dboth@testvm1 ~]$<\/code><\/pre>\n\n\n\n
Use these little Bash programs to explore tilde expansion.<\/p>\n\n\n\n
[david@testvm1 testdir1]$ echo ~<\/strong>
\/home\/student
[david@testvm1 testdir1]$ echo ~\/Documents<\/strong>
\/home\/student\/Documents
[david@testvm1 testdir1]$ Var1=~\/Documents ; echo $Var1 ; cd $Var1<\/strong>
\/home\/student\/Documents
[david@testvm1 Documents]$<\/code><\/pre>\n\n\n\n
Dash expansion<\/h3>\n\n\n\n
The dash (-) is also a shortcut and expands to the value of the previous directory. It uses the value in the $OLDPWD environment variable. So let\u2019s first look at that value and then use the dash to return to the previous directory.<\/p>\n\n\n\n
[dboth@testvm1 Documents]$ echo $OLDPWD<\/strong>\n\/home\/dboth\/testdir1\n[dboth@testvm1 Documents]$ cd -<\/strong>\n\/home\/dboth\/testdir1\n[dboth@testvm1 testdir1]$<\/code><\/pre>\n\n\n\n
The dash (-) is also a shortcut and expands to the value of the previous directory. It uses the value in the $OLDPWD environment variable. So<\/p>\n\n\n\n
Pathname expansion<\/h3>\n\n\n\n
Pathname expansion is fancy term for expansion of file globbing patterns using the characters ? and * into the full names of directories and files that match the pattern. File globbing means special pattern characters that allow us significant flexibility in matching file names, directories, and other strings when performing various actions. These special pattern characters allow matching single, multiple or specific characters in a string.<\/p>\n\n\n\n