Short-circuit evaluation

<h2 id="definition">Definition</h2>
In any programming language that implements short-circuit evaluation, the expression x and y is equivalent to the <a href="/facts/Conditional_(programming)/8gDQTqUD">conditional expression</a> 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 <a href="/facts/Truth-value/SY4e2w8l">truth-values</a> 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.

<h3>Precedence</h3>
Although AND takes <a href="/facts/Operator_precedence/sWsoTzbH">precedence</a> over OR 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 <a href="/facts/Left-associative/HcEdArws">left-associative</a> with each other is <a href="/facts/POSIX_shell/2G4T2Fb9">POSIX shell</a>'s command-list syntax.<a class="footnote-ref" id="fnref:2" href="#fn:2">2</a>: §2.9.3 
The following simple left-to-right evaluator enforces a precedence of AND over OR by a continue:

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

<h3>Formalization</h3>
Short-circuit logic, with or without side-effects, have been formalized based on <a href="/facts/Hoare_logic/UoMg08wo">Hoare's conditional</a>. A result is that non-short-circuiting operators can be defined out of short-circuit logic to have the same sequence of evaluation.<a class="footnote-ref" id="fnref:3" href="#fn:3">3</a>

<h2 id="support-in-common-programming-and-scripting-languages">Support in common programming and scripting languages</h2>
The following table is restricted to common programming languages and the basic boolean operators for <a href="/facts/Logical_conjunction/62uyyn1d">logical conjunction</a> AND and <a href="/facts/Logical_disjunction/jbI2EGlM">logical disjunction</a> OR. In some languages, the <a href="/facts/Bitwise_operation/0gkqnUda">bitwise operators</a> can be used as eager boolean operators. For other languages, bitwise operators are not included in the list, because they do not take boolean values or have a result type different from the respective short-circuit operators.
Note that there are more short-circuit operators, for example the <a href="/facts/Ternary_conditional_operator/3C8mgMD9">ternary conditional operator</a>, which is cond ? e1 : e2 (<a href="/facts/C_(programming_language)/Ky2No763">C</a>, <a href="/facts/C%2B%2B/Et0F2qn9">C++</a>, <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>, <a href="/facts/PHP/vU6YRJX0">PHP</a>), if cond then e1 else e2 (<a href="/facts/ALGOL/wlFJGNEx">ALGOL</a>, <a href="/facts/Haskell_(programming_language)/4Htv9WLu">Haskell</a>, <a href="/facts/Kotlin_(programming_language)/CrAqIFLn">Kotlin</a>, <a href="/facts/Rust_(programming_language)/8JNMV19F">Rust</a>), e1 if cond else e2 (<a href="/facts/Python_(programming_language)/YbuGqofa">Python</a>). Please take a look at <a href="/facts/Ternary_conditional_operator/3C8mgMD9">ternary conditional operator#Usage</a>.

