Short-circuit evaluation
Template:Short description
Template:Distinguish
Template:More citations needed
Template:Evaluation strategy
Short-circuit evaluation, minimal evaluation, or McCarthy evaluation (after John McCarthy) is the semantics of some Boolean operators in some programming languages in which the second argument is executed or evaluated only if the first argument does not suffice to determine the value of the expression: when the first argument of the AND function evaluates to false, the overall value must be false; and when the first argument of the OR function evaluates to true, the overall value must be true.
In programming languages with lazy evaluation (Lisp, Perl, Haskell), the usual Boolean operators short-circuit. In others (Ada, Java, Delphi), both short-circuit and standard Boolean operators are available. For some Boolean operations, like exclusive or (XOR), it is impossible to short-circuit, because both operands are always needed to determine a result.
Short-circuit operators are, in effect, control structures rather than simple arithmetic operators, as they are not strict. In imperative language terms (notably C and C++), where side effects are important, short-circuit operators introduce a sequence point: they completely evaluate the first argument, including any side effects, before (optionally) processing the second argument. ALGOL 68 used proceduring to achieve user-defined short-circuit operators and procedures.
The use of short-circuit operators has been criticized as problematic: Template:Quote
Definition
In any programming language that implements short-circuit evaluation, the expression x and y is equivalent to the conditional expression if x then y else x, and the expression x or y is equivalent to if x then x else y. In either case, x is only evaluated once.
The generalized definition above accommodates loosely typed languages that have more than the two truth-values True and False, where short-circuit operators may return the last evaluated subexpression. This is called "last value" in the table below. For a strictly-typed language, the expression is simplified to if x then y else false and if x then true else y respectively for the boolean case.
Precedence
Although Template:Code takes precedence over Template:Code in many languages, this is not a universal property of short-circuit evaluation. An example of the two operators taking the same precedence and being left-associative with each other is POSIX shell's command-list syntax.<ref>Template:Cite web</ref>Template:Rp
The following simple left-to-right evaluator enforces a precedence of Template:Code over Template:Code by a Template:Code:
function short-circuit-eval (operators, values)
let result := True
for each (op, val) in (operators, values):
if op = "AND" && result = False
continue
else if op = "OR" && result = True
return result
else
result := val
return result
Formalization
Short-circuit logic, with or without side-effects, have been formalized based on Hoare's conditional. A result is that non-short-circuiting operators can be defined out of short-circuit logic to have the same sequence of evaluation.<ref>Template:Cite arXiv</ref>
Comparison with bitwise operators
& and | are bitwise operators that occur in many programming languages. The major difference is that bitwise operations operate on the individual bits of a binary numeral, whereas conditional operators operate on logical operations. Additionally, expressions either side of a bitwise operator are always evaluated. In some languages, including Java and C#, they can be used on boolean operands to force both sides to be evaluated.
<syntaxhighlight lang="java">
if (expression1 || expression2 || expression3)
</syntaxhighlight>If expression 1 is true, expressions 2 and 3 are not checked.
<syntaxhighlight lang="java">
if (expression1 | expression2 | expression3)
</syntaxhighlight>This checks expressions 2 and 3, even if expression 1 is true.
Short-circuit operators can thus reduce run times by avoiding unnecessary calculations. They can also avoid null exceptions when expression 1 checks whether an object is valid.
Support in common programming and scripting languages
The following table is restricted to common programming languages and the basic boolean operators for logical conjunction AND and logical disjunction OR. Bitwise operators are shown only for languages that allow them to be used as eager boolean operators and have the same return type.
Note that there are more short-circuit operators, for example the ternary conditional operator, which is cond ? e1 : e2 (C, C++, Java, PHP), if cond then e1 else e2 (ALGOL, Haskell, Kotlin, Rust), e1 if cond else e2 (Python). Please take a look at ternary conditional operator#Usage.
| Language | Eager operators | Short-circuit operators | Result type |
|---|---|---|---|
| Ada | and, or
|
and then, or else
|
Boolean |
| ALGOL 68 | and, &, ∧ ; or, ∨ | Template:Depends | Boolean |
| APL | ∧, ∨
|
:AndIf, :OrIf
|
Boolean |
| awk | Template:CNone | &&, ||
|
Boolean |
| C, Objective-C | &, |Template:Efn
|
&&, ||<ref>ISO/IEC 9899 standard, section 6.5.13</ref>
|
int |
| C++Template:Efn | Template:CNone | &&, ||<ref>ISO/IEC IS 14882 draft.</ref>
|
Boolean |
| C# | &, |
|
&&, ||
|
Boolean |
| DTemplate:Efn | &, |
|
&&, ||
|
Boolean |
| Eiffel | and, or
|
and then, or else
|
Boolean |
| Erlang | and, or
|
andalso, orelse
|
Boolean |
| FortranTemplate:Efn | .and., .or.
|
.and., .or.
|
Boolean |
| Go, Haskell, OCamlTemplate:Efn | Template:CNone | &&, ||
|
Boolean |
| Java, R, Swift | &, |
|
&&, ||Template:Efn
|
Boolean |
| JavaScript | Template:CNone | &&, ||
|
Last value |
| Julia | Template:CNone | &&, ||
|
Last value |
| Kotlin | and, or
|
&&, ||
|
Boolean |
| Lisp, LuaTemplate:Efn, Scheme | Template:CNone | and, or
|
Last value |
| MATLABTemplate:Efn | &, |
|
&, |, &&, ||
|
Boolean |
| MUMPS (M) | &, !
|
Template:CNone | Numeric |
| Modula-2 | Template:CNone | AND, OR
|
Boolean |
| Pascal | and, orTemplate:EfnTemplate:Efn
|
and_then, or_elseTemplate:Efn
|
Boolean |
| Perl | &, |
|
&&, and, ||, or
|
Last value |
| PHP | Template:CNone | &&, and, ||, or
|
Boolean |
| POSIX shell, Bash | Template:CNone | &&, ||
|
Numeric (exit code) |
| PowerShell Scripting Language | Template:CNone | -and, -or
|
Boolean |
| Python | &, |
|
and, or
|
Last value |
| Ruby | &, |
|
&&, and, ||, or<ref>Template:Cite web</ref>
|
Last value |
| Rust | &, |
|
&&, ||<ref>Template:Cite web</ref>
|
Boolean |
| Smalltalk | &, |
|
and:, or:Template:Efn
|
Boolean |
| Standard ML | Template:Unknown | andalso, orelse
|
Boolean |
| Visual Basic .NET | And, Or
|
AndAlso, OrElse
|
Boolean |
| Visual Basic, Visual Basic for Applications (VBA) | And, Or
|
Template:CNone | Numeric |
Common use
Avoiding undesired side effects of the second argument
Usual example, using a C-based language: <syntaxhighlight lang="c"> int denom = 0; if (denom != 0 && num / denom) {
... // ensures that calculating num/denom never results in divide-by-zero error
} </syntaxhighlight>
Consider the following example: <syntaxhighlight lang="c"> int a = 0; if (a != 0 && myfunc(b)) {
doSomething();
} </syntaxhighlight>
In this example, short-circuit evaluation guarantees that myfunc(b) is never called. This is because a != 0 evaluates to false. This feature permits two useful programming constructs.
- If the first sub-expression checks whether an expensive computation is needed and the check evaluates to false, one can eliminate expensive computation in the second argument.
- It permits a construct where the first expression guarantees a condition without which the second expression may cause a run-time error.
Both are illustrated in the following C snippet where minimal evaluation prevents both null pointer dereference and excess memory fetches: <syntaxhighlight lang="c"> bool isFirstCharValidAlphaUnsafe(const char* p) {
return isalpha(p[0]); // SEGFAULT highly possible with p == NULL
}
bool isFirstCharValidAlpha(const char* p) {
return p != NULL && isalpha(p[0]); // 1) no unneeded isalpha() execution with p == NULL, 2) no SEGFAULT risk
} </syntaxhighlight>
Idiomatic conditional construct
Since minimal evaluation is part of an operator's semantic definition and not an optional optimization, a number of coding idioms rely on it as a succinct conditional construct. Examples include:
Perl idioms: <syntaxhighlight lang="perl"> some_condition or die; # Abort execution if some_condition is false some_condition and die; # Abort execution if some_condition is true </syntaxhighlight>
POSIX shell idioms:<ref>Template:Cite web</ref>
<syntaxhighlight lang="bash">
modprobe -q some_module && echo "some_module installed" || echo "some_module not installed"
</syntaxhighlight>
This idiom presumes that echo cannot fail.
Possible problems
Untested second condition leads to unperformed side effect
Despite these benefits, minimal evaluation may cause problems for programmers who do not realize (or forget) it is happening. For example, in the code <syntaxhighlight lang="c"> if (expressionA && myFunc(b)) {
doSomething();
}
</syntaxhighlight>
if myFunc(b) is supposed to perform some required operation regardless of whether doSomething() is executed, such as allocating system resources, and expressionA evaluates as false, then myFunc(b) will not execute, which could cause problems. Some programming languages, such as Java, have two operators, one that employs minimal evaluation and one that does not, to avoid this problem.
Problems with unperformed side effect statements can be easily solved with proper programming style, i.e., not using side effects in boolean statements, as using values with side effects in evaluations tends to generally make the code opaque and error-prone.<ref>Template:Cite web</ref>
Reduced efficiency due to constraining optimizations
Short-circuiting can lead to errors in branch prediction on modern central processing units (CPUs), and dramatically reduce performance. A notable example is highly optimized ray with axis aligned box intersection code in ray tracing.Template:Clarify Some compilers can detect such cases and emit faster code, but programming language semantics may constrain such optimizations.Template:Citation needed
An example of a compiler unable to optimize for such a case is Java's Hotspot virtual machine (VM) as of 2012.<ref>Template:Cite web</ref>