explicit-function-return-type

Require explicit return types on functions and class methods.

TypeScript 中的函数通常不需要给出显式的返回类型注释。 省略返回类型可以减少读取或写入的代码，并允许编译器从函数的内容推断它。

英：Functions in TypeScript often don't need to be given an explicit return type annotation. Leaving off the return type is less code to read or write and allows the compiler to infer it from the contents of the function.

然而，显式返回类型确实使函数返回的类型在视觉上更加清晰。 它们还可以提高具有许多大型函数的大型代码库中的 TypeScript 类型检查性能。

英：However, explicit return types do make it visually more clear what type is returned by a function. They can also speed up TypeScript type checking performance in large codebases with many large functions.

此规则强制函数确实具有显式返回类型注释。

英：This rule enforces that functions do have an explicit return type annotation.

.eslintrc.cjs

module.exports = {
  "rules": {
    "@typescript-eslint/explicit-function-return-type": "error"
  }
};

在线运行试试这个规则 ↗

示例

❌ 不正确

// Should indicate that no value is returned (void)
function test() {
  return;
}

// Should indicate that a number is returned
var fn = function () {
  return 1;
};

// Should indicate that a string is returned
var arrowFn = () => 'test';

class Test {
  // Should indicate that no value is returned (void)
  method() {
    return;
  }
}

Open in Playground

✅ 正确

// No return value should be expected (void)
function test(): void {
  return;
}

// A return value of type number
var fn = function (): number {
  return 1;
};

// A return value of type string
var arrowFn = (): string => 'test';

class Test {
  // No return value should be expected (void)
  method(): void {
    return;
  }
}

Open in Playground

选项

在混合 JS/TS 代码库中进行配置

如果你正在开发的代码库中包含 lint 非 TypeScript 代码（即 .js/.mjs/.cjs/.jsx），则应确保应使用 ESLint overrides 仅在 .ts/.mts/.cts/.tsx 文件上启用规则。 如果不这样做，那么你将在 .js/.mjs/.cjs/.jsx 文件中报告无法修复的 lint 错误。

英：If you are working on a codebase within which you lint non-TypeScript code (i.e. .js/.mjs/.cjs/.jsx), you should ensure that you should use ESLint overrides to only enable the rule on .ts/.mts/.cts/.tsx files. If you don't, then you will get unfixable lint errors reported within .js/.mjs/.cjs/.jsx files.

{
  "rules": {
    // disable the rule for all files
    "@typescript-eslint/explicit-function-return-type": "off"
  },
  "overrides": [
    {
      // enable the rule specifically for TypeScript files
      "files": ["*.ts", "*.mts", "*.cts", "*.tsx"],
      "rules": {
        "@typescript-eslint/explicit-function-return-type": "error"
      }
    }
  ]
}

allowExpressions

此规则与 { allowExpressions: true } 的代码示例：

英：Examples of code for this rule with { allowExpressions: true }:

❌ 不正确

function test() {}

const fn = () => {};

export default () => {};

Open in Playground

✅ 正确

node.addEventListener('click', () => {});

node.addEventListener('click', function () {});

const foo = arr.map(i => i * i);

Open in Playground

allowTypedFunctionExpressions

此规则与 { allowTypedFunctionExpressions: true } 的代码示例：

英：Examples of code for this rule with { allowTypedFunctionExpressions: true }:

❌ 不正确

let arrowFn = () => 'test';

let funcExpr = function () {
  return 'test';
};

let objectProp = {
  foo: () => 1,
};

Open in Playground

✅ 正确

type FuncType = () => string;

let arrowFn: FuncType = () => 'test';

let funcExpr: FuncType = function() {
  return 'test';
};

let asTyped = (() => '') as () => string;
let castTyped = <() => string>(() => '');

interface ObjectType {
  foo(): number;
}
let objectProp: ObjectType = {
  foo: () => 1,
};
let objectPropAs = {
  foo: () => 1,
} as ObjectType;
let objectPropCast = <ObjectType>{
  foo: () => 1,
};

declare functionWithArg(arg: () => number);
functionWithArg(() => 1);

declare functionWithObjectArg(arg: { method: () => number });
functionWithObjectArg({
  method() {
    return 1;
  },
});

const Comp: FC = () => {
  return <button onClick={() => {}} />;
};

Open in Playground

allowHigherOrderFunctions

此规则与 { allowHigherOrderFunctions: true } 的代码示例：