Boolean and/or operators in common languages<table><tbody><tr><th>Language</th><th><a href="/facts/Eager_evaluation/vLXH27zR">Eager</a> operators</th><th>Short-circuit operators</th><th>Result type</th></tr><tr><td><a href="/facts/Ada_(programming_language)/Y2yHel4l">Ada</a></td><td>and, or</td><td>and then, or else</td><td>Boolean</td></tr><tr><td><a href="/facts/ALGOL_68/NTnc9fy7">ALGOL 68</a></td><td>and, &, ∧ ; or, ∨</td><td>andf , orf (both user defined)</td><td>Boolean</td></tr><tr><td><a href="/facts/APL_(programming_language)/E2sb98gC">APL</a></td><td>∧, ∨</td><td>:AndIf, :OrIf</td><td>Boolean</td></tr><tr><td><a href="/facts/Awk/lAQ0leyj">awk</a></td><td>none</td><td>&&, ||</td><td>Boolean</td></tr><tr><td><a href="/facts/C_(programming_language)/Ky2No763">C</a>, <a href="/facts/Objective-C/5mM557BW">Objective-C</a></td><td>&, |<a class="footnote-ref" id="fnref:4" href="#fn:4">4</a></td><td>&&, ||<a class="footnote-ref" id="fnref:5" href="#fn:5">5</a></td><td>int</td></tr><tr><td><a href="/facts/C%2B%2B/Et0F2qn9">C++</a><a class="footnote-ref" id="fnref:6" href="#fn:6">6</a></td><td>none</td><td>&&, ||<a class="footnote-ref" id="fnref:7" href="#fn:7">7</a></td><td>Boolean</td></tr><tr><td><a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a></td><td>&, |</td><td>&&, ||</td><td>Boolean</td></tr><tr><td><a href="/facts/D_(programming_language)/4qIzRjkF">D</a><a class="footnote-ref" id="fnref:8" href="#fn:8">8</a></td><td>&, |</td><td>&&, ||</td><td>Boolean</td></tr><tr><td><a href="/facts/Eiffel_(programming_language)/gEzPjzmn">Eiffel</a></td><td>and, or</td><td>and then, or else</td><td>Boolean</td></tr><tr><td><a href="/facts/Erlang_(programming_language)/2PuxmzT3">Erlang</a></td><td>and, or</td><td>andalso, orelse</td><td>Boolean</td></tr><tr><td><a href="/facts/Fortran/m1KqjcMU">Fortran</a><a class="footnote-ref" id="fnref:9" href="#fn:9">9</a></td><td>.and., .or.</td><td>.and., .or.</td><td>Boolean</td></tr><tr><td><a href="/facts/Go_(programming_language)/oWlsmAFJ">Go</a>, <a href="/facts/Haskell_(programming_language)/4Htv9WLu">Haskell</a>, <a href="/facts/OCaml/ThBGLND8">OCaml</a><a class="footnote-ref" id="fnref:10" href="#fn:10">10</a></td><td>none</td><td>&&, ||</td><td>Boolean</td></tr><tr><td><a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>, <a href="/facts/R_(programming_language)/LSrkr8K8">R</a>, <a href="/facts/Swift_(programming_language)/A7qHQC32">Swift</a></td><td>&, |</td><td>&&, ||</td><td>Boolean</td></tr><tr><td><a href="/facts/JavaScript/XhhIIEsl">JavaScript</a></td><td>none</td><td>&&, ||</td><td>Last value</td></tr><tr><td><a href="/facts/Julia_(programming_language)/AoB0PJ9C">Julia</a></td><td>none</td><td>&&, ||</td><td>Last value</td></tr><tr><td><a href="/facts/Kotlin_(programming_language)/CrAqIFLn">Kotlin</a></td><td>and, or</td><td>&&, ||</td><td>Boolean</td></tr><tr><td><a href="/facts/Lisp_(programming_language)/xJHA3CrX">Lisp</a>, <a href="/facts/Lua_(programming_language)/xkBCgta0">Lua</a><a class="footnote-ref" id="fnref:11" href="#fn:11">11</a>, <a href="/facts/Scheme_(programming_language)/0aGdf3SC">Scheme</a></td><td>none</td><td>and, or</td><td>Last value</td></tr><tr><td><a href="/facts/MATLAB/qPjLISCk">MATLAB</a><a class="footnote-ref" id="fnref:12" href="#fn:12">12</a></td><td>&, |</td><td>&, |, &&, ||</td><td>Boolean</td></tr><tr><td><a href="/facts/MUMPS/06E3hkoE">MUMPS</a> (M)</td><td>&, !</td><td>none</td><td>Numeric</td></tr><tr><td><a href="/facts/Modula-2/DFyUTdAq">Modula-2</a></td><td>none</td><td>AND, OR</td><td>Boolean</td></tr><tr><td><a href="/facts/Pascal_(programming_language)/b3yvp8bF">Pascal</a></td><td>and, or<a class="footnote-ref" id="fnref:13" href="#fn:13">13</a><a class="footnote-ref" id="fnref:14" href="#fn:14">14</a></td><td>and_then, or_else<a class="footnote-ref" id="fnref:15" href="#fn:15">15</a></td><td>Boolean</td></tr><tr><td><a href="/facts/Perl/fx31kjlT">Perl</a></td><td>&, |</td><td>&&, and, ||, or</td><td>Last value</td></tr><tr><td><a href="/facts/PHP/vU6YRJX0">PHP</a></td><td>none</td><td>&&, and, ||, or</td><td>Boolean</td></tr><tr><td><a href="/facts/POSIX_shell/2G4T2Fb9">POSIX shell</a>, <a href="/facts/Bash_(Unix_shell)/RrYLtEJT">Bash</a></td><td>none</td><td>&&, ||</td><td>Numeric (exit code)</td></tr><tr><td><a href="/facts/PowerShell/G1d10lwn">PowerShell</a> Scripting Language</td><td>none</td><td>-and, -or</td><td>Boolean</td></tr><tr><td><a href="/facts/Python_(programming_language)/YbuGqofa">Python</a></td><td>&, |</td><td>and, or</td><td>Last value</td></tr><tr><td><a href="/facts/Ruby_(programming_language)/BeYSaPSR">Ruby</a></td><td>&, |</td><td>&&, and, ||, or<a class="footnote-ref" id="fnref:16" href="#fn:16">16</a></td><td>Last value</td></tr><tr><td><a href="/facts/Rust_(programming_language)/8JNMV19F">Rust</a></td><td>&, |</td><td>&&, ||<a class="footnote-ref" id="fnref:17" href="#fn:17">17</a></td><td>Boolean</td></tr><tr><td><a href="/facts/Smalltalk/Ru2UPVDE">Smalltalk</a></td><td>&, |</td><td>and:, or:<a class="footnote-ref" id="fnref:18" href="#fn:18">18</a></td><td>Boolean</td></tr><tr><td><a href="/facts/Standard_ML/4LaEq9tA">Standard ML</a></td><td>Unknown</td><td>andalso, orelse</td><td>Boolean</td></tr><tr><td><a href="/facts/Visual_Basic_.NET/09mPEo4q">Visual Basic .NET</a></td><td>And, Or</td><td>AndAlso, OrElse</td><td>Boolean</td></tr><tr><td><a href="/facts/Visual_Basic/7QMXM6fP">Visual Basic</a>, <a href="/facts/Visual_Basic_for_Applications/aXrmxDlI">Visual Basic for Applications</a> (VBA)</td><td>And, Or</td><td>none</td><td>Numeric</td></tr></tbody></table>

