no-useless-assignment

Disallow variable assignments when the value is not used

Wikipedia describes a “dead store” as follows:

In computer programming, a local variable that is assigned a value but is not read by any subsequent instruction is referred to as a dead store.

“Dead stores” waste processing and memory, so it is better to remove unnecessary assignments to variables.

Also, if the author intended the variable to be used, there is likely a mistake around the dead store. For example,

you should have used a stored value but forgot to do so.
you made a mistake in the name of the variable to be stored.

let id = "x1234";    // this is a "dead store" - this value ("x1234") is never read

id = generateId();

doSomethingWith(id);
1
2
3
4
5

Rule Details

This rule aims to report variable assignments when the value is not used.

Examples of incorrect code for this rule:

Open in Playground

/* eslint no-useless-assignment: "error" */

function fn1() {
    let v = 'used';
    doSomething(v);
    v = 'unused';
}

function fn2() {
    let v = 'used';
    if (condition) {
        v = 'unused';
        return
    }
    doSomething(v);
}

function fn3() {
    let v = 'used';
    if (condition) {
        doSomething(v);
    } else {
        v = 'unused';
    }
}

function fn4() {
    let v = 'unused';
    if (condition) {
        v = 'used';
        doSomething(v);
        return
    }
}

function fn5() {
    let v = 'used';
    if (condition) {
        let v = 'used';
        console.log(v);
        v = 'unused';
    }
    console.log(v);
}
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

Examples of correct code for this rule:

Open in Playground

/* eslint no-useless-assignment: "error" */

function fn1() {
    let v = 'used';
    doSomething(v);
    v = 'used-2';
    doSomething(v);
}

function fn2() {
    let v = 'used';
    if (condition) {
        v = 'used-2';
        doSomething(v);
        return
    }
    doSomething(v);
}

function fn3() {
    let v = 'used';
    if (condition) {
        doSomething(v);
    } else {
        v = 'used-2';
        doSomething(v);
    }
}

function fn4() {
    let v = 'used';
    for (let i = 0; i < 10; i++) {
        doSomething(v);
        v = 'used in next iteration';
    }
}
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

This rule will not report variables that are never read. Because it’s clearly an unused variable. If you want it reported, please enable the no-unused-vars rule.

Open in Playground

/* eslint no-useless-assignment: "error" */

function fn() {
    let v = 'unused';
    v = 'unused-2'
    doSomething();
}
1
2
3
4
5
6
7

Known Limitations

This rule does not report certain variable reassignments when they occur inside the try block. This is intentional because such assignments may still be observed within the corresponding catch block or after the try-catch structure, due to potential early exits or error handling logic.

function foo() {
    let bar;
    try {
        bar = 2;
        unsafeFn();
        return { error: undefined };
    } catch {
        return { bar }; // `bar` is observed in the catch block
    }
}   
function unsafeFn() {
    throw new Error();
}

function foo() {
    let bar;
    try {
        bar = 2; // This assignment is relevant if unsafeFn() throws an error
        unsafeFn();
        bar = 4;
    } catch {
        // Error handling
    }
    return bar;
}   
function unsafeFn() {
    throw new Error();
}
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