Short-circuiting is where an expression is stopped being evaluated as soon as its outcome is determined. So for instance:
if (a == b || c == d || e == f) {
// Do something
}
If a == b
is true, then c == d
and e == f
are never evaluated at all, because the expression's outcome has already been determined. if a == b
is false, then c == d
is evaluated; if it's true, then e == f
is never evaluated. This may not seem to make any difference, but consider:
if (foo() || bar() || baz()) {
// Do something
}
If foo()
returns true, then bar
and baz
are never called, because the expression's outcome has already been determined. So if bar
or baz
has some other effect than just returning something (a side effect), those effects never occur.
One great example of short-circuiting relates to object references:
if (a != null && a.getFoo() != 42) {
// Do something
}
a.getFoo()
would normally throw a NullPointerException
if a
were null
, but because the expression short-circuits, if a != null
is false
, the a.getFoo()
part never happens, so we don't get an exception.
Note that not all expressions are short-circuited. The ||
and &&
operators are short-circuited, but |
and &
are not, nor are *
or /
; in fact most operators are not.
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…