When to use if-else, switch-case, or functions like Array.prototype.includes() or Array.prototype.find()

In JavaScript, choosing between if-else, switch-case, or functions like Array.prototype.includes() or Array.prototype.find() depends on the specific use case, readability, performance, and the type of conditions you are handling. Below is a comparison of these constructs, along with suggestions for when to use each.

1. if-else:
Purpose: Evaluates a sequence of conditions and executes code based on whether a condition is true or false.
Behavior: Each condition is checked in sequence, and the first matching condition is executed.
Use case: Best suited for handling boolean logic, range checks, or complex conditions.
Example:

let age = 25;

if (age < 18) {
    console.log('Too young');
} else if (age >= 18 && age <= 65) {
    console.log('Eligible for work');
} else {
    console.log('Retired');
}

When to use:
Complex or multiple conditions: Use if-else when you need to check more complex or non-discrete conditions, such as logical combinations, ranges, or dynamic evaluations.
Small number of conditions: Ideal for situations where there are only a few conditions to evaluate.
Flexible condition evaluation: if-else allows you to combine logical operators (&&, ||, etc.) for more complex checks.

2. switch-case:
Purpose: Compares a single expression (often a variable or value) against multiple possible cases.
Behavior: The expression is evaluated once, and the corresponding case block is executed. If no cases match, the default block runs.
Use case: Best suited for discrete or enumerated values where multiple cases need to be evaluated.
Example:

let day = 'Monday';

switch (day) {
    case 'Monday':
        console.log('Start of the week');
        break;
    case 'Wednesday':
        console.log('Midweek');
        break;
    case 'Friday':
        console.log('Almost weekend');
        break;
    default:
        console.log('Unknown day');
}

When to use:
Discrete values: Use switch-case when you have a single variable that could take one of a limited number of known values (e.g., enums, constants, or states).
Many possible values: It’s ideal when you have multiple specific cases to handle.
Readability: switch-case makes code easier to read than using multiple if-else for discrete values.

3. Functions like includes() and find():
Purpose: Used to check for the existence of a value in an array (includes()) or to find an object/value within an array (find()).
Behavior: These functions operate on arrays, returning a boolean (includes) or the found value (find).
Use case: Best suited for array-based checks, such as finding if a value is present in a list or array of objects.

Example of includes():

const fruits = ['apple', 'banana', 'cherry'];

if (fruits.includes('banana')) {
    console.log('We have bananas!');
} else {
    console.log('No bananas here');
}

Example of find():

const users = [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' },
];

const user = users.find(user => user.id === 2);
console.log(user);  // Output: { id: 2, name: 'Bob' }

When to use:

Array lookups: Use includes() when you want to check if a value exists in an array.
Finding objects in arrays: Use find() when searching for an object in an array of objects based on a specific condition.
Efficient membership tests: These methods are particularly effective when you need to check for the presence of an item in a large dataset (array).