英：Examples of code for this rule with { allowHigherOrderFunctions: true }:

❌ 不正确

var arrowFn = () => () => {};

function fn() {
  return function () {};
}

Open in Playground

✅ 正确

var arrowFn = () => (): void => {};

function fn() {
  return function (): void {};
}

Open in Playground

allowDirectConstAssertionInArrowFunctions

此规则与 { allowDirectConstAssertionInArrowFunctions: true } 的代码示例：

英：Examples of code for this rule with { allowDirectConstAssertionInArrowFunctions: true }:

❌ 不正确

const func = (value: number) => ({ type: 'X', value }) as any;
const func = (value: number) => ({ type: 'X', value }) as Action;

Open in Playground

✅ 正确

const func = (value: number) => ({ foo: 'bar', value }) as const;
const func = () => x as const;

Open in Playground

allowConciseArrowFunctionExpressionsStartingWithVoid

此规则与 { allowConciseArrowFunctionExpressionsStartingWithVoid: true } 的代码示例：

英：Examples of code for this rule with { allowConciseArrowFunctionExpressionsStartingWithVoid: true }:

❌ 不正确

var join = (a: string, b: string) => `${a}${b}`;

const log = (message: string) => {
  console.log(message);
};

Open in Playground

✅ 正确

var log = (message: string) => void console.log(message);

Open in Playground

allowFunctionsWithoutTypeParameters

此规则与 { allowFunctionsWithoutTypeParameters: true } 的代码示例：

英：Examples of code for this rule with { allowFunctionsWithoutTypeParameters: true }:

❌ 不正确

function foo<T>(t: T) {
  return t;
}

const bar = <T>(t: T) => t;

Open in Playground

✅ 正确

function foo<T>(t: T): T {
  return t;
}

const bar = <T>(t: T): T => t;

const allowedFunction(x: string) {
  return x;
}

const allowedArrow = (x: string) => x;

Open in Playground

allowedNames

你可以传递你希望此规则忽略的函数/方法名称，如下所示：

英：You may pass function/method names you would like this rule to ignore, like so:

{
  "@typescript-eslint/explicit-function-return-type": [
    "error",
    {
      "allowedNames": ["ignoredFunctionName", "ignoredMethodName"]
    }
  ]
}

allowIIFEs

此规则与 { allowIIFEs: true } 的代码示例：

英：Examples of code for this rule with { allowIIFEs: true }:

❌ 不正确

var func = () => 'foo';

Open in Playground

✅ 正确

var foo = (() => 'foo')();

var bar = (function () {
  return 'bar';
})();

Open in Playground

何时不使用它

如果你认为显式编写函数返回类型所增加的成本不值得视觉清晰度，或者你的项目不够大，不足以成为类型检查性能的一个因素，那么你将不需要此规则。

英：If you don't find the added cost of explicitly writing function return types to be worth the visual clarity, or your project is not large enough for it to be a factor in type checking performance, then you will not need this rule.

进一步阅读

• TypeScript 函数

选项

该规则接受以下选项

type Options = [
  {
    /** Whether to allow arrow functions that start with the `void` keyword. */
    allowConciseArrowFunctionExpressionsStartingWithVoid?: boolean;
    /** Whether to ignore arrow functions immediately returning a `as const` value. */
    allowDirectConstAssertionInArrowFunctions?: boolean;
    /** Whether to ignore function expressions (functions which are not part of a declaration). */
    allowExpressions?: boolean;
    /** Whether to ignore functions that don't have generic type parameters. */
    allowFunctionsWithoutTypeParameters?: boolean;
    /** Whether to ignore functions immediately returning another function expression. */
    allowHigherOrderFunctions?: boolean;
    /** Whether to ignore immediately invoked function expressions (IIFEs). */
    allowIIFEs?: boolean;
    /** Whether to ignore type annotations on the variable of function expressions. */
    allowTypedFunctionExpressions?: boolean;
    /** An array of function/method names that will not have their arguments or return values checked. */
    allowedNames?: string[];
  },
];

const defaultOptions: Options = [
  {
    allowExpressions: false,
    allowTypedFunctionExpressions: true,
    allowHigherOrderFunctions: true,
    allowDirectConstAssertionInArrowFunctions: true,
    allowConciseArrowFunctionExpressionsStartingWithVoid: false,
    allowFunctionsWithoutTypeParameters: false,
    allowedNames: [],
    allowIIFEs: false,
  },
];

资源

• 规则源码
• 测试源码