Use && to skip expensive operations and guard against null/undefined by short-circuiting on falsy values; 2. Use || to set defaults efficiently, but beware it treats all falsy values (like 0) as invalid, so prefer ?? for null/undefined only; 3. Use && or || for concise conditional execution of functions like debug logs or redirects, but avoid for complex logic to maintain readability; 4. Chain && and || to reduce nesting and return early, ensuring correct behavior by considering truthiness of return values. Short-circuit evaluation improves performance and clarity when used wisely with awareness of falsy values and code readability.

Using short-circuit evaluation with && and || isn’t just about logic—it’s a subtle but effective way to improve performance and avoid unnecessary operations in JavaScript (and other languages that support it). These operators don’t just return true or false; they return the actual value of the operand that determined the result, which makes them powerful tools for conditional execution and default values.

Here’s how you can leverage them smartly:

1. Avoid Expensive Operations with &&

The && operator evaluates left to right and stops as soon as one operand is falsy. This means you can prevent function calls or heavy computations if an earlier condition fails.

// Only call expensiveOperation() if user is logged in and active
if (user.isLoggedIn && user.isActive && expensiveOperation()) {
  // do something
}

In this case, if user.isLoggedIn is false, JavaScript won’t even check user.isActive, and expensiveOperation() won’t run at all. This avoids wasted CPU cycles.

Use case: Guarding against null/undefined before accessing properties or methods:

user && user.profile && user.profile.getName();

This prevents errors if user or user.profile is undefined. Modern JavaScript has optional chaining (?.), but && still works in older environments.

2. Set Defaults Efficiently with ||

The || operator returns the first truthy value. This is perfect for assigning defaults:

const timeout = config.timeout || 5000;
const message = user.input || "No input provided";

If config.timeout is undefined, null, or 0, it falls back to 5000. But be careful: if you allow 0 as a valid value, || will ignore it because 0 is falsy.

Gotcha: || uses falsy checks, not null/undefined checks. So this can backfire:

const delay = config.delay || 100; // if config.delay is 0 → uses 100!

Fix: Use ?? (nullish coalescing) for null/undefined only:

const delay = config.delay ?? 100; // respects 0

But if you're in an environment without ??, and you know the input won’t be 0, "", or false, || is fast and clean.

3. Conditional Execution Without if

You can use short-circuiting for side effects—though this should be used sparingly for readability.

debugMode && logDetailedInfo();

This only runs logDetailedInfo() if debugMode is true. It’s concise and skips the function call entirely when not needed.

Similarly:

isAuthenticated || redirectToLogin();

Redirects only if not authenticated. Again, the function won’t be called if the left side is truthy.

Note: Avoid overusing this style for complex logic—it can hurt readability. But for simple guards or debug logs, it's clean and performant.

4. Chaining Conditions for Early Exits

Combine && and || to streamline logic and reduce nesting:

return user && user.hasRole('admin') && fetchData();

Returns fetchData() result if user exists and is admin; otherwise, returns the first falsy value (undefined or false).

Or:

const result = isValid ? process(data) : fallbackValue;
// Can be rewritten as:
const result = isValid && process(data) || fallbackValue;

But caution: this only works if process(data) returns a truthy value. If it can return 0 or "", the fallback might trigger incorrectly.

Bottom line:
Short-circuit evaluation with && and || lets you:

• Skip unnecessary function calls
• Prevent errors via guard clauses
• Assign defaults concisely
• Improve runtime performance

Just be mindful of falsy values and code clarity. Used wisely, it’s a lightweight optimization that’s both fast and readable.

Basically, if you’re checking conditions or setting defaults, short-circuiting is doing you a favor—let it.

The above is the detailed content of Leveraging Short-Circuit Evaluation with `&&` and `||` for Performance. For more information, please follow other related articles on the PHP Chinese website!