On 18 Jan 2020, Spectre said the following...
load=`echo $(cat /proc/loadavg | awk '{print $1}') \> 8 | bc -l`
if [ "$load" -ne 0 ]; then
This will make more sense, but I didn't realise what it was all doing at the time, and I left the logic operation out.
Somehow in a fashion I don't completely understand renders the question a binary one, 1 or 0, which is why the loadavg is never printed at least
not a way I recognised.
That's correct, because what you're actually getting out of the
expression above is the value of a boolean (ie, true or false)
expression printed as an integer: 1 for true, 0 for false.
Let's unpack that expression a bit:
load=`echo $(cat /proc/loadavg | awk '{print $1}') \> 8 | bc -l`
So first you're using the `$(...)` syntax to perform command
substitution: that is, you're running a command and substituting
the output of that command into a program's argument list.
The program in this case is `cat /proc/loadavg | awk '{print $1}'`.
That is, use `cat(1)` to print the contents of the file /proc/loadavg
(note that that 'file' is synthesized dynamically by the operating
system; it's not e.g. a disk file) and then you're piping that to
`awk` to extract the first field.
The first thing to note here is that you don't need `cat` at all.
`awk` is perfectly capable of opening and reading a file, so to
get the first field out of /proc/loadavg, you could just run:
awk '{print $1}' /proc/loadavg
Now, you've got some number, and you're interpolating that number
(as text) into the argument list to `echo`, so you end up with
something like:
load=`echo 1.23 \> 8 | bc -l`
So here, you're doing command substitution again, but you're using
the older (and obsolete!) syntax using backticks (the '`' characters)
to do it. So the command you're running is:
echo 1.23 \> 8 | bc -l
That is, you're piping the string '1.23 > 8' to `bc -l`, then taking
the output of that command, which will be the output from `bc` and
assigning that to the variable `load`.
But '1.23 > 8' is a boolean expression. The calculator program `bc`
will evaluate that expression and print the result of the evaluation.
Since that's a boolean value, and `bc` prints booleans as 1 (for true)
or 0 (for false), that's what you're seeing assigned to `load`.
So a few things here: first, one needs some way to evaluate the boolean
in this program, and `bc` is a reasonable way to do that, but since
we aren't preserving the value you read from `/proc/loadavg` anywhere,
we're losing that value by the time we get the boolean back. Second,
the `-l` argument to `bc` says to load its library (which includes
functions for exponentiation, sin and other trigonometric functions,
etc). But you're not using anything from the library and thus you
really don't need the `-l`. `bc` is a bit of overkill for what you
are trying to accomplish, though, which is why I used `expr`.
Looking at your logic, I would be guessing in some way the cat can still be removed and it was a foible of whoever wrote it. I tend to do it that way too, I'm more used to redirection than what individial commands can do.
Yes. `cat` is completely redundant; there used to be a (fake) award
called the "useless uses of cat" award for things like this. It
wasn't exactly mean-spirited, but was a bit snooty. But yeah, the
upshot is that `cat` can go.
I still don't quite get this though.
awk '{print $1}') \> 8
and how that becomes print if > 8..
Ah; I think perhaps you're missing that the `awk` is connected to
another command, and not part of the expression to you typed here:
note the un-paired ')'.
and bc is rendering the integer.
In order to get what I was looking for, the actual load average into the message, I had to re-read "/proc/loadavg"
Does the explanation above clear it up?
Thanks for your time, and explanation.
Sure thing!
--- Mystic BBS v1.12 A43 2019/03/03 (Raspberry Pi/32)
* Origin: ACiD Underworld // acidunderworld.com:31337 (21:1/188)