Skip to main content

explicit-member-accessibility

要求类属性和方法上有显式可访问性修饰符.

🔧

此规则报告的一些问题可通过 --fix ESLint 命令行选项自动修复。

💡

此规则报告的一些问题可以通过编辑器 建议 手动修复。

TypeScript 允许在类成员前面放置显式 public、protected 和 private 可访问性修饰符。修饰符仅存在于类型系统中，仅用于描述允许谁访问这些成员。

¥TypeScript allows placing explicit public, protected, and private accessibility modifiers in front of class members. The modifiers exist solely in the type system and just serve to describe who is allowed to access those members.

去掉可访问性修饰符可以减少读取和写入的代码。成员默认为 public。

¥Leaving off accessibility modifiers makes for less code to read and write. Members are public by default.

但是，在具有许多类的代码库中添加显式可访问性修饰符有助于强制执行成员的适当隐私。一些开发者还发现，为了代码的可读性，保持成员公开的明确性更好。

¥However, adding in explicit accessibility modifiers can be helpful in codebases with many classes for enforcing proper privacy of members. Some developers also find it preferable for code readability to keep member publicity explicit.

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

在线运行试试这个规则 ↗

示例​

¥Examples

此规则旨在使代码更具可读性，并且更明确地说明谁可以使用哪些属性。

¥This rule aims to make code more readable and explicit about who can use which properties.

选项​

该规则接受以下选项:

type AccessibilityLevel =
  /** 始终需要访问器。 */
  | 'explicit'
  /** 永远不要检查是否有访问器。 */
  | 'off'
  /** 除公共外，要求访问器。 */
  | 'no-public';

type Options = [
  {
    /** 需要存在或不存在哪些可访问性修饰符。 */
    accessibility?: AccessibilityLevel;
    /** 可以忽略的特定方法名称。 */
    ignoredMethodNames?: string[];
    /** 更改特定类型的类成员所需的可访问性修饰符。 */
    overrides?: {
      accessors?: AccessibilityLevel;
      constructors?: AccessibilityLevel;
      methods?: AccessibilityLevel;
      parameterProperties?: AccessibilityLevel;
      properties?: AccessibilityLevel;
    };
  },
];

const defaultOptions: Options = [{ accessibility: 'explicit' }];

¥Options

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

¥Configuring in a mixed JS/TS codebase

如果你正在处理一个代码库，在其中对非 TypeScript 代码进行 lint（即 .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-member-accessibility": "off",
  },
  "overrides": [
    {
      // enable the rule specifically for TypeScript files
      "files": ["*.ts", "*.mts", "*.cts", "*.tsx"],
      "rules": {
        "@typescript-eslint/explicit-member-accessibility": "error",
      },
    },
  ],
}

accessibility​

需要存在或不存在哪些可访问性修饰符。 Default: "explicit".

该规则在默认状态下不需要配置，并且将强制每个类成员都具有可访问性修饰符。如果你想允许一些隐式公共成员，那么你有以下选择：

¥This rule in its default state requires no configuration and will enforce that every class member has an accessibility modifier. If you would like to allow for some implicit public members then you have the following options:

{
  "accessibility": "explicit",
  "overrides": {
    "accessors": "explicit",
    "constructors": "no-public",
    "methods": "explicit",
    "properties": "off",
    "parameterProperties": "explicit",
  },
}

请注意，以上是你可以使用的可能配置的示例 - 它不是默认配置。

¥Note the above is an example of a possible configuration you could use - it is not the default configuration.

如果未提供选项，以下模式将被视为不正确的代码：

¥The following patterns are considered incorrect code if no options are provided:

class Animal {
  constructor(name) {
    // No accessibility modifier
    this.animalName = name;
  }
  animalName: string; // No accessibility modifier
  get name(): string {
    // No accessibility modifier
    return this.animalName;
  }
  set name(value: string) {
    // No accessibility modifier
    this.animalName = value;
  }
  walk() {
    // method
  }
}
Open in Playground

在默认选项 { accessibility: 'explicit' } 的情况下，以下模式被视为正确：

¥The following patterns are considered correct with the default options { accessibility: 'explicit' }:

class Animal {
  public constructor(
    public breed,
    name,
  ) {
    // Parameter property and constructor
    this.animalName = name;
  }
  private animalName: string; // Property
  get name(): string {
    // get accessor
    return this.animalName;
  }
  set name(value: string) {
    // set accessor
    this.animalName = value;
  }
  public walk() {
    // method
  }
}
Open in Playground

在可访问性设置为 no-public [{ accessibility: 'no-public' }] 的情况下，以下模式被视为不正确：

¥The following patterns are considered incorrect with the accessibility set to no-public [{ accessibility: 'no-public' }]:

class Animal {
  public constructor(
    public breed,
    name,
  ) {
    // Parameter property and constructor
    this.animalName = name;
  }
  public animalName: string; // Property
  public get name(): string {
    // get accessor
    return this.animalName;
  }
  public set name(value: string) {
    // set accessor
    this.animalName = value;
  }
  public walk() {
    // method
  }
}
Open in Playground

在可访问性设置为 no-public [{ accessibility: 'no-public' }] 的情况下，以下模式被视为正确：

¥The following patterns are considered correct with the accessibility set to no-public [{ accessibility: 'no-public' }]:

class Animal {
  constructor(
    protected breed,
    name,
  ) {
    // Parameter property and constructor
    this.name = name;
  }
  private animalName: string; // Property
  get name(): string {
    // get accessor
    return this.animalName;
  }
  private set name(value: string) {
    // set accessor
    this.animalName = value;
  }
  protected walk() {
    // method
  }
}
Open in Playground

