Skip to main content

typedef

Require type annotations in certain places.

TypeScript 无法始终推断代码中所有位置的类型。有些位置需要类型注释才能推断其类型。

¥TypeScript cannot always infer types for all places in code. Some locations require type annotations for their types to be inferred.

此规则可以在位置强制执行类型注释，无论它们是否需要。这通常用于维护有时需要它们的元素类型的一致性。

¥This rule can enforce type annotations in locations regardless of whether they're required. This is typically used to maintain consistency for element types that sometimes require them.

class ContainsText {
  // There must be a type annotation here to infer the type
  delayedText: string;

  // `typedef` requires a type annotation here to maintain consistency
  immediateTextExplicit: string = 'text';

  // This is still a string type because of its initial value
  immediateTextImplicit = 'text';
}

要强制执行调用签名上存在的类型定义，请使用 explicit-function-return-type 或 explicit-module-boundary-types。

¥To enforce type definitions existing on call signatures, use explicit-function-return-type, or explicit-module-boundary-types.

提醒

不必要地要求类型注释可能会导致维护起来很麻烦，并且通常会降低代码的可读性。TypeScript 通常比易于编写的类型注释更擅长推断类型。

¥Requiring type annotations unnecessarily can be cumbersome to maintain and generally reduces code readability. TypeScript is often better at inferring types than easily written type annotations would allow.

通常建议使用 --noImplicitAny 和 --strictPropertyInitialization 编译器选项来强制执行类型注释，而不是启用 typedef。

¥Instead of enabling typedef, it is generally recommended to use the --noImplicitAny and --strictPropertyInitialization compiler options to enforce type annotations only when useful.

eslint.config.mjs
export default tseslint.config({
  rules: {
    "@typescript-eslint/typedef": "error"
  }
});

在线运行试试这个规则 ↗

选项​

该规则接受以下选项:

type Options = [
  {
    /** Whether to enforce type annotations on variables declared using array destructuring. */
    arrayDestructuring?: boolean;
    /** Whether to enforce type annotations for parameters of arrow functions. */
    arrowParameter?: boolean;
    /** Whether to enforce type annotations on member variables of classes. */
    memberVariableDeclaration?: boolean;
    /** Whether to enforce type annotations on variables declared using object destructuring. */
    objectDestructuring?: boolean;
    /** Whether to enforce type annotations for parameters of functions and methods. */
    parameter?: boolean;
    /** Whether to enforce type annotations for properties of interfaces and types. */
    propertyDeclaration?: boolean;
    /** Whether to enforce type annotations for variable declarations, excluding array and object destructuring. */
    variableDeclaration?: boolean;
    /** Whether to ignore variable declarations for non-arrow and arrow functions. */
    variableDeclarationIgnoreFunction?: boolean;
  },
];

const defaultOptions: Options = [
  {
    arrayDestructuring: false,
    arrowParameter: false,
    memberVariableDeclaration: false,
    objectDestructuring: false,
    parameter: false,
    propertyDeclaration: false,
    variableDeclaration: false,
    variableDeclarationIgnoreFunction: false,
  },
];

¥Options

例如，使用以下配置：

¥For example, with the following configuration:

{
  "rules": {
    "@typescript-eslint/typedef": [
      "error",
      {
        "arrowParameter": true,
        "variableDeclaration": true
      }
    ]
  }
}

  • 箭头函数参数需要类型注释

    ¥Type annotations on arrow function parameters are required

  • 需要对变量进行类型注释

    ¥Type annotations on variables are required

arrayDestructuring​

Whether to enforce type annotations on variables declared using array destructuring. Default: false.

带有 { "arrayDestructuring": true } 的代码示例：

¥Examples of code with { "arrayDestructuring": true }:

const [a] = [1];
const [b, c] = [1, 2];
Open in Playground

arrowParameter​

Whether to enforce type annotations for parameters of arrow functions. Default: false.

带有 { "arrowParameter": true } 的代码示例：

¥Examples of code with { "arrowParameter": true }:

const logsSize = size => console.log(size);

['hello', 'world'].map(text => text.length);

const mapper = {
  map: text => text + '...',
};
Open in Playground

memberVariableDeclaration​

Whether to enforce type annotations on member variables of classes. Default: false.

带有 { "memberVariableDeclaration": true } 的代码示例：

¥Examples of code with { "memberVariableDeclaration": true }:

class ContainsText {
  delayedText;
  immediateTextImplicit = 'text';
}
Open in Playground

objectDestructuring​

Whether to enforce type annotations on variables declared using object destructuring. Default: false.

带有 { "objectDestructuring": true } 的代码示例：

¥Examples of code with { "objectDestructuring": true }:

const { length } = 'text';
const [b, c] = Math.random() ? [1, 2] : [3, 4];
Open in Playground

parameter​

Whether to enforce type annotations for parameters of functions and methods. Default: false.

带有 { "parameter": true } 的代码示例：

¥Examples of code with { "parameter": true }:

function logsSize(size): void {
  console.log(size);
}

const doublesSize = function (size): number {
  return size * 2;
};

const divider = {
  curriesSize(size): number {
    return size;
  },
  dividesSize: function (size): number {
    return size / 2;
  },
};

class Logger {
  log(text): boolean {
    console.log('>', text);
    return true;
  }
}
Open in Playground

propertyDeclaration​

Whether to enforce type annotations for properties of interfaces and types. Default: false.

带有 { "propertyDeclaration": true } 的代码示例：

¥Examples of code with { "propertyDeclaration": true }:

type Members = {
  member;
  otherMember;
};
Open in Playground

variableDeclaration​

Whether to enforce type annotations for variable declarations, excluding array and object destructuring. Default: false.

带有 { "variableDeclaration": true } 的代码示例：

¥Examples of code with { "variableDeclaration": true }:

const text = 'text';
let initialText = 'text';
let delayedText;
Open in Playground

variableDeclarationIgnoreFunction​

Whether to ignore variable declarations for non-arrow and arrow functions. Default: false.

带有 { "variableDeclaration": true, "variableDeclarationIgnoreFunction": true } 的代码示例：

¥Examples of code with { "variableDeclaration": true, "variableDeclarationIgnoreFunction": true }:

const text = 'text';
Open in Playground

何时不使用它​

¥When Not To Use It

如果你使用的是更严格的 TypeScript 编译器选项，特别是 --noImplicitAny 和/或 --strictPropertyInitialization，你可能不需要此规则。

¥If you are using stricter TypeScript compiler options, particularly --noImplicitAny and/or --strictPropertyInitialization, you likely don't need this rule.

一般来说，如果你不认为编写不必要的类型注释的成本合理，那么就不要使用此规则。

¥In general, if you do not consider the cost of writing unnecessary type annotations reasonable, then do not use this rule.

进一步阅读​

¥Further Reading

'## 资源'