<h2 id="common-use">Common use</h2>
<h3>Avoiding undesired side effects of the second argument</h3>
Usual example, using a <a href="/facts/C_(programming_language)/Ky2No763">C-based</a> language:

int denom = 0;
if (denom != 0 && num / denom)
{
 ... // ensures that calculating num/denom never results in divide-by-zero error 
}

Consider the following example:

int a = 0;
if (a != 0 && myfunc(b))
{
 do_something();
}

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.

<ol><li>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.</li>
<li>It permits a construct where the first expression guarantees a condition without which the second expression may cause a <a href="/facts/Run-time_error/lCxKsrzB">run-time error</a>.</li></ol>
Both are illustrated in the following C snippet where minimal evaluation prevents both null pointer dereference and excess memory fetches:

bool is_first_char_valid_alpha_unsafe(const char *p)
{
 return isalpha(p[0]); // SEGFAULT highly possible with p == NULL
}

bool is_first_char_valid_alpha(const char *p)
{
    return p != NULL && isalpha(p[0]); // 1) no unneeded isalpha() execution with p == NULL, 2) no SEGFAULT risk
}

<h3>Idiomatic conditional construct</h3>
Since minimal evaluation is part of an operator's semantic definition and not an optional <a href="/facts/Compiler_optimization/JXnv4LUd">optimization</a>, a number of coding idioms rely on it as a succinct conditional construct. Examples include:
<a href="/facts/Perl/fx31kjlT">Perl</a> idioms:

some_condition or die; # Abort execution if some_condition is false
some_condition and die; # Abort execution if some_condition is true

<a href="/facts/POSIX_shell/2G4T2Fb9">POSIX shell</a> idioms:<a class="footnote-ref" id="fnref:19" href="#fn:19">19</a>

modprobe -q some_module && echo "some_module installed" || echo "some_module not installed"

This idiom presumes that echo cannot fail.

<h2 id="possible-problems">Possible problems</h2>
<h3>Untested second condition leads to unperformed side effect</h3>
Despite these benefits, minimal evaluation may cause problems for programmers who do not realize (or forget) it is happening. For example, in the code

if (expressionA && myfunc(b)) {
 do_something();
}

if myfunc(b) is supposed to perform some required operation regardless of whether do_something() 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 <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>, 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.<a class="footnote-ref" id="fnref:20" href="#fn:20">20</a>

<h3>Reduced efficiency due to constraining optimizations</h3>
Short-circuiting can lead to errors in <a href="/facts/Branch_prediction/pGPhFMj5">branch prediction</a> on modern <a href="/facts/Central_processing_unit/Jxp1bqMV">central processing units</a> (CPUs), and dramatically reduce performance. A notable example is highly optimized ray with axis aligned box intersection code in <a href="/facts/Ray_tracing_(physics)/VKdjk6Sc">ray tracing</a>. Some compilers can detect such cases and emit faster code, but programming language semantics may constrain such optimizations.
An example of a compiler unable to optimize for such a case is <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>'s <a href="/facts/HotSpot_(virtual_machine)/m6vjRXvm">Hotspot virtual machine</a> (VM) as of 2012.<a class="footnote-ref" id="fnref:21" href="#fn:21">21</a>

