explicit-member-accessibility

要求在类属性和方法上显式指定访问修饰符。

🔧

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

💡

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

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

省略访问修饰符可以减少代码的阅读和编写量。成员默认情况下为 public。

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

.eslintrc.cjs

module.exports = {
  "rules": {
    "@typescript-eslint/explicit-member-accessibility": "error"
  }
};

在游乐场中尝试此规则 ↗

示例

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

选项

此规则接受以下选项

type AccessibilityLevel =
  /** Always require an accessor. */
  | 'explicit'
  /** Never check whether there is an accessor. */
  | 'off'
  /** Require an accessor except when public. */
  | 'no-public';

type Options = [
  {
    accessibility?: AccessibilityLevel;
    ignoredMethodNames?: string[];
    overrides?: {
      accessors?: AccessibilityLevel;
      constructors?: AccessibilityLevel;
      methods?: AccessibilityLevel;
      parameterProperties?: AccessibilityLevel;
      properties?: AccessibilityLevel;
    };
  },
];

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

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

如果您正在处理一个代码库，其中您对非 TypeScript 代码（例如 .js/.mjs/.cjs/.jsx）进行 lint，您应该确保使用 ESLint overrides 仅在 .ts/.mts/.cts/.tsx 文件上启用该规则。如果您没有这样做，那么您将在 .js/.mjs/.cjs/.jsx 文件中收到无法修复的 lint 错误。

{
  "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

此规则在其默认状态下不需要任何配置，并将强制执行每个类成员都具有访问修饰符。如果您想允许一些隐式公共成员，那么您有以下选项

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

请注意，以上只是一个可能的配置示例，它不是默认配置。

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

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
  }
}

在 Playground 中打开

以下模式在使用默认选项 { 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
  }
}

在 Playground 中打开

以下模式在将 accessibility 设置为 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
  }
}

在 Playground 中打开

以下模式在将 accessibility 设置为 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
  }
}

在 Playground 中打开

overrides

可以使用三种方法来使用覆盖。

• 禁止在给定成员上使用 public。
• 在根目录允许隐式公共访问的情况下，强制执行显式成员访问。
• 禁用对给定成员类型的任何检查。

禁止在给定成员上使用 public

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

以下模式在使用示例覆盖时被视为不正确

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

在 Playground 中打开

以下模式在使用示例覆盖时被视为正确

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

在 Playground 中打开

要求对给定成员进行显式访问

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

以下模式在使用示例覆盖时被视为不正确

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

在 Playground 中打开

以下模式在使用示例覆盖时被视为正确

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

在 Playground 中打开

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

以下代码在使用示例覆盖的情况下被认为是错误的

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

在 Playground 中打开

以下代码模式在使用示例覆盖的情况下被认为是正确的

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

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

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

在 Playground 中打开

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

以下代码在使用示例覆盖的情况下被认为是错误的

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

在 Playground 中打开

以下代码在使用示例覆盖的情况下被认为是正确的

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

在 Playground 中打开

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

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

由于没有对被覆盖的成员类型进行任何检查，因此该成员类型的所有可见性排列都是允许的

以下模式对于给定的配置被认为是错误的

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

在 Playground 中打开

以下模式在使用示例覆盖时被视为正确

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

在 Playground 中打开

ignoredMethodNames

如果您想忽略一些特定的方法，可以通过指定方法名称来实现。请注意，此选项不关心上下文，并将忽略具有这些名称的所有方法，这可能会导致它错过一些情况。您应该谨慎使用此选项。例如：[ { 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');
  }
}

在 Playground 中打开

何时不使用它

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

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

进一步阅读

• TypeScript 可访问性修饰符手册文档

资源

• 规则来源
• 测试来源