Skip to main content

naming-convention

Enforce naming conventions for everything across a codebase.

💭

该规则需要 类型信息 才能运行。


强制命名约定有助于保持代码库的一致性，并减少考虑如何命名变量时的开销。 此外，精心设计的样式指南可以帮助传达意图，例如强制所有私有属性以 _ 开头，并且所有全局级常量都以 UPPER_CASE 编写。

英：Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable. Additionally, a well-designed style guide can help communicate intent, such as by enforcing all private properties begin with an _, and all global-level constants are written in UPPER_CASE.

.eslintrc.cjs
module.exports = {
  "rules": {
    "@typescript-eslint/naming-convention": "error"
  }
};
在线运行试试这个规则 ↗

示例​

此规则允许你对任何标识符强制执行约定，使用细粒度选择器来创建细粒度的样式指南。

英：This rule allows you to enforce conventions for any identifier, using granular selectors to create a fine-grained style guide.

注意

该规则仅在特定情况下需要类型信息，详细信息如下。

英：This rule only needs type information in specific cases, detailed below.

选项​

该规则接受对象数组，每个对象描述不同的命名约定。 下面将详细描述每个属性。 另请参阅下面的示例部分以获取图示示例。

英：This rule accepts an array of objects, with each object describing a different naming convention. Each property will be described in detail below. Also see the examples section below for illustrated examples.

type Options = {
  // format options
  format:
    | (
        | 'camelCase'
        | 'strictCamelCase'
        | 'PascalCase'
        | 'StrictPascalCase'
        | 'snake_case'
        | 'UPPER_CASE'
      )[]
    | null;
  custom?: {
    regex: string;
    match: boolean;
  };
  leadingUnderscore?:
    | 'forbid'
    | 'require'
    | 'requireDouble'
    | 'allow'
    | 'allowDouble'
    | 'allowSingleOrDouble';
  trailingUnderscore?:
    | 'forbid'
    | 'require'
    | 'requireDouble'
    | 'allow'
    | 'allowDouble'
    | 'allowSingleOrDouble';
  prefix?: string[];
  suffix?: string[];

  // selector options
  selector: Selector | Selector[];
  filter?:
    | string
    | {
        regex: string;
        match: boolean;
      };
  // the allowed values for these are dependent on the selector - see below
  modifiers?: Modifiers<Selector>[];
  types?: Types<Selector>[];
}[];

// the default config is similar to ESLint's camelcase rule but more strict
const defaultOptions: Options = [
  {
    selector: 'default',
    format: ['camelCase'],
    leadingUnderscore: 'allow',
    trailingUnderscore: 'allow',
  },

  {
    selector: 'import',
    format: ['camelCase', 'PascalCase'],
  },

  {
    selector: 'variable',
    format: ['camelCase', 'UPPER_CASE'],
    leadingUnderscore: 'allow',
    trailingUnderscore: 'allow',
  },

  {
    selector: 'typeLike',
    format: ['PascalCase'],
  },
];

格式选项​

每个选择器都可以具有相同的格式选项集。 有关如何应用每个选择器的信息，请参阅 "该规则如何评估名称的格式？"。

英：Every single selector can have the same set of format options. For information about how each selector is applied, see "How does the rule evaluate a name's format?".

format​

format 选项定义了标识符允许的格式。 此选项接受以下值的数组，并且标识符可以与其中任何一个匹配：

英：The format option defines the allowed formats for the identifier. This option accepts an array of the following values, and the identifier can match any of them:

  • camelCase - 标准驼峰格式 - 字符之间不允许有下划线，并且允许连续大写（即 myID 和 myId 都有效）。
  • PascalCase - 与 camelCase 相同，但第一个字符必须是大写。
  • snake_case - 标准 snake_case 格式 - 所有字符必须为小写，并且允许使用下划线。
  • strictCamelCase - 与 camelCase 相同，但不允许连续大写（即 myId 有效，但 myID 无效）。
  • StrictPascalCase - 与 strictCamelCase 相同，但第一个字符必须是大写。
  • UPPER_CASE - 与 snake_case 相同，但所有字符必须为大写。

除了数组之外，你还可以传递 null。 这表示 "该选择器不应检查其格式"。 如果你想在应用组选择器后对特定选择器不强制执行特定格式，这会很有用。