<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Don%27t-care_term/kvQuwYMK">Don't-care term</a></li>
<li><a href="/facts/Null_coalescing_operator/U1T9KMKJ">Null coalescing operator</a></li>
<li><a href="/facts/Ternary_conditional_operator/3C8mgMD9">Ternary conditional operator</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1">Edsger W. Dijkstra "On a somewhat disappointing correspondence", EWD1009-0, 25 May 1987 full text <a href="/wiki/Edsger_W._Dijkstra" target="_blank">/wiki/Edsger_W._Dijkstra</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></li>
<li id="fn:2">"Shell Command Language". pubs.opengroup.org. <a href="https://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html" target="_blank">https://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></li>
<li id="fn:3">Bergstra, Jan A.; Ponse, A.; Staudt, D.J.C. (2010). "Short-circuit logic". arXiv:1010.3674 [cs.LO]. <a href="/wiki/ArXiv_(identifier)" target="_blank">/wiki/ArXiv_(identifier)</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></li>
<li id="fn:4">The bitwise operators behave like boolean operators when both arguments are of type bool or take only the values 0 or 1.[4] <a href="#fnref:4" class="footnote-back-ref">↩</a></li>
<li id="fn:5">ISO/IEC 9899 standard, section 6.5.13 <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf" target="_blank">http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></li>
<li id="fn:6">When overloaded, the operators && and || are eager and can return any type. <a href="/wiki/Operator_overloading" target="_blank">/wiki/Operator_overloading</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></li>
<li id="fn:7">ISO/IEC IS 14882 draft. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf" target="_blank">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></li>
<li id="fn:8">This only applies to runtime-evaluated expressions, static if and static assert. Expressions in static initializers or manifest constants use eager evaluation. <a href="#fnref:8" class="footnote-back-ref">↩</a></li>
<li id="fn:9">Fortran operators are neither short-circuit nor eager: the language specification allows the compiler to select the method for optimization. <a href="/wiki/Compiler" target="_blank">/wiki/Compiler</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></li>
<li id="fn:10">In lua and OCaml, bitwise operators &, | (OCaml land, lor) are restricted to integers and cannot be used with Booleans. <a href="#fnref:10" class="footnote-back-ref">↩</a></li>
<li id="fn:11">In lua and OCaml, bitwise operators &, | (OCaml land, lor) are restricted to integers and cannot be used with Booleans. <a href="#fnref:11" class="footnote-back-ref">↩</a></li>
<li id="fn:12">The operator & behaves like a short-circuit operator when used in a statement following if or while.[7] <a href="#fnref:12" class="footnote-back-ref">↩</a></li>
<li id="fn:13">ISO/IEC 10206:1990 Extended Pascal allows, but does not require, short-circuiting. <a href="/wiki/Pascal_(programming_language)#ISO/IEC_10206:1990_Extended_Pascal" target="_blank">/wiki/Pascal_(programming_language)#ISO/IEC_10206:1990_Extended_Pascal</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></li>
<li id="fn:14">Delphi and Free Pascal default to short circuit evaluation. This may be changed by compiler options but does not seem to be used widely. <a href="/wiki/Delphi_(software)" target="_blank">/wiki/Delphi_(software)</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></li>
<li id="fn:15">Delphi and Free Pascal default to short circuit evaluation. This may be changed by compiler options but does not seem to be used widely. <a href="/wiki/Delphi_(software)" target="_blank">/wiki/Delphi_(software)</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></li>
<li id="fn:16">"operators - Documentation for Ruby 3.3". docs.ruby-lang.org. Retrieved 2024-04-02. <a href="https://docs.ruby-lang.org/en/3.3/syntax/operators_rdoc.html#label-Logical+Operators" target="_blank">https://docs.ruby-lang.org/en/3.3/syntax/operators_rdoc.html#label-Logical+Operators</a> <a href="#fnref:16" class="footnote-back-ref">↩</a></li>
<li id="fn:17">"std::ops - Rust". doc.rust-lang.org. Retrieved 2019-02-12. <a href="https://doc.rust-lang.org/std/ops/index.html" target="_blank">https://doc.rust-lang.org/std/ops/index.html</a> <a href="#fnref:17" class="footnote-back-ref">↩</a></li>
<li id="fn:18">Smalltalk uses short-circuit semantics as long as the argument to and: is a block (e.g., false and: [Transcript show: 'Wont see me']). <a href="#fnref:18" class="footnote-back-ref">↩</a></li>
<li id="fn:19">"What does || mean in bash?". stackexchange.com. Retrieved 2019-01-09. <a href="https://unix.stackexchange.com/questions/190543/what-does-mean-in-bash" target="_blank">https://unix.stackexchange.com/questions/190543/what-does-mean-in-bash</a> <a href="#fnref:19" class="footnote-back-ref">↩</a></li>
<li id="fn:20">"Referential Transparency, Definiteness and Unfoldability" (PDF). Itu.dk. Retrieved 2013-08-24. <a href="http://www.itu.dk/people/sestoft/papers/SondergaardSestoft1990.pdf" target="_blank">http://www.itu.dk/people/sestoft/papers/SondergaardSestoft1990.pdf</a> <a href="#fnref:20" class="footnote-back-ref">↩</a></li>
<li id="fn:21">Wasserman, Louis (11 July 2012). "Java: What are the cases in which it is better to use unconditional AND (& instead of &&)". Stack Overflow. <a href="https://stackoverflow.com/a/11412121" target="_blank">https://stackoverflow.com/a/11412121</a> <a href="#fnref:21" class="footnote-back-ref">↩</a></li>
</ol>

Short-circuit evaluation open-in-new

Short-circuit evaluation