
When a variable is compared against a string value, the easiest way to start is with a `variable === "value"` or `variable !== "value"` comparison.
Over time, these can grow into longer sequences, e.g. `variable === "value1" || variable === "value2" || variable === "value3"`.

The values that the variable is compared to are often a meaningful collection on their own. 
Refactoring them into an array and using `array.includes(variable)` can facilitate reuse and extension, and a meaningful array name can make it easier to understand the code.

### Before
```javascript
if (extension !== "js" && extension !== "ts" && extension !== "tsx") {
  handleUnsupportedExtension(extension)
}
```

### Refactoring Steps
1. [Convert string comparison chain to array.includes](/documentation/code-action/convert-or-equal-chain-to-array-includes)
1. [Extract the array into a variable](/documentation/code-action/extract-variable)
1. Move the extracted array variable, e.g., to the top of the file (not shown)

### After
```javascript
const SUPPORTED_EXTENSIONS = ["js", "ts", "tsx"];
if (!SUPPORTED_EXTENSIONS.includes(extension)) {
  handleUnsupportedExtension(extension)
}
```

Convert && !== and || === chains into array.includes.

Extract array constant from string comparison chain



If-statements can contain duplicated statements with minimal differences. For example, copy-paste changes can result in such code duplication. The duplication can often be simplified by extracting the difference using the [conditional operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator) and reducing the if-else to the deduplicated statement.

### Before
```javascript
if (direction === "left") {
  move(original.x, -10);
} else {
  move(original.x, 10);
}
```

### Refactoring Steps
1. [Extract variable](/documentation/code-action/extract-variable) twice with the same variable name
1. [Split declaration and initialization](/documentation/code-action/split-variable-declaration-and-initialization) of both extracted constants
1. [Move duplicated first statement out of if-else](/documentation/code-action/move-first-statement-out-of-if-else)
1. [Move duplicated last statement out of if-else](/documentation/code-action/move-last-statement-out-of-if-else)
1. [Convert the if-else statement into a conditional expression](/documentation/code-action/convert-if-else-to-conditional-expression)
1. [Merge variable declaration and initialization](/documentation/code-action/merge-variable-declaration-and-initialization)
1. [Inline variable](/documentation/code-action/inline-variable)

### After
```javascript
move(original.x, direction === "left" ? -10 : 10);
```


Convert an if-else statement with a duplicated function call into a function call with a conditional expression.

Simplify duplicated function call inside if-else statement


If-statements are sometimes used to initialize variables with different values depending on a condition. This usage of if-statements can lead to unnecessary code duplication and can often be shortened with the [conditional operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator).


### Before
```javascript
let movedObject;
if (direction === "left") {
  movedObject = moveLeft(original);
} else {
  movedObject = moveRight(original);
}
```

### Refactoring Steps
1. [Convert the if-else statement into a conditional expression](/documentation/code-action/convert-if-else-to-conditional-expression)
1. [Merge variable declaration and initialization](/documentation/code-action/merge-variable-declaration-and-initialization)
1. [Convert let to const](/documentation/code-action/convert-let-to-const)

### After
```javascript
const movedObject = direction === "left"
  ? moveLeft(original)
  : moveRight(original);
```

The change to `const` is only possible if the variable is not re-assigned later. It has the advantage that it communicates the immutability of `movedObject`.



Convert a conditional variable initialization with if-else to a conditional expression.

Refactoring Combos