英：Instead of an array, you may also pass null. This signifies "this selector shall not have its format checked". This can be useful if you want to enforce no particular format for a specific selector, after applying a group selector.

custom​

custom 选项定义标识符必须（或不能）匹配的自定义正则表达式。 此选项允许你对标识符进行更细粒度的控制，从而禁止（或强制）某些模式和子字符串。 接受具有以下属性的对象：

英：The custom option defines a custom regex that the identifier must (or must not) match. This option allows you to have a bit more finer-grained control over identifiers, letting you ban (or force) certain patterns and substrings. Accepts an object with the following properties:

  • match - 如果标识符必须与 regex 匹配，则为 true；如果标识符不能与 regex 匹配，则为 false。
  • regex - 然后将字符串传递给 RegExp 以创建新的正则表达式： new RegExp(regex)

filter​

filter 选项的操作与 custom 类似，接受相同形状的对象，不同之处在于它控制配置的其余部分是否应该应用于标识符。

英：The filter option operates similar to custom, accepting the same shaped object, except that it controls if the rest of the configuration should or should not be applied to an identifier.

你可以使用它来包含或排除特定配置中的特定标识符。

英：You can use this to include or exclude specific identifiers from specific configurations.

接受具有以下属性的对象：

英：Accepts an object with the following properties:

  • match - 如果标识符必须与 regex 匹配，则为 true；如果标识符不能与 regex 匹配，则为 false。
  • regex - 然后将字符串传递给 RegExp 以创建新的正则表达式： new RegExp(regex)

或者，filter 接受正则表达式（new RegExp(filter) 接受的任何内容）。 在这种情况下，它被视为好像你传递了一个带有正则表达式和 match: true 的对象。

英：Alternatively, filter accepts a regular expression (anything accepted into new RegExp(filter)). In this case, it's treated as if you had passed an object with the regex and match: true.

leadingUnderscore / trailingUnderscore​

leadingUnderscore / trailingUnderscore 选项控制前导/尾随下划线是否被视为有效。 接受以下值之一：

英：The leadingUnderscore / trailingUnderscore options control whether leading/trailing underscores are considered valid. Accepts one of the following values:

  • allow - 未明确强制存在单个前导/尾随下划线。
  • allowDouble - 没有明确强制存在双前导/尾随下划线。
  • allowSingleOrDouble - 未明确强制存在单或双前导/尾随下划线。
  • forbid - 根本不允许使用前导/尾随下划线。
  • require - 必须包含单个前导/尾随下划线。
  • requireDouble - 必须包含两个前导/尾随下划线。

prefix / suffix​

prefix / suffix 选项控制标识符必须存在哪些前缀/后缀字符串。 接受字符串数组。

英：The prefix / suffix options control which prefix/suffix strings must exist for the identifier. Accepts an array of strings.

如果提供了这些，则标识符必须以提供的值之一开头。 例如，如果你提供 { prefix: ['Class', 'IFace', 'Type'] }，则以下名称有效： ClassBar、IFaceFoo、TypeBaz，但名称 Bang 无效，因为它不包含任何前缀。

英：If these are provided, the identifier must start with one of the provided values. For example, if you provide { prefix: ['Class', 'IFace', 'Type'] }, then the following names are valid: ClassBar, IFaceFoo, TypeBaz, but the name Bang is not valid, as it contains none of the prefixes.

注意： 对于 上面记录了，在验证格式之前会修剪前缀，因此必须使用 PascalCase 来允许诸如 isEnabled 之类的变量使用前缀 is。

英：Note: As documented above, the prefix is trimmed before format is validated, therefore PascalCase must be used to allow variables such as isEnabled using the prefix is.

