|Written by Ian Elliot
|Thursday, 29 November 2018
Page 2 of 3
There is yet another small and subtle point.
This is more generally called lazy evaluation.
As A is truthy there is no need to evaluate the second term and hence the function test is never called. On the other hand if A=0 or any other falsey value the function is called.
This sort of lazy evaluation can help you avoid runtime errors.
The basic idea is that you write something as the first expression that evaluates to truthy when the second expression should not be evaluated.
but we can easily check to see if a variable is null using:
in this expression !A. i.e. not A, is truthy if A is null and hence we never evaluate A.method if A is indeed null.
You can avoid using the ! (NOT) operator (see later) by expressing the same idea using the && operator as will now be explained.
All of the ideas that we have just encountered with respect to the logical Or operator || apply to the And && operator.
which we now have to interpret as truthy and falsey values as for the Or operator.
You can also see that you can reinterpret the table in an "active" way and formulate the AND operation as -
if the first expression is falsey then the result is the first expression.
If the first expression is truthy then the result is the second expression.
You could interpret it as saying:
"return the first value if it is false and return the second value otherwise".
Notice that is just the way we work out the logical OR
"return the first value if it is true and return the second value otherwise".
but with the first expression false rather than true.
You should also be able to see the the AND operation
is equivalent to the if statement:
If you think about this for a moment you should be able to see that (!A)&&B is "almost" the same as A||B in that both give the value B when A is false.
However it isn't identical because when A is true (!A)&&B gives the logical opposite of A||B that is (!A)&&B is false but A||B is true if A is true.
The exact equivalence is given by one of De Morgan's laws of logic and it reveals that
You can use the AND operator in much the same way as the OR operator and it too uses lazy evaluation - that is if A is false then B in A&&B is not evaluated.
This enables us to write the protection against a runtime error given earlier as:
and avoid the use of a NOT !.
|Last Updated ( Thursday, 13 June 2019 )