ANDALSO: Difference between revisions

From QB64 Phoenix Edition Wiki
Jump to navigation Jump to search
No edit summary
No edit summary
Line 9: Line 9:
{{PageDescription}}
{{PageDescription}}
* A logical operation is said to be short-circuiting if the compiled code can bypass the evaluation of one expression depending on the result of another expression.
* A logical operation is said to be short-circuiting if the compiled code can bypass the evaluation of one expression depending on the result of another expression.
* If the result of the first expression evaluated determines the final result of the operation, there is no need to evaluate the second expression, because it cannot change the final result.
* If the result of the first expression evaluated determines the final result of the operation, there is no need to evaluate the second expression, because it cannot change the final result. E.g. if the first expression is already false, then the second expression can't change the result anymore, it will remain false, even if the second expression would be true. Hence, the second expression is irrelevant and never evaluated, if the first one is already false.
** Note well that any functions involved in the second expression are **not called**, if the first expression is false. This behavior is intended and the reason for the better performance against a regular [[AND (boolean)|AND]], but it may cause unexpected failure when used without care.
** In fact, if any functions in the second expression **must be called** regardless of the truth of the first expression, then you must use the regular [[AND (boolean)|AND]].
* Short-circuiting can improve performance if the bypassed expression is complex, or if it involves procedure calls.
* Short-circuiting can improve performance if the bypassed expression is complex, or if it involves procedure calls.
* If both expressions evaluate to true, result is true.
* Only if both expressions evaluate to true, then the result is true too.





Revision as of 12:12, 12 December 2024

_ANDALSO is a boolean logical operator that performs short-circuiting logical conjunction on two expressions.


Syntax

result = firstvalue _ANDALSO secondvalue


Description

  • A logical operation is said to be short-circuiting if the compiled code can bypass the evaluation of one expression depending on the result of another expression.
  • If the result of the first expression evaluated determines the final result of the operation, there is no need to evaluate the second expression, because it cannot change the final result. E.g. if the first expression is already false, then the second expression can't change the result anymore, it will remain false, even if the second expression would be true. Hence, the second expression is irrelevant and never evaluated, if the first one is already false.
    • Note well that any functions involved in the second expression are **not called**, if the first expression is false. This behavior is intended and the reason for the better performance against a regular AND, but it may cause unexpected failure when used without care.
    • In fact, if any functions in the second expression **must be called** regardless of the truth of the first expression, then you must use the regular AND.
  • Short-circuiting can improve performance if the bypassed expression is complex, or if it involves procedure calls.
  • Only if both expressions evaluate to true, then the result is true too.


Availability


Examples

Example
AND versus _ANDALSO
DIM AS LONG index, values(1 TO 10), v

FOR index = 1 TO 10
    values(index) = RND * 255
NEXT index

' value of index is now > 10

PRINT "Trying _ANDALSO"

' _ANDALSO performs short-circuiting logical conjunction and hence the GetArrayValue check is completely bypassed
IF index >= 1 _ANDALSO index <= 10 _ANDALSO GetArrayValue(values(), index, v) THEN
    PRINT "_ANDALSO: Value ="; v
ELSE
    PRINT "_ANDALSO: Outside range."
END IF

PRINT
PRINT "Trying AND"

' AND does not performs short-circuiting logical conjunction and hence QB64-PE will throw a runtime error: Subscript out of range
IF index >= 1 AND index <= 10 AND GetArrayValue(values(), index, v) THEN
    PRINT "AND: Value ="; v
ELSE
    PRINT "AND: Outside range."
END IF

END

FUNCTION GetArrayValue%% (arr() AS LONG, idx AS LONG, value AS LONG)
    value = arr(idx)
    GetArrayValue = -1 ' return true
END FUNCTION


See also



Navigation:
Main Page with Articles and Tutorials
Keyword Reference - Alphabetical
Keyword Reference - By usage
Report a broken link