选择器选项​

  • selector 允许你指定要定位的标识符类型。
    • 接受一个或一组选择器来定义适用于一个或多个选择器的选项块。
    • 例如，如果你提供 { selector: ['function', 'variable'] }，那么它将对变量和函数节点应用相同的选项。
    • 有关允许的选择器的完整列表，请参阅下面的 允许的选择器、修饰符和类型。
  • modifiers 允许你指定要细化应用的修饰符，例如可访问性 (#private/private/protected/public)，或者事物是否为 static 等。
    • 该名称必须与所有修饰符匹配。
    • 例如，如果你提供 { modifiers: ['private','readonly','static'] }，那么它只会匹配 private static readonly，而 private 则不会匹配。
    • 允许以下 modifiers：
      • abstract,override,private,protected,readonly,static - 匹配使用给定修饰符显式声明的任何成员。
      • async - 匹配通过 async 关键字异步的任何方法、函数或函数变量（例如，不匹配不使用 async 关键字而返回 Promise 的函数）
      • const - 匹配声明为 const (const x = 1) 的变量。
      • destructured - 匹配通过对象解构模式 (const {x, z = 2}) 声明的变量。
        • 请注意，这与重命名的解构属性 (const {x: y, a: b = 2}) 不匹配。
      • exported - 匹配从模块导出的任何内容。
      • global - 匹配顶层作用域中声明的变量/函数。
      • #private - 匹配具有私有标识符（以 # 开头的标识符）的任何成员
      • public - 匹配任何显式声明为 public 或没有可见性修饰符（即隐式公共）的成员。
      • requiresQuotes - 匹配任何需要引号的名称，因为它不是有效的标识符（即其中包含空格、破折号等）。
      • unused - 匹配任何未使用的内容。
  • types 允许你指定要匹配的类型。 此选项仅支持简单的原始类型（array、boolean、function、number、string）。
    • 该名称必须与其中一种类型匹配。
    • 注意 - 使用此选项将要求你检查类型信息。
    • 例如，这可以让你执行诸如强制 boolean 变量以动词作为前缀之类的操作。
    • 允许以下 types：
      • array 匹配可分配给 Array<unknown> | null | undefined 的任何类型
      • boolean 匹配可分配给 boolean | null | undefined 的任何类型
      • function 匹配可分配给 Function | null | undefined 的任何类型
      • number 匹配可分配给 number | null | undefined 的任何类型
      • string 匹配可分配给 string | null | undefined 的任何类型

选择器的顺序并不重要。 该实现将自动对选择器进行排序，以确保它们从最具体到最不具体的匹配。 它将继续按该顺序检查选择器，直到找到与名称匹配的选择器。 见 "规则如何自动对选择器进行排序？"

英：The ordering of selectors does not matter. The implementation will automatically sort the selectors to ensure they match from most-specific to least specific. It will keep checking selectors in that order until it finds one that matches the name. See "How does the rule automatically order selectors?"

允许的选择器、修饰符和类型​

选择器有两种类型：单独选择器和分组选择器。

英：There are two types of selectors, individual selectors, and grouped selectors.

单独选择器​

各个选择器匹配特定的、定义明确的集合。 每个单独的选择器之间没有重叠。

英：Individual Selectors match specific, well-defined sets. There is no overlap between each of the individual selectors.

  • accessor - 匹配任何访问器。
    • 允许 modifiers： abstract、override、private、protected、public、requiresQuotes、static。
    • 允许 types： array、boolean、function、number、string。
  • class - 匹配任何类声明。
    • 允许 modifiers： abstract、exported、unused。
    • 允许 types： 没有任何。
  • classMethod - 匹配任何类方法。 还匹配具有直接函数表达式或箭头函数表达式值的属性。 与访问器不匹配。
    • 允许 modifiers： abstract、async、override、#private、private、protected、public、requiresQuotes、static。
    • 允许 types： 没有任何。
  • classProperty - 匹配任何类属性。 不匹配具有直接函数表达式或箭头函数表达式值的属性。
    • 允许 modifiers： abstract、override、#private、private、protected、public、readonly、requiresQuotes、static。
    • 允许 types： array、boolean、function、number、string。
  • enum - 匹配任何枚举声明。
    • 允许 modifiers： exported、unused。
    • 允许 types： 没有任何。
  • enumMember - 匹配任何枚举成员。
    • 允许 modifiers： requiresQuotes。
    • 允许 types： 没有任何。
  • function - 匹配任何命名函数声明或命名函数表达式。
    • 允许 modifiers： async、exported、global、unused。
    • 允许 types： 没有任何。
  • import - 匹配命名空间导入和默认导入（即不匹配命名导入）。
    • 允许 modifiers： default、namespace。
    • 允许 types： 没有任何。
  • interface - 匹配任何接口声明。
    • 允许 modifiers： exported、unused。
    • 允许 types： 没有任何。
  • objectLiteralMethod - 匹配任何对象字面量方法。 还匹配具有直接函数表达式或箭头函数表达式值的属性。 与访问器不匹配。
    • 允许 modifiers： async、public、requiresQuotes。
    • 允许 types： 没有任何。
  • objectLiteralProperty - 匹配任何对象字面量属性。 不匹配具有直接函数表达式或箭头函数表达式值的属性。
    • 允许 modifiers： public、requiresQuotes。
    • 允许 types： array、boolean、function、number、string。
  • parameter - 匹配任何函数参数。 与参数属性不匹配。
    • 允许 modifiers： destructured、unused。
    • 允许 types： array、boolean、function、number、string。
  • parameterProperty - 匹配任何参数属性。
    • 允许 modifiers： private、protected、public、readonly。
    • 允许 types： array、boolean、function、number、string。
  • typeAlias - 匹配任何类型别名声明。
    • 允许 modifiers： exported、unused。
    • 允许 types： 没有任何。
  • typeMethod - 匹配任何对象类型的方法。 还匹配具有直接函数表达式或箭头函数表达式值的属性。 与访问器不匹配。
    • 允许 modifiers： public、requiresQuotes。
    • 允许 types： 没有任何。
  • typeParameter - 匹配任何泛型类型参数声明。
    • 允许 modifiers： unused。
    • 允许 types： 没有任何。
  • typeProperty - 匹配任何对象类型属性。 不匹配具有直接函数表达式或箭头函数表达式值的属性。
    • 允许 modifiers： public、readonly、requiresQuotes。
    • 允许 types： array、boolean、function、number、string。
  • variable - 匹配任何 const / let / var 变量名称。
    • 允许 modifiers： async、const、destructured、exported、global、unused。
    • 允许 types： array、boolean、function、number、string。
组选择器​

组选择器是为了方便起见而提供的，本质上是将各个选择器的集合打包在一起。

英：Group Selectors are provided for convenience, and essentially bundle up sets of individual selectors.

  • default - 匹配一切。
    • 允许 modifiers： 所有修饰符。
    • 允许 types： 没有任何。
  • memberLike - 与 accessor、enumMember、method、parameterProperty、property 相同的匹配。
    • 允许 modifiers： abstract、async、override、#private、private、protected、public、readonly、requiresQuotes、static。
    • 允许 types： 没有任何。
  • method - 与 classMethod、objectLiteralMethod、typeMethod 相同的匹配。
    • 允许 modifiers： abstract、async、override、#private、private、protected、public、readonly、requiresQuotes、static。
    • 允许 types： 没有任何。
  • property - 与 classProperty、objectLiteralProperty、typeProperty 相同的匹配。
    • 允许 modifiers： abstract、async、override、#private、private、protected、public、readonly、requiresQuotes、static。
    • 允许 types： array、boolean、function、number、string。
  • typeLike - 与 class、enum、interface、typeAlias、typeParameter 相同的匹配。
    • 允许 modifiers： abstract、unused。
    • 允许 types： 没有任何。
  • variableLike - 与 function、parameter 和 variable 匹配相同。
    • 允许 modifiers： async、unused。
    • 允许 types： 没有任何。

常见问题​

这是一个很大的规则，并且有很多文档。 以下是人们经常询问或通过反复试验找出的一些澄清。

英：This is a big rule, and there's a lot of docs. Here are a few clarifications that people often ask about or figure out via trial-and-error.

规则如何评估选择器？​

每个选择器都按以下方式检查：

英：Each selector is checked in the following way:

  1. 检查 filter
    1. 如果省略 filter → 跳过此步骤。
    2. 如果名称与 filter 匹配 → 继续评估该选择器。
    3. 如果名称与 filter 不匹配 → 跳过此选择器并继续下一个选择器。
  2. 检查 selector
    1. 如果 selector 是一个单独的选择器 → 名称的类型必须是该类型。
    2. 如果 selector 是组选择器 → 名称的类型必须是分组类型之一。
    3. 如果 selector 是选择器数组 → 将上述内容应用于数组中的每个选择器。
  3. 检查 types
    1. 如果省略 types → 跳过此步骤。
    2. 如果名称的类型为 types → 继续评估此选择器。
    3. 如果名称在 types 中没有类型 → 跳过此选择器并继续下一个选择器。

如果名称符合以下条件，则被视为传递配置：

英：A name is considered to pass the config if it:

  1. 匹配一个选择器并通过该选择器的所有格式检查。
  2. 不匹配任何选择器。

如果名称与一个选择器匹配并且未通过选择器格式检查，则该名称将被视为配置失败。

英：A name is considered to fail the config if it matches one selector and fails one that selector's format checks.

规则如何自动对选择器进行排序？​

每个标识符应该与一个选择器完全匹配。 它可能匹配多个组选择器 - 但只能匹配一个选择器。 考虑到这一点 - 基本排序顺序是：

英：Each identifier should match exactly one selector. It may match multiple group selectors - but only ever one selector. With that in mind - the base sort order works out to be:

  1. 单独选择器
  2. 分组选择器
  3. 默认选择器

在每个类别中，根据提供的选择器选项进行一些进一步的排序：

英：Within each of these categories, some further sorting occurs based on what selector options are supplied:

  1. filter 被赋予最高优先级。
  2. types
  3. modifiers
  4. 其他一切

例如，如果你提供以下配置：

英：For example, if you provide the following config:

[
  /* 1 */ { selector: 'default', format: ['camelCase'] },
  /* 2 */ { selector: 'variable', format: ['snake_case'] },
  /* 3 */ { selector: 'variable', types: ['boolean'], format: ['UPPER_CASE'] },
  /* 4 */ { selector: 'variableLike', format: ['PascalCase'] },
];

然后对于代码 const x = 1，规则将按以下顺序验证选择器： 3、2、4、1。 为了清楚地阐明它：

英：Then for the code const x = 1, the rule will validate the selectors in the following order: 3, 2, 4, 1. To clearly spell it out:

  • (3) 首先被测试，因为它有 types 并且是一个单独的选择器。
  • 接下来测试 (2)，因为它是一个单独的选择器。
  • 接下来测试 (4)，因为它是分组选择器。
  • (1) 最后测试，因为它是基本默认选择器。

值得注意的是，虽然应用了此顺序，但所有选择器可能不会在名称上运行。 这在 "该规则如何评估名称的格式？" 中有解释

英：Its worth noting that whilst this order is applied, all selectors may not run on a name. This is explained in "How does the rule evaluate a name's format?"

该规则如何评估名称的格式？​

检查标识符的格式时，按以下顺序检查：

英：When the format of an identifier is checked, it is checked in the following order:

  1. 验证前导下划线
  2. 验证尾随下划线
  3. 验证前缀
  4. 验证后缀
  5. 验证自定义
  6. 验证格式

对于步骤 1-4，如果标识符与选项匹配，则匹配部分将被删除。 这样做是为了让你可以应用 PascalCase 等格式，而不必担心前缀或下划线导致其不匹配。

英：For steps 1-4, if the identifier matches the option, the matching part will be removed. This is done so that you can apply formats like PascalCase without worrying about prefixes or underscores causing it to not match.

最后要注意的是，如果名称通过此修剪过程变为空，则认为它与所有 format 匹配。 这可能有用的一个示例是对于泛型类型参数，你希望所有名称都以 T 为前缀，但也希望允许使用单字符 T 名称。

英：One final note is that if the name were to become empty via this trimming process, it is considered to match all formats. An example of where this might be useful is for generic type parameters, where you want all names to be prefixed with T, but also want to allow for the single character T name.

这里有一些例子来帮助说明

英：Here are some examples to help illustrate

名称： _IMyInterface 选择器：

英：Name: _IMyInterface Selector:

{
  "leadingUnderscore": "require",
  "prefix": ["I"],
  "format": ["UPPER_CASE", "StrictPascalCase"]
}
  1. name = _IMyInterface
  2. 验证前导下划线
    1. 提供了配置
    2. 检查名称 → 通过
    3. 修剪下划线 → name = IMyInterface
  3. 验证尾随下划线
    1. 未提供配置 → 跳过
  4. 验证前缀
    1. 提供了配置
    2. 检查名称 → 通过
    3. 修剪前缀 → name = MyInterface
  5. 验证后缀
    1. 未提供配置 → 跳过
  6. 验证自定义
    1. 未提供配置 → 跳过
  7. 验证格式
    1. 对于每种格式...
      1. format = 'UPPER_CASE'
        1. 检查格式→失败。
          • 需要注意的是，如果你提供多种格式 - 名称只需匹配其中一种即可！
      2. format = 'StrictPascalCase'
        1. 检查格式→成功。
  8. success

名称： IMyInterface 选择器：

英：Name: IMyInterface Selector:

{
  "format": ["StrictPascalCase"],
  "trailingUnderscore": "allow",
  "custom": {
    "regex": "^I[A-Z]",
    "match": false
  }
}
  1. name = IMyInterface
  2. 验证前导下划线
    1. 未提供配置 → 跳过
  3. 验证尾随下划线
    1. 提供了配置
    2. 检查名称 → 通过
    3. 修剪下划线 → name = IMyInterface
  4. 验证前缀
    1. 未提供配置 → 跳过
  5. 验证后缀
    1. 未提供配置 → 跳过
  6. 验证自定义
    1. 提供了配置
    2. regex = new RegExp("^I[A-Z]")
    3. regex.test(name) === custom.match
    4. fail → 报告并退出

如果我向组选择器提供 modifiers 会发生什么？​

一些组选择器接受 modifiers。 在大多数情况下，它们的工作方式与单个选择器完全相同。 有一个例外，即修饰符可能不适用于组选择器涵盖的所有单独选择器。

英：Some group selectors accept modifiers. For the most part these will work exactly the same as with individual selectors. There is one exception to this in that a modifier might not apply to all individual selectors covered by a group selector.

例如 - memberLike 包含 enumMember 选择器，并且允许 protected 修饰符。 enumMember 永远不可能是 protected，这意味着以下配置永远不会匹配任何 enumMember：

英：For example - memberLike includes the enumMember selector, and it allows the protected modifier. An enumMember can never ever be protected, which means that the following config will never match any enumMember:

{
  "selector": "memberLike",
  "modifiers": ["protected"]
}

为了帮助匹配，无法指定可访问性的成员将始终具有 public 修饰符。 这意味着以下配置将始终匹配任何 enumMember：

英：To help with matching, members that cannot specify an accessibility will always have the public modifier. This means that the following config will always match any enumMember:

{
  "selector": "memberLike",
  "modifiers": ["public"]
}

示例​

强制所有变量、函数和属性遵循驼峰命名法​

{
  "@typescript-eslint/naming-convention": [
    "error",
    { "selector": "variableLike", "format": ["camelCase"] }
  ]
}

强制私有成员以下划线为前缀​

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "memberLike",
      "modifiers": ["private"],
      "format": ["camelCase"],
      "leadingUnderscore": "require"
    }
  ]
}

