Logical & in Bash


Get real time updates directly on you device, subscribe now.

One would suppose you can dispatch & in two articles. Seems you’ll be able to’t. Whereas the primary article handled utilizing & on the finish of instructions to push them into the background after which diverged into explaining course of administration, the second article noticed & getting used as a strategy to consult with file descriptors, which led us to seeing how, mixed with , you’ll be able to route inputs and outputs from and to totally different locations.

This implies we have not even touched on & as an AND operator, so let’s do this now.

& is a Bitwise Operator

If you’re in any respect aware of binary operations, you’ll have heard of AND and OR. These are bitwise operations that function on particular person bits of a binary quantity. In Bash, you utilize & because the AND operator and | because the OR operator:


zero & zero = zero

zero & 1 = zero

1 & zero = zero

1 & 1 = 1


zero | zero = zero

zero | 1 = 1

1 | zero = 1

1 | 1 = 1

You may check this by ANDing any two numbers and outputting the end result with echo:

$ echo $(( 2 & three )) # 00000010 AND 00000011 = 00000010


$ echo $(( 120 & 97 )) # 01111000 AND 01100001 = 01100000


The identical goes for OR (|):

$ echo $(( 2 | three )) # 00000010 OR 00000011 = 00000011


$ echo $(( 120 | 97 )) # 01111000 OR 01100001 = 01111001


Three issues about this:

You utilize (( … )) to inform Bash that what goes between the double brackets is a few kind of arithmetic or logical operation. (( 2 + 2 )), (( 5 % 2 )) (% being the modulo operator) and ((( 5 % 2 ) + 1)) (equals three) will all work.
Like with variables, $ extracts the worth so you need to use it.
For as soon as areas do not matter: ((2+three)) will work the identical as (( 2+three )) and (( 2 + three )).
Bash solely operates with integers. Attempting to do one thing like this (( 5 / 2 )) provides you with “2”, and attempting to do one thing like this (( 2.5 & 7 )) will end in an error. Then once more, utilizing something however integers in a bitwise operation (which is what we’re speaking about now) is usually one thing you would not do anyway.

TIP: If you wish to verify what your decimal quantity would appear like in binary, you need to use bc, the command-line calculator that comes preinstalled with most Linux distros. For instance, utilizing:

bc <<< "obase=2; 97"

will convert 97 to binary (the o in obase stands for output), and …

bc <<< "ibase=2; 11001011"

will convert 11001011 to decimal (the i in ibase stands for enter).

&& is a Logical Operator

Though it makes use of the identical logic ideas as its bitwise cousin, Bash’s && operator can solely render two outcomes: 1 (“true”) and zero (“false”). For Bash, any quantity not zero is “true” and something that equals zero is “false.” What can be false is something that’s not a quantity:

$ echo $(( four && 5 )) # Each non-zero numbers, each true = true


$ echo $(( zero && 5 )) # One zero quantity, one is fake = false


$ echo $(( b && 5 )) # One in all them isn’t quantity, one is fake = false


The OR counterpart for && is || and works precisely as you’ll anticipate.

All of that is easy sufficient… till it involves a command’s exit standing.

&& is a Logical Operator for Command Exit Standing

As we’ve got seen in earlier articles, as a command runs, it outputs error messages. However, extra importantly for at present’s dialogue, it additionally outputs a quantity when it ends. This quantity is named an exit code, and whether it is zero, it means the command didn’t encounter any downside throughout its execution. Whether it is some other quantity, it means one thing, someplace, went fallacious, even when the command accomplished.

So zero is sweet, some other quantity is dangerous, and, within the context of exit codes, zero/good means “true” and every thing else means “false.” Sure, that is the precise opposite of what you noticed within the logical operations above, however what are you gonna do? Totally different contexts, totally different guidelines. The usefulness of this may grow to be obvious quickly sufficient.

Transferring on.

Exit codes are saved quickly within the particular variable ? — sure, I do know: one other complicated selection. Be that as it could, keep in mind that in our article about variables, and we stated that you just learn the worth in a variable utilizing a the $ image. So, if you wish to know if a command has run with out a hitch, it’s a must to learn ? as quickly because the command finishes and earlier than operating the rest.

Attempt it with:

$ discover /and many others -iname “*.service”

discover: ‘/and many others/audisp/plugins.d’: Permission denied

/and many others/systemd/system/dbus-org.freedesktop.nm-dispatcher.service

/and many others/systemd/system/dbus-org.freedesktop.ModemManager1.service


As you noticed within the earlier article, operating discover over /and many others as an everyday person will usually throw some errors when it tries to learn subdirectories for which you wouldn’t have entry rights.

So, in the event you execute…

echo $?

… proper after discover, it would print a 1, indicating that there have been some errors.

(Discover that in the event you had been to run echo $? a second time in a row, you’d get a zero. It’s because $? would comprise the exit code of echo $?, which, supposedly, can have executed accurately. So the primary lesson when utilizing $? is: use $? right away or retailer it someplace protected — like in one other variable, or you’ll lose it).

One speedy use of ? is to fold it into an inventory of chained instructions and bork the entire thing if something fails as Bash runs via it. For instance, you could be aware of the method of constructing and compiling the supply code of an software. You may run them on after one other by hand like this:

$ configure




$ make




$ make set up




You can even put all three on one line…

$ configure; make; make set up

… and hope for one of the best.

The drawback of that is that if, say, configure fails, Bash will nonetheless attempt to run make and sudo make set up, even when there’s nothing to make or, certainly, set up.

The smarter approach of doing it’s like this:

$ configure && make && make set up

This takes the exit code from every command and makes use of it as an operand in a chained && operation.

However, and this is the kicker, Bash is aware of the entire thing goes to fail if configure returns a non-zero end result. If that occurs, it does not must run make to verify its exit code, because the result’s going to be false it doesn’t matter what. So, it forgoes make and simply passes a non-zero end result onto the following step of the operation. And, as configure && make delivers false, Bash does not must run make set up both. Which means that, in an extended chain of instructions, you’ll be able to be a part of them with &&, and, as quickly as one fails, it can save you time as the remainder of the instructions get canceled instantly.

You are able to do one thing related with ||, the OR logical operator, and make Bash proceed processing chained instructions if solely one among a pair completes.

In view of all this (together with the stuff we coated earlier), it is best to now have a clearer concept of what the command line we set firstly of this text does:

mkdir test_dir 2>/dev/null || contact backup/dir/photos.txt && discover . -iname “*jpg” > backup/dir/photos.txt &

So, assuming you’re operating the above from a listing for which you have got learn and write privileges, what it does it do and the way does it do it? How does it keep away from unseemly and doubtlessly execution-breaking errors? Subsequent week, other than supplying you with the answer, we’ll be coping with brackets: curly, curvy and straight. Do not miss it!

Source link

Leave A Reply

This website uses cookies to improve your experience. We'll assume you're ok with this, but you can opt-out if you wish. Accept Read More