Pular para o conteúdo
Biome
Docs Blog Playground

noInferrableTypes

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

Diagnostic Category: lint/style/noInferrableTypes

Since: v1.0.0

Sources:

Disallow type annotations for variables, parameters, and class properties initialized with a literal expression.

TypeScript is able to infer the types of parameters, properties, and variables from their default or initial values. There is no need to use an explicit : type annotation for trivially inferred types (boolean, bigint, number, regex, string). Doing so adds unnecessary verbosity to code making it harder to read.

In contrast to ESLint’s rule, this rule allows to use a wide type for const declarations. Moreover, the rule does not recognize undefined values, primitive type constructors (String, Number, …), and RegExp type. These global variables could be shadowed by local ones.

Examples

Section titled Examples

Invalid

Section titled Invalid
const variable: 1 = 1;
code-block.ts:1:15 lint/style/noInferrableTypes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ This type annotation is trivially inferred from its initialization.
  
  > 1 │ const variable: 1 = 1;
      │               ^^^
    2 │ 
  
  ℹ Safe fix: Remove the type annotation.
  
    1   │ - const·variable:·1·=·1;
      1 │ + const·variable·=·1;
    2 2 │   
  
let variable: number = 1;
code-block.ts:1:13 lint/style/noInferrableTypes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ This type annotation is trivially inferred from its initialization.
  
  > 1 │ let variable: number = 1;
      │             ^^^^^^^^
    2 │ 
  
  ℹ Safe fix: Remove the type annotation.
  
    1   │ - let·variable:·number·=·1;
      1 │ + let·variable·=·1;
    2 2 │   
  
class SomeClass {
  readonly field: 1 = 1;
}
code-block.ts:2:17 lint/style/noInferrableTypes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ This type annotation is trivially inferred from its initialization.
  
    1 │ class SomeClass {
  > 2 │   readonly field: 1 = 1;
      │                 ^^^
    3 │ }
    4 │ 
  
  ℹ Safe fix: Remove the type annotation.
  
    1 1 │   class SomeClass {
    2   │ - ··readonly·field:·1·=·1;
      2 │ + ··readonly·field·=·1;
    3 3 │   }
    4 4 │   
  
class SomeClass {
  field: number = 1;
}
code-block.ts:2:8 lint/style/noInferrableTypes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ This type annotation is trivially inferred from its initialization.
  
    1 │ class SomeClass {
  > 2 │   field: number = 1;
      │        ^^^^^^^^
    3 │ }
    4 │ 
  
  ℹ Safe fix: Remove the type annotation.
  
    1 1 │   class SomeClass {
    2   │ - ··field:·number·=·1;
      2 │ + ··field·=·1;
    3 3 │   }
    4 4 │   
  
function f(param: number = 1): void {}
code-block.ts:1:17 lint/style/noInferrableTypes  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ This type annotation is trivially inferred from its initialization.
  
  > 1 │ function f(param: number = 1): void {}
      │                 ^^^^^^^^
    2 │ 
  
  ℹ Safe fix: Remove the type annotation.
  
    1   │ - function·f(param:·number·=·1):·void·{}
      1 │ + function·f(param·=·1):·void·{}
    2 2 │

Valid

Section titled Valid
const variable: number = 1;
let variable: 1 | 2 = 1;
class SomeClass {
  readonly field: number = 1;
}
// `undefined` could be shadowed
const variable: undefined = undefined;
// `RegExp` could be shadowed
const variable: RegExp = /a/;
// `String` could be shadowed
let variable: string = String(5);
class SomeClass {
  field: 1 | 2 = 1;
}
function f(param: 1 | 2 = 1): void {}
Section titled Related links