强制布尔变量以允许的动词为前缀​

注意： 对于 上面记录了，在验证格式之前会修剪前缀，因此必须使用 PascalCase 来允许诸如 isEnabled 之类的变量。

英：Note: As documented above, the prefix is trimmed before format is validated, thus PascalCase must be used to allow variables such as isEnabled.

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "variable",
      "types": ["boolean"],
      "format": ["PascalCase"],
      "prefix": ["is", "should", "has", "can", "did", "will"]
    }
  ]
}

强制所有变量都采用驼峰式命名或大写命名​

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "variable",
      "format": ["camelCase", "UPPER_CASE"]
    }
  ]
}

强制所有 const 变量均采用 UPPER_CASE​

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "variable",
      "modifiers": ["const"],
      "format": ["UPPER_CASE"]
    }
  ]
}

强制类型参数（泛型）以 T 为前缀​

这允许你模拟旧的 generic-type-naming 规则。

英：This allows you to emulate the old generic-type-naming rule.

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "typeParameter",
      "format": ["PascalCase"],
      "prefix": ["T"]
    }
  ]
}

强制接口名称不以 I 开头​

这允许你模拟旧的 interface-name-prefix 规则。

英：This allows you to emulate the old interface-name-prefix rule.

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "interface",
      "format": ["PascalCase"],
      "custom": {
        "regex": "^I[A-Z]",
        "match": false
      }
    }
  ]
}

