Suggest an edit

Improve this article

Refine the answer for “What is a branching algorithm?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## Short answer

A branching algorithm is an algorithm in which, depending on whether a condition is true, one of the alternative branches of action is chosen and executed. In code it is implemented with if/else, else if, switch, and the ternary operator ?:, while the branches that are not chosen are skipped.

## Detailed breakdown

### Definition

A branching algorithm contains decision points: based on the result of checking conditions, one of the possible execution branches is chosen. Most often the branches are mutually exclusive (if / else if / else). Independent checks are also possible (several ifs), where several branches can execute in a row.

### When it is used

- Validating and normalizing input data
- Choosing a variant of business logic (different plans, statuses, modes)
- Handling errors and exceptions, recovering from errors
- Routing/navigation, choosing a UI view
- Feature flags, A/B testing
- Access control (roles/permissions)

### Basic forms of branching

#### if / else

```javascript
const age = 20;
if (age >= 18) {
  console.log('Adult');
} else {
  console.log('Minor');
}
```

One of two branches is chosen depending on the condition.

#### else if (multiple choice)

```javascript
const score = 73;
let grade;
if (score >= 90) grade = 'A';
else if (score >= 75) grade = 'B';
else if (score >= 60) grade = 'C';
else grade = 'D';

// Only the first matching branch executes.
```

#### switch (choice by value)

```javascript
function access(role) {
  switch (role) {
    case 'admin':
      return 'Full access';
    case 'manager':
      return 'Limited access';
    case 'user':
      return 'Basic access';
    default:
      return 'Guest';
  }
}

// Important: do not forget default, and avoid unwanted "fallthrough".
```

#### The ternary operator (expression)

```javascript
const isMobile = window.innerWidth < 768;
const layout = isMobile ? 'mobile' : 'desktop';

// Good for compact assignments, do not overuse nesting.
```

#### Early returns (guard clauses)

```javascript
function processOrder(order) {
  if (!order) return 'No order';
  if (!order.items?.length) return 'Empty order';
  if (order.canceled) return 'Order canceled';

// Main logic
  return 'OK';
}

// Reduce nesting and improve readability.
```

### Conditions and logic in JavaScript

Comparisons: `===, !==, >, >=, <, <=`. Logic: `&&, ||, !`. Short-circuiting lets you write compact checks.

Falsy values (considered false in a condition): false, 0, -0, 0n, "", null, undefined, NaN. Everything else is truthy.

### Typical mistakes and best practices

- Use strict comparisons ===/!== instead of ==/!= to avoid non-obvious type coercions.
- Do not place side effects inside conditions; compute them beforehand.
- Avoid deep if nesting - use early returns and move logic into functions/predicates.
- In a switch, do not forget default; use break or return to prevent accidental fallthrough.
- Try to make conditions self-documenting: move complex checks into functions with clear names.
- If the choice depends on a key value (for example, by role), a mapping can be used instead of a long else-if chain:

```javascript
  const accessByRole = {
    admin: 'Full access',
    manager: 'Limited access',
    user: 'Basic access',
    default: 'Guest',
  };
  const role = 'manager';
  const access = accessByRole[role] ?? accessByRole.default;
  ```

### Complexity and testing

Every branching point increases cyclomatic complexity. Keep functions short and branching flat. Ensure test coverage for every branch: positive/negative scenarios and edge cases.

### Small examples from web development

1) Form validation:

```javascript
function validateSignup({ email, password }) {
  if (!email) return 'Enter an email';
  if (!/\S+@\S+\.\S+/.test(email)) return 'Invalid email';
  if (!password) return 'Enter a password';
  if (password.length < 8) return 'Password is too short';
  return 'OK';
}
```

2) Handling a server response:

```javascript
async function fetchUser(id) {
  if (!id) throw new Error('id is required');

const res = await fetch(`/api/users/${id}`);

if (!res.ok) {
    if (res.status === 404) return null; // branch: user not found
    throw new Error('Server error'); // branch: other error
  }

return res.json(); // branch: success
}
```

### Conclusion

A branching algorithm is a basic tool for controlling the execution flow. Skillful use of conditions, the right choice of constructs (if/else, switch, the ternary operator), early returns, and test coverage make code predictable, readable, and resilient.

Markdown · drag & drop images · ⌘B / ⌘I shortcuts677 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.