useConst

import { Tabs, TabItem } from '@astrojs/starlight/components';

<Tabs> <TabItem label="JavaScript (and super languages)" icon="seti:javascript"> ## Summary - Rule available since: `v1.0.0` - Diagnostic Category: [`lint/style/useConst`](/reference/diagnostics#diagnostic-category) - This rule is **recommended**, meaning it is enabled by default. - This rule has a [**safe**](/linter/#safe-fixes) fix. - The default severity of this rule is [**warning**](/reference/diagnostics#warning). - Sources: - Same as [`prefer-const`](https://eslint.org/docs/latest/rules/prefer-const)

How to configure

json

{
	"linter": {
		"rules": {
			"style": {
				"useConst": "error"
			}
		}
	}
}

Description

Require const declarations for variables that are only assigned once.

Variables that are initialized and never reassigned and variables that are only assigned once can be declared as const.

Examples

Invalid

let a = 3;
console.log(a);

<pre class="language-text"><code class="language-text">code-block.js:1:1 <a href="https://biomejs.dev/linter/rules/use-const">lint/style/useConst</a> FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ⚠ This let declares a variable that is only assigned once. > 1 │ let a = 3; │ ^^^ 2 │ console.log(a); 3 │ ℹ 'a' is never reassigned. > 1 │ let a = 3; │ ^ 2 │ console.log(a); 3 │ ℹ Safe fix: Use const instead. 1 │ - let·a·=·3; 1 │ + const·a·=·3; 2 2 │ console.log(a); 3 3 │ </code></pre>

// `a` is redefined (not reassigned) on each loop step.
for (let a of [1, 2, 3]) {
    console.log(a);
}

<pre class="language-text"><code class="language-text">code-block.js:2:6 <a href="https://biomejs.dev/linter/rules/use-const">lint/style/useConst</a> FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ⚠ This let declares a variable that is only assigned once. 1 │ // `a` is redefined (not reassigned) on each loop step. > 2 │ for (let a of [1, 2, 3]) { │ ^^^ 3 │ console.log(a); 4 │ } ℹ 'a' is never reassigned. 1 │ // `a` is redefined (not reassigned) on each loop step. > 2 │ for (let a of [1, 2, 3]) { │ ^ 3 │ console.log(a); 4 │ } ℹ Safe fix: Use const instead. 1 1 │ // `a` is redefined (not reassigned) on each loop step. 2 │ - for·(let·a·of·[1,·2,·3])·{ 2 │ + for·(const·a·of·[1,·2,·3])·{ 3 3 │ console.log(a); 4 4 │ } </code></pre>

// `a` is redefined (not reassigned) on each loop step.
for (let a in [1, 2, 3]) {
    console.log(a);
}

<pre class="language-text"><code class="language-text">code-block.js:2:6 <a href="https://biomejs.dev/linter/rules/use-const">lint/style/useConst</a> FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ⚠ This let declares a variable that is only assigned once. 1 │ // `a` is redefined (not reassigned) on each loop step. > 2 │ for (let a in [1, 2, 3]) { │ ^^^ 3 │ console.log(a); 4 │ } ℹ 'a' is never reassigned. 1 │ // `a` is redefined (not reassigned) on each loop step. > 2 │ for (let a in [1, 2, 3]) { │ ^ 3 │ console.log(a); 4 │ } ℹ Safe fix: Use const instead. 1 1 │ // `a` is redefined (not reassigned) on each loop step. 2 │ - for·(let·a·in·[1,·2,·3])·{ 2 │ + for·(const·a·in·[1,·2,·3])·{ 3 3 │ console.log(a); 4 4 │ } </code></pre>

let a;
a = 0;

<pre class="language-text"><code class="language-text">code-block.js:1:1 <a href="https://biomejs.dev/linter/rules/use-const">lint/style/useConst</a> ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ⚠ This let declares a variable that is only assigned once. > 1 │ let a; │ ^^^ 2 │ a = 0; 3 │ ℹ 'a' is only assigned here. 1 │ let a; > 2 │ a = 0; │ ^ 3 │ </code></pre>

let a = 3;
{
    let a = 4;
    a = 2;
}

<pre class="language-text"><code class="language-text">code-block.js:1:1 <a href="https://biomejs.dev/linter/rules/use-const">lint/style/useConst</a> FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ⚠ This let declares a variable that is only assigned once. > 1 │ let a = 3; │ ^^^ 2 │ { 3 │ let a = 4; ℹ 'a' is never reassigned. > 1 │ let a = 3; │ ^ 2 │ { 3 │ let a = 4; ℹ Safe fix: Use const instead. 1 │ - let·a·=·3; 1 │ + const·a·=·3; 2 2 │ { 3 3 │ let a = 4; </code></pre>

Valid

let a = 2;
a = 3;
console.log(a);

let a = 1, b = 2;
b = 3;

let a;
a; // the variable is read before its assignment
a = 0;

Caveats

Since v2.2, the rule no longer reports variables that are read in an inner function before being written. This can result in false negatives. For example, the following code is now valid:

let a;
function f() {
    return a; // read
}
a = 0; // written

</TabItem> </Tabs>