强制变量和函数名称采用驼峰命名法​

这允许你使用相同的模式对多种类型进行 lint 处理。

英：This allows you to lint multiple type with same pattern.

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": ["variable", "function"],
      "format": ["camelCase"],
      "leadingUnderscore": "allow"
    }
  ]
}

忽略 require 引用的属性​

有时你必须使用违反约定的带引号的名称（例如，HTTP 标头）。 如果这在你的代码库中很常见，那么你有几个选择。

英：Sometimes you have to use a quoted name that breaks the convention (for example, HTTP headers). If this is a common thing in your codebase, then you have a few options.

如果你只想允许所有需要引号的属性名称，则可以使用 requiresQuotes 修饰符来匹配任何需要引号的属性名称，并使用 format: null 忽略该名称。

英：If you simply want to allow all property names that require quotes, you can use the requiresQuotes modifier to match any property name that requires quoting, and use format: null to ignore the name.

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": [
        "classProperty",
        "objectLiteralProperty",
        "typeProperty",
        "classMethod",
        "objectLiteralMethod",
        "typeMethod",
        "accessor",
        "enumMember"
      ],
      "format": null,
      "modifiers": ["requiresQuotes"]
    }
  ]
}

如果你有一小部分已知的例外列表，则可以使用 filter 选项仅忽略这些特定名称：

