no-undef-init

Disallow initializing variables to undefined

In JavaScript, a variable that is declared and not initialized to any value automatically gets the value of undefined. For example:

var foo;

console.log(foo === undefined);     // true
1
2
3

It’s therefore unnecessary to initialize a variable to undefined, such as:

var foo = undefined;
1

It’s considered a best practice to avoid initializing variables to undefined.

Rule Details

This rule aims to eliminate var and let variable declarations that initialize to undefined.

Examples of incorrect code for this rule:

/*eslint no-undef-init: "error"*/

var foo = undefined;
let bar = undefined;
1
2
3
4

Examples of correct code for this rule:

/*eslint no-undef-init: "error"*/

var foo;
let bar;
1
2
3
4

Please note that this rule does not check const declarations, using declarations, await using declarations, destructuring patterns, function parameters, and class fields.

Examples of additional correct code for this rule:

/*eslint no-undef-init: "error"*/

const foo = undefined;

using foo1 = undefined;

await using foo2 = undefined;

let { bar = undefined } = baz;

[quux = undefined] = quuux;

(foo = undefined) => {};

class Foo {
    bar = undefined;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

When Not To Use It

There are situations where initializing to undefined behaves differently than omitting the initialization.

One such case is when a var declaration occurs inside of a loop. For example:

Example of incorrect code for this rule:

/*eslint no-undef-init: "error"*/

for (i = 0; i < 10; i++) {
    var x = undefined;
    console.log(x);
    x = i;
}
1
2
3
4
5
6
7

In this case, the var x is hoisted out of the loop, effectively creating:

var x;

for (i = 0; i < 10; i++) {
    x = undefined;
    console.log(x);
    x = i;
}
1
2
3
4
5
6
7

If you were to remove the initialization, then the behavior of the loop changes:

for (i = 0; i < 10; i++) {
    var x;
    console.log(x);
    x = i;
}
1
2
3
4
5

This code is equivalent to:

var x;

for (i = 0; i < 10; i++) {
    console.log(x);
    x = i;
}
1
2
3
4
5
6

This produces a different outcome than defining var x = undefined in the loop, as x is no longer reset to undefined each time through the loop.

If you’re using such an initialization inside of a loop, then you should disable this rule.

Example of correct code for this rule, because it is disabled on a specific line:

/*eslint no-undef-init: "error"*/

for (i = 0; i < 10; i++) {
    var x = undefined; // eslint-disable-line no-undef-init
    console.log(x);
    x = i;
}
1
2
3
4
5
6
7

Another such case is when a variable is redeclared using var. For example:

function foo() {
    var x = 1;
    console.log(x); // output: 1

    var x;
    console.log(x); // output: 1

    var x = undefined;
    console.log(x); // output: undefined
}

foo();
1
2
3
4
5
6
7
8
9
10
11
12

In this case, you can avoid redeclaration by changing it to an assignment (x = undefined;), or use an eslint disable comment on a specific line.

Related Rules

• no-undefined
• no-void

Version

This rule was introduced in ESLint v0.0.6.

Resources

• Rule source
• Tests source