noInvalidUseBeforeDeclaration

Este conteúdo não está disponível em sua língua ainda.

JavaScript (and super languages)

Summary

Rule available since: v1.5.0
Diagnostic Category: lint/correctness/noInvalidUseBeforeDeclaration
This rule is recommended, meaning it is enabled by default.
This rule doesn’t have a fix.
The default severity of this rule is error.
Sources:
- Same as no-use-before-define
- Same as @typescript-eslint/no-use-before-define

How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "correctness": {
5
        "noInvalidUseBeforeDeclaration": "error"
6
      }
7
    }
8
  }
9
}

Description

Disallow the use of variables, function parameters, classes, and enums before their declaration

JavaScript doesn’t allow the use of block-scoped variables (let, const), function parameters, and classes before their declaration. Similarly TypeScript doesn’t allow the use of enums before their declaration. A ReferenceError will be thrown with any attempt to access the variable or the parameter before its declaration.

The rule also reports the use of variables declared with var before their declarations.

Examples

Invalid

1
function f() {
2
    console.log(x);
3
    let x;
4
}

code-block.js:2:17 lint/correctness/noInvalidUseBeforeDeclaration ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ This variable is used before its declaration.
  
    1 │ function f() {
  > 2 │     console.log(x);
      │                 ^
    3 │     let x;
    4 │ }
  
  ℹ The variable is declared here:
  
    1 │ function f() {
    2 │     console.log(x);
  > 3 │     let x;
      │         ^
    4 │ }
    5 │ 
  
  ℹ Using a variable before it is declared makes the code depend on declaration order and hoisting behavior.
  
  ℹ Move this use after the declaration, or move the declaration earlier.

1
function f() {
2
    console.log(x);
3
    var x = 0;
4
}

code-block.js:2:17 lint/correctness/noInvalidUseBeforeDeclaration ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ This variable is used before its declaration.
  
    1 │ function f() {
  > 2 │     console.log(x);
      │                 ^
    3 │     var x = 0;
    4 │ }
  
  ℹ The variable is declared here:
  
    1 │ function f() {
    2 │     console.log(x);
  > 3 │     var x = 0;
      │         ^
    4 │ }
    5 │ 
  
  ℹ Using a variable before it is declared makes the code depend on declaration order and hoisting behavior.
  
  ℹ Move this use after the declaration, or move the declaration earlier.

1
function f(a = b, b = 0) {}

code-block.js:1:16 lint/correctness/noInvalidUseBeforeDeclaration ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ This parameter is used before its declaration.
  
  > 1 │ function f(a = b, b = 0) {}
      │                ^
    2 │ 
  
  ℹ The parameter is declared here:
  
  > 1 │ function f(a = b, b = 0) {}
      │                   ^
    2 │ 
  
  ℹ Using a parameter before it is declared makes the code depend on declaration order and hoisting behavior.
  
  ℹ Move this use after the declaration, or move the declaration earlier.

1
new C();
2
class C {}

code-block.js:1:5 lint/correctness/noInvalidUseBeforeDeclaration ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ This class is used before its declaration.
  
  > 1 │ new C();
      │     ^
    2 │ class C {}
    3 │ 
  
  ℹ The class is declared here:
  
    1 │ new C();
  > 2 │ class C {}
      │       ^
    3 │ 
  
  ℹ Using a class before it is declared makes the code depend on declaration order and hoisting behavior.
  
  ℹ Move this use after the declaration, or move the declaration earlier.

Valid

1
f();
2
function f() {}

1
// An export can reference a variable before its declaration.
2
export { CONSTANT };
3
const CONSTANT = 0;

1
function f() { return CONSTANT; }
2
const CONSTANT = 0;

1
function f() {
2
    new C();
3
}
4
let c: C;
5
class C {}