英：If you have a small and known list of exceptions, you can use the filter option to ignore these specific names only:

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "property",
      "format": ["strictCamelCase"],
      "filter": {
        // you can expand this regex to add more allowed names
        "regex": "^(Property-Name-One|Property-Name-Two)$",
        "match": false
      }
    }
  ]
}

你可以使用 filter 选项来忽略具有特定字符的名称：

英：You can use the filter option to ignore names with specific characters:

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "property",
      "format": ["strictCamelCase"],
      "filter": {
        // you can expand this regex as you find more cases that require quoting that you want to allow
        "regex": "[- ]",
        "match": false
      }
    }
  ]
}

请注意，无法忽略任何被引用的名称 - 只能忽略需要引用的名称。 这是有意为之的 - 在名称周围添加引号并不是正确命名的应急方案。 如果你想要特定名称的应急方案 - 你应该使用 eslint-disable 注释。

英：Note that there is no way to ignore any name that is quoted - only names that are required to be quoted. This is intentional - adding quotes around a name is not an escape hatch for proper naming. If you want an escape hatch for a specific name - you should can use an eslint-disable comment.

忽略解构名称​

有时你可能希望允许解构属性保留其原始名称，即使它打破了你的命名约定。

英：Sometimes you might want to allow destructured properties to retain their original name, even if it breaks your naming convention.

