no-constant-condition

Disallow constant expressions in conditions

A constant expression (for example, a literal) as a test condition might be a typo or development trigger for a specific behavior. For example, the following code looks as if it is not ready for production.

if (false) {
    doSomethingUnfinished();
}
1
2
3

Rule Details

This rule disallows constant expressions in the test condition of:

• if, for, while, or do...while statement
• ?: ternary expression

Examples of incorrect code for this rule:

/*eslint no-constant-condition: "error"*/

if (false) {
    doSomethingUnfinished();
}

if (void x) {
    doSomethingUnfinished();
}

if (x &&= false) {
    doSomethingNever();
}

if (class {}) {
    doSomethingAlways();
}

if (new Boolean(x)) {
    doSomethingAlways();
}

if (Boolean(1)) {
    doSomethingAlways();
}

if (undefined) {
    doSomethingUnfinished();
}

if (x ||= true) {
    doSomethingAlways();
}

for (;-2;) {
    doSomethingForever();
}

while (typeof x) {
    doSomethingForever();
}

do {
    doSomethingForever();
} while (x = -1);

const result = 0 ? a : b;

if(input === "hello" || "bye"){
  output(input);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

Examples of correct code for this rule:

/*eslint no-constant-condition: "error"*/

if (x === 0) {
    doSomething();
}

for (;;) {
    doSomethingForever();
}

while (typeof x === "undefined") {
    doSomething();
}

do {
    doSomething();
} while (x);

const result = x !== 0 ? a : b;

if(input === "hello" || input === "bye"){
  output(input);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Options

checkLoops

This is a string option having following values:

• "all" - Disallow constant expressions in all loops.
• "allExceptWhileTrue" (default) - Disallow constant expressions in all loops except while loops with expression true.
• "none" - Allow constant expressions in loops.

Or instead you can set the checkLoops value to booleans where true is same as "all" and false is same as "none".

Examples of incorrect code for when checkLoops is "all" or true:

/*eslint no-constant-condition: ["error", { "checkLoops": "all" }]*/

while (true) {
    doSomething();
};

for (;true;) {
    doSomething();
};
1
2
3
4
5
6
7
8
9

/*eslint no-constant-condition: ["error", { "checkLoops": true }]*/

while (true) {
    doSomething();
};

do {
    doSomething();
} while (true)
1
2
3
4
5
6
7
8
9

Examples of correct code for when checkLoops is "all" or true:

/*eslint no-constant-condition: ["error", { "checkLoops": "all" }]*/

while (a === b) {
    doSomething();
};
1
2
3
4
5

/*eslint no-constant-condition: ["error", { "checkLoops": true }]*/

for (let x = 0; x <= 10; x++) {
    doSomething();
};
1
2
3
4
5

Example of correct code for when checkLoops is "allExceptWhileTrue":

/*eslint no-constant-condition: "error"*/

while (true) {
    doSomething();
};
1
2
3
4
5

Examples of correct code for when checkLoops is "none" or false:

/*eslint no-constant-condition: ["error", { "checkLoops": "none" }]*/

while (true) {
    doSomething();
    if (condition()) {
        break;
    }
};

do {
    doSomething();
    if (condition()) {
        break;
    }
} while (true)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

/*eslint no-constant-condition: ["error", { "checkLoops": false }]*/

while (true) {
    doSomething();
    if (condition()) {
        break;
    }
};

for (;true;) {
    doSomething();
    if (condition()) {
        break;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Related Rules

• no-constant-binary-expression

Version

This rule was introduced in ESLint v0.4.1.

Resources

• Rule source
• Tests source