Conditional statement specification

Conditional Statement Guidelines

Conditional statements are the core of flow control in programming. Well-written conditional statements improve code readability and maintainability. The following guidelines apply to JavaScript environments and cover best practices for common conditional structures such as if/else and switch.

Basic if Statement Guidelines

if statements should always use curly braces to wrap code blocks, even for single-line statements. Omitting braces may lead to errors during future maintenance.

// Bad example  
if (condition) doSomething();  

// Good example  
if (condition) {  
  doSomething();  
}  

Comparison operations should use strict equality operators (=== and !==) to avoid unexpected behavior due to implicit type coercion:

// Bad example  
if (value == 1) { /*...*/ }  

// Good example  
if (value === 1) { /*...*/ }  

Handling Complex Conditions

When conditional logic involves multiple logical operators, follow these guidelines:

1. Place each logical operator on a new line.
2. Place operators at the beginning of the line rather than the end.
3. Break down complex conditions using temporary variables.

// Hard-to-read version  
if ((user.role === 'admin' || user.role === 'editor') && user.isActive && !user.isSuspended) { /*...*/ }  

// Recommended version  
const isAuthorizedUser = user.role === 'admin' || user.role === 'editor';  
const isValidUser = user.isActive && !user.isSuspended;  

if (isAuthorizedUser && isValidUser) {  
  // Business logic  
}  

Using else and else if

Avoid excessive nesting. If if-else exceeds three levels, consider refactoring. Prioritize handling errors or edge cases early and returning early:

// Not recommended  
function processUser(user) {  
  if (user) {  
    if (user.isActive) {  
      if (!user.isSuspended) {  
        // Core logic  
      } else {  
        throw new Error('User suspended');  
      }  
    } else {  
      throw new Error('Inactive user');  
    }  
  } else {  
    throw new Error('No user provided');  
  }  
}  

// Recommended  
function processUser(user) {  
  if (!user) throw new Error('No user provided');  
  if (!user.isActive) throw new Error('Inactive user');  
  if (user.isSuspended) throw new Error('User suspended');  

  // Core logic  
}  

switch Statement Guidelines

switch statements should follow these rules:

1. Every case must include a break or return.
2. Always include a default case.
3. Group related cases with clear comments.

switch (statusCode) {  
  case 200: {  
    const response = parseResponse(data);  
    return processSuccess(response);  
  }  

  // Client errors  
  case 400:  
  case 401:  
  case 403: {  
    logClientError(statusCode);  
    return handleClientError();  
  }  

  // Server errors  
  case 500:  
  case 502:  
  case 503: {  
    retryRequest();  
    break;  
  }  

  default: {  
    throw new Error(`Unhandled status code: ${statusCode}`);  
  }  
}  

Ternary Operator Usage

Ternary operators are suitable for simple conditional assignments but should not be nested beyond two levels:

// Suitable for simple cases  
const accessLevel = user.isAdmin ? 'admin' : 'user';  

// Avoid deep nesting  
const message = isError  
  ? 'Operation failed'  
  : isLoading  
    ? 'Processing...'  
    : 'Operation completed';  

Performance Optimization for Conditionals

In performance-sensitive scenarios, consider these optimizations:

1. Place the most common conditions first.
2. Use lookup tables instead of complex switch statements.
3. Avoid repeated calculations in conditions.

// Lookup table example  
const handlers = {  
  success: handleSuccess,  
  error: handleError,  
  pending: handlePending  
};  

const handler = handlers[status] || handleDefault;  
handler();  

Testability of Conditional Statements

Write conditionals that are easy to test:

1. Avoid directly using global state.
2. Extract condition checks into pure functions.
3. Use dependency injection instead of hardcoded values.

// Hard to test  
if (Date.now() > expirationDate) { /*...*/ }  

// Testable version  
function isExpired(expirationDate, now = Date.now()) {  
  return now > expirationDate;  
}  

if (isExpired(expirationDate)) { /*...*/ }  

Type Safety in Conditionals

In TypeScript environments, leverage type narrowing in conditionals:

interface User {  
  name: string;  
  age?: number;  
}  

function getUserLabel(user: User) {  
  if (user.age === undefined) {  
    return `${user.name} (age unknown)`;  
  }  

  // TypeScript infers `user.age` as `number` here  
  return `${user.name} (${user.age} years)`;  
}  

Debugging Tips for Conditionals

For easier debugging, add temporary logs in complex conditions:

if (process.env.NODE_ENV === 'development') {  
  console.debug('Condition evaluation:', {  
    conditionA,  
    conditionB,  
    combined: conditionA && conditionB  
  });  
}  

if (conditionA && conditionB) {  
  // ...  
}