你可以使用 destructured 修饰符来匹配这些名称，并显式设置 format: null 以不应用格式：

英：You can use the destructured modifier to match these names, and explicitly set format: null to apply no formatting:

{
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "variable",
      "modifiers": ["destructured"],
      "format": null
    }
  ]
}

强制代码库遵循 ESLint 的 camelcase 约定​

{
  "camelcase": "off",
  "@typescript-eslint/naming-convention": [
    "error",
    {
      "selector": "default",
      "format": ["camelCase"]
    },

    {
      "selector": "variable",
      "format": ["camelCase", "UPPER_CASE"]
    },
    {
      "selector": "parameter",
      "format": ["camelCase"],
      "leadingUnderscore": "allow"
    },

    {
      "selector": "memberLike",
      "modifiers": ["private"],
      "format": ["camelCase"],
      "leadingUnderscore": "require"
    },

    {
      "selector": "typeLike",
      "format": ["PascalCase"]
    }
  ]
}

何时不使用它​

这条规则可能非常严格。 如果你对强制执行命名约定没有强烈的需求，我们建议你仅使用它来标记严重违反命名标准的行为。 如果你有类似的流程，请考虑记录你的命名约定并在代码审查中强制执行它们。

英：This rule can be very strict. If you don't have strong needs for enforcing naming conventions, we recommend using it only to flag very egregious violations of your naming standards. Consider documenting your naming conventions and enforcing them in code review if you have processes like that.

如果你不想强制执行任何内容的命名约定，则可以禁用此规则。

英：If you do not want to enforce naming conventions for anything, you can disable this rule.

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

英：However, keep in mind that inconsistent style can harm readability in a project. We recommend that if you care about naming conventions, pick a single option for this rule that works best for your project.

选项​

资源​