---
description: 'Disallow unnecessary equality comparisons against boolean literals.'
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
> 🛑 This file is source code, not the primary documentation location! 🛑
>
> See **https://typescript-eslint.io/rules/no-unnecessary-boolean-literal-compare** for documentation.
Comparing boolean values to boolean literals is unnecessary: those comparisons result in the same booleans.
Using the boolean values directly, or via a unary negation (`!value`), is more concise and clearer.
This rule ensures that you do not include unnecessary comparisons with boolean literals.
A comparison is considered unnecessary if it checks a boolean literal against any variable with just the `boolean` type.
A comparison is **_not_** considered unnecessary if the type is a union of booleans (`string | boolean`, `SomeObject | boolean`, etc.).
## Examples
:::note
Throughout this page, only strict equality (`===` and `!==`) are used in the examples.
However, the implementation of the rule does not distinguish between strict and loose equality.
Any example below that uses `===` would be treated the same way if `==` was used, and `!==` would be treated the same way if `!=` was used.
:::
```ts
declare const someCondition: boolean;
if (someCondition === true) {
}
```
```ts
declare const someCondition: boolean;
if (someCondition) {
}
declare const someObjectBoolean: boolean | Record;
if (someObjectBoolean === true) {
}
declare const someStringBoolean: boolean | string;
if (someStringBoolean === true) {
}
```
## Options
This rule always checks comparisons between a boolean variable and a boolean
literal. Comparisons between nullable boolean variables and boolean literals
are **not** checked by default.
### `allowComparingNullableBooleansToTrue`
{/* insert option description */}
Examples of code for this rule with `{ allowComparingNullableBooleansToTrue: false }`:
```ts option='{ "allowComparingNullableBooleansToTrue": false }'
declare const someUndefinedCondition: boolean | undefined;
if (someUndefinedCondition === true) {
}
declare const someNullCondition: boolean | null;
if (someNullCondition !== true) {
}
```
```ts option='{ "allowComparingNullableBooleansToTrue": false }'
declare const someUndefinedCondition: boolean | undefined;
if (someUndefinedCondition) {
}
declare const someNullCondition: boolean | null;
if (!someNullCondition) {
}
```
### `allowComparingNullableBooleansToFalse`
{/* insert option description */}
Examples of code for this rule with `{ allowComparingNullableBooleansToFalse: false }`:
```ts option='{ "allowComparingNullableBooleansToFalse": false }'
declare const someUndefinedCondition: boolean | undefined;
if (someUndefinedCondition === false) {
}
declare const someNullCondition: boolean | null;
if (someNullCondition !== false) {
}
```
```ts option='{ "allowComparingNullableBooleansToFalse": false }'
declare const someUndefinedCondition: boolean | undefined;
if (!(someUndefinedCondition ?? true)) {
}
declare const someNullCondition: boolean | null;
if (someNullCondition ?? true) {
}
```
### `allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing`
:::danger Deprecated
This option will be removed in the next major version of typescript-eslint.
:::
{/* insert option description */}
Without `strictNullChecks`, TypeScript essentially erases `undefined` and `null` from the types. This means when this rule inspects the types from a variable, **it will not be able to tell that the variable might be `null` or `undefined`**, which essentially makes this rule useless.
You should be using `strictNullChecks` to ensure complete type-safety in your codebase.
If for some reason you cannot turn on `strictNullChecks`, but still want to use this rule - you can use this option to allow it - but know that the behavior of this rule is _undefined_ with the compiler option turned off. We will not accept bug reports if you are using this option.
## Fixer
| Comparison | Fixer Output | Notes |
| :----------------------------: | ------------------------------- | ----------------------------------------------------------------------------------- |
| `booleanVar === true` | `booleanVar` | |
| `booleanVar !== true` | `!booleanVar` | |
| `booleanVar === false` | `!booleanVar` | |
| `booleanVar !== false` | `booleanVar` | |
| `nullableBooleanVar === true` | `nullableBooleanVar` | Only checked/fixed if the `allowComparingNullableBooleansToTrue` option is `false` |
| `nullableBooleanVar !== true` | `!nullableBooleanVar` | Only checked/fixed if the `allowComparingNullableBooleansToTrue` option is `false` |
| `nullableBooleanVar === false` | `!(nullableBooleanVar ?? true)` | Only checked/fixed if the `allowComparingNullableBooleansToFalse` option is `false` |
| `nullableBooleanVar !== false` | `nullableBooleanVar ?? true` | Only checked/fixed if the `allowComparingNullableBooleansToFalse` option is `false` |
## When Not To Use It
Do not use this rule when `strictNullChecks` is disabled.
ESLint is not able to distinguish between `false` and `undefined` or `null` values.
This can cause unintended code changes when using autofix.