overrides​

更改特定类型的类成员所需的可访问性修饰符。

可以通过三种方式使用覆盖。

¥There are three ways in which an override can be used.

  • 禁止对给定成员使用 public。

    ¥To disallow the use of public on a given member.

  • 当根允许隐式公共访问时强制执行显式成员访问

    ¥To enforce explicit member accessibility when the root has allowed implicit public accessibility

  • 禁用对给定成员类型的任何检查

    ¥To disable any checks on given member type

禁止对指定成员使用 public​

¥Disallow the use of public on a given member

例如 [ { overrides: { constructors: 'no-public' } } ]

¥e.g. [ { overrides: { constructors: 'no-public' } } ]

对于示例覆盖，以下模式被认为是不正确的

¥The following patterns are considered incorrect with the example override

class Animal {
  public constructor(protected animalName) {}
  public get name() {
    return this.animalName;
  }
}
Open in Playground

对于示例覆盖，以下模式被认为是正确的

¥The following patterns are considered correct with the example override

class Animal {
  constructor(protected animalName) {}
  public get name() {
    return this.animalName;
  }
}
Open in Playground

要求给定成员具有显式可访问性​

¥Require explicit accessibility for a given member

例如 [ { accessibility: 'no-public', overrides: { properties: 'explicit' } } ]

¥e.g. [ { accessibility: 'no-public', overrides: { properties: 'explicit' } } ]

对于示例覆盖，以下模式被认为是不正确的

¥The following patterns are considered incorrect with the example override

class Animal {
  constructor(protected animalName) {}
  get name() {
    return this.animalName;
  }
  protected set name(value: string) {
    this.animalName = value;
  }
  legs: number;
  private hasFleas: boolean;
}
Open in Playground

对于示例覆盖，以下模式被认为是正确的

¥The following patterns are considered correct with the example override

class Animal {
  constructor(protected animalName) {}
  get name() {
    return this.animalName;
  }
  protected set name(value: string) {
    this.animalName = value;
  }
  public legs: number;
  private hasFleas: boolean;
}
Open in Playground

例如 [ { accessibility: 'off', overrides: { parameterProperties: 'explicit' } } ]

¥e.g. [ { accessibility: 'off', overrides: { parameterProperties: 'explicit' } } ]

以下代码被认为是不正确的示例覆盖

¥The following code is considered incorrect with the example override

class Animal {
  constructor(readonly animalName: string) {}
}
Open in Playground

通过示例覆盖，以下代码模式被认为是正确的

¥The following code patterns are considered correct with the example override

class Animal {
  constructor(public readonly animalName: string) {}
}

class Animal {
  constructor(public animalName: string) {}
}

class Animal {
  constructor(animalName: string) {}
}
Open in Playground

例如 [ { accessibility: 'off', overrides: { parameterProperties: 'no-public' } } ]

¥e.g. [ { accessibility: 'off', overrides: { parameterProperties: 'no-public' } } ]

以下代码被认为是不正确的示例覆盖

¥The following code is considered incorrect with the example override

class Animal {
  constructor(public readonly animalName: string) {}
}
Open in Playground

通过示例覆盖，以下代码被认为是正确的

¥The following code is considered correct with the example override

class Animal {
  constructor(public animalName: string) {}
}
Open in Playground

禁用对给定成员类型的任何检查​

¥Disable any checks on given member type

例如 [{ overrides: { accessors : 'off' } } ]

¥e.g. [{ overrides: { accessors : 'off' } } ]

由于不对被重写的成员类型执行任何检查，因此该成员类型允许所有可见性排列

¥As no checks on the overridden member type are performed all permutations of visibility are permitted for that member type

对于给定的配置，以下模式被认为是不正确的

¥The follow pattern is considered incorrect for the given configuration

class Animal {
  constructor(protected animalName) {}
  public get name() {
    return this.animalName;
  }
  get legs() {
    return this.legCount;
  }
}
Open in Playground

对于示例覆盖，以下模式被认为是正确的

¥The following patterns are considered correct with the example override

class Animal {
  public constructor(protected animalName) {}
  public get name() {
    return this.animalName;
  }
  get legs() {
    return this.legCount;
  }
}
Open in Playground

ignoredMethodNames​

可以忽略的特定方法名称。 Default: [].

请注意，此选项不关心上下文，并且会忽略具有这些名称的每种方法，这可能会导致它遗漏某些情况。你应该谨慎使用这个。例如 [ { ignoredMethodNames: ['specificMethod', 'whateverMethod'] } ]

¥Note that this option does not care about context, and will ignore every method with these names, which could lead to it missing some cases. You should use this sparingly. e.g. [ { ignoredMethodNames: ['specificMethod', 'whateverMethod'] } ]

class Animal {
  get specificMethod() {
    console.log('No error because you specified this method on option');
  }
  get whateverMethod() {
    console.log('No error because you specified this method on option');
  }
  public get otherMethod() {
    console.log('This method comply with this rule');
  }
}
Open in Playground

何时不使用它​

¥When Not To Use It

如果你认为默认为 public 是一个很好的默认设置，那么你应该考虑使用 no-public 设置。如果你想混合隐式和显式公共成员，则可以禁用此规则。

¥If you think defaulting to public is a good default, then you should consider using the no-public setting. If you want to mix implicit and explicit public members then you can disable this rule.

但是，请记住，不一致的风格可能会损害项目的可读性。我们建议为此规则选择一个最适合你的项目的选项。

¥However, keep in mind that inconsistent style can harm readability in a project. We recommend picking a single option for this rule that works best for your project.

进一步阅读​

¥Further Reading

资源​