useNamingConvention

TypeScript and TSX

摘要

¥Summary

规则生效日期：v1.0.0

¥Rule available since: v1.0.0
诊断类别：lint/style/useNamingConvention

¥Diagnostic Category: lint/style/useNamingConvention
此规则包含 safe 修复程序。

¥This rule has a safe fix.
此规则的默认严重级别为 information。

¥The default severity of this rule is information.
来源：

¥Sources:
- 灵感来自 @typescript-eslint/naming-convention
  
  ¥Inspired from @typescript-eslint/naming-convention

如何配置

¥How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": "error"
6
      }
7
    }
8
  }
9
}

描述

¥Description

强制 JavaScript 和 TypeScript 文件名的命名约定。

¥Enforce naming conventions for everything across a codebase.

强制命名约定有助于保持代码库的一致性，并在考虑变量的名称 case 时减少开销。

¥Enforcing naming conventions helps to keep the codebase consistent, and reduces overhead when thinking about the name case of a variable.

以下部分描述了规则强制执行的默认约定。你还可以使用规则选项强制执行自定义约定。

¥The following section describes the default conventions enforced by the rule. You can also enforce custom conventions with the rule options.

命名约定

¥Naming conventions

所有名称都可以使用下划线 _ 和美元符号 $ 作为前缀和后缀。名称以 _ 为前缀的未使用变量将被完全忽略。这避免了与 noUnusedVariables 规则的冲突。

¥All names can be prefixed and suffixed with underscores _ and dollar signs $. Unused variables with a name prefixed with _ are completely ignored. This avoids conflicts with the noUnusedVariables rule.

变量和参数名称

¥Variable and parameter names

所有变量和函数参数都在 camelCase 或 PascalCase 中。CLI 现在能够自动搜索和解析 camelCase ()。

¥All variables and function parameters are in camelCase or PascalCase. Catch parameters are in camelCase.

此外，声明为 const 或 var 的全局变量可能在 CONSTANT_CASE 中。全局变量在模块或脚本级别声明。在 TypeScript namespace 中声明的变量也被视为全局变量。

¥Additionally, global variables declared as const or var may be in CONSTANT_CASE. Global variables are declared at module or script level. Variables declared in a TypeScript namespace are also considered global.

1
function f(param, _unusedParam) {
2
    let localValue = 0;
3
    try {
4
        /* ... */
5
    } catch (customError) {
6
        /* ... */
7
    }
8
}
9

10
export const A_CONSTANT = 5;
11

12
let aVariable = 0;
13

14
export namespace ns {
15
    export const ANOTHER_CONSTANT = "";
16
}

不正确名称的示例：

¥Examples of incorrect names:

1
let a_value = 0;

code-block.js:1:5 lint/style/useNamingConvention  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This let name should be in camelCase or PascalCase.
  
  > 1 │ let a_value = 0;
      │     ^^^^^^^
    2 │ 
  
  ℹ Safe fix: Rename this symbol in camelCase.
  
    1   │ - let·a_value·=·0;
      1 │ + let·aValue·=·0;
    2 2 │

1
const fooYPosition = 0;

code-block.js:1:7 lint/style/useNamingConvention ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Two consecutive uppercase characters are not allowed in camelCase because strictCase is set to `true`.
  
  > 1 │ const fooYPosition = 0;
      │       ^^^^^^^^^^^^
    2 │ 
  
  ℹ If you want to use consecutive uppercase characters in camelCase, then set the strictCase option to `false`.
    See the rule options for more details.

1
function f(FIRST_PARAM) {}

code-block.js:1:12 lint/style/useNamingConvention  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This function parameter name should be in camelCase or PascalCase.
  
  > 1 │ function f(FIRST_PARAM) {}
      │            ^^^^^^^^^^^
    2 │ 
  
  ℹ Safe fix: Rename this symbol in PascalCase.
  
    1   │ - function·f(FIRST_PARAM)·{}
      1 │ + function·f(FirstParam)·{}
    2 2 │

函数名称

¥Function names

function 名称在 camelCase 或 PascalCase 中。

¥A function name is in camelCase or PascalCase.
全局 function 也可以在 UPPERCASE 中。这允许支持需要某些功能才能使用有效 HTTP 方法名称的框架。

¥A global function can also be in UPPERCASE. This allows supporting the frameworks that require some function to use valid HTTP method names.

1
function trimString(s) { /*...*/ }
2

3
function Component() {
4
    return <div></div>;
5
}
6

7
export function GET() { /*...*/ }

TypeScript `enum` 名称

¥TypeScript enum names

TypeScript enum 名称在 PascalCase 中。

¥A TypeScript enum name is in PascalCase.

enum 成员默认在 PascalCase 中。但是，你可以配置 enum 成员的 case。有关更多详细信息，请参阅 options。

¥enum members are by default in PascalCase. However, you can configure the case of enum members. See options for more details.

1
enum Status {
2
    Open,
3
    Close,
4
}

类

¥Classes

类名在 PascalCase 中。

¥A class name is in PascalCase.
静态属性和静态 getter 名称为 camelCase 或 CONSTANT_CASE。

¥Static property and static getter names are in camelCase or CONSTANT_CASE.
选择多行 JSX 元素的结尾 camelCase 是否应位于最后一个属性行

¥Class property and method names are in camelCase.

1
class Person {
2
    static MAX_FRIEND_COUNT = 256;
3

4
    static get SPECIAL_PERSON_INSTANCE() { /*...*/ }
5

6
    initializedProperty = 0;
7

8
    specialMethod() {}
9
}

TypeScript `type` 别名和 `interface`

¥TypeScript type aliases and interface

type 别名或接口名称在 PascalCase 中。

¥A type alias or an interface name are in PascalCase.
类型的成员名称在 camelCase 中。

¥Member names of a type are in camelCase.
readonly 属性和 getter 名称也可以在 CONSTANT_CASE 中。

¥readonly property and getter names can also be in CONSTANT_CASE.

1
type Named = {
2
    readonly fullName: string;
3

4
    specialMethod(): void;
5
};
6

7
interface Named {
8
    readonly fullName: string;
9

10
    specialMethod(): void;
11
}
12

13
interface PersonConstructor {
14
    readonly MAX_FRIEND_COUNT: number;
15

16
    get SPECIAL_PERSON_INSTANCE(): Person;
17

18
    new(): Person;
19
}

错误类型别名的示例：

¥Examples of an incorrect type alias:

1
type person = { fullName: string };

code-block.ts:1:6 lint/style/useNamingConvention  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This type alias name should be in PascalCase.
  
  > 1 │ type person = { fullName: string };
      │      ^^^^^^
    2 │ 
  
  ℹ Safe fix: Rename this symbol in PascalCase.
  
    1   │ - type·person·=·{·fullName:·string·};
      1 │ + type·Person·=·{·fullName:·string·};
    2 2 │

文字对象成员名称

¥Literal object member names

文字对象成员在 camelCase 中。

¥Literal object members are in camelCase.

1
const alice = {
2
    fullName: "Alice",
3
}

错误名称的示例：

¥Example of an incorrect name:

1
const alice = {
2
    full_name: "Alice",
3
}

code-block.js:2:5 lint/style/useNamingConvention ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This object property name should be in camelCase.
  
    1 │ const alice = {
  > 2 │     full_name: “Alice”,
      │     ^^^^^^^^^
    3 │ }
    4 │

导入和导出别名和命名空间

¥Import and export aliases and namespaces

导入和导出命名空间在 camelCase 或 PascalCase 中。

¥Import and export namespaces are in camelCase or PascalCase.

1
import * as myLib from "my-lib";
2
import * as Framework from "framework";
3

4
export * as myLib from "my-lib";
5
export * as Framework from "framework";

import 和 export 别名在 camelCase、PascalCase 或 CONSTANT_CASE 中：

¥import and export aliases are in camelCase, PascalCase, or CONSTANT_CASE:

1
import assert, {
2
    deepStrictEqual as deepEqual,
3
    AssertionError as AssertError
4
} from "node:assert";

错误名称的示例：

¥Examples of an incorrect name:

1
import * as MY_LIB from "my-lib";

code-block.ts:1:13 lint/style/useNamingConvention  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This import namespace name should be in camelCase or PascalCase.
  
  > 1 │ import * as MY_LIB from “my-lib”;
      │             ^^^^^^
    2 │ 
  
  ℹ Safe fix: Rename this symbol in PascalCase.
  
    1   │ - import·*·as·MY_LIB·from·“my-lib”;
      1 │ + import·*·as·MyLib·from·“my-lib”;
    2 2 │

TypeScript 类型参数名称

¥TypeScript type parameter names

TypeScript 类型参数名称在 PascalCase 中。

¥A TypeScript type parameter name is in PascalCase.

1
function id<Val>(value: Val): Val { /* ... */}

TypeScript `namespace` 名称

¥TypeScript namespace names

TypeScript namespace 名称位于 camelCase 或 PascalCase 中。

¥A TypeScript namespace name is in camelCase or in PascalCase.

1
namespace mathExtra {
2
    /*...*/
3
}
4

5
namespace MathExtra {
6
    /*...*/
7
}

忽略声明

¥Ignored declarations

请注意，某些声明始终被忽略。你不能对它们应用约定。以下情况适用：

¥Note that some declarations are always ignored. You cannot apply a convention to them. This is the case for:

不是标识符的成员名称

¥Member names that are not identifiers

1
class C {
2
  ["not an identifier"]() {}
3
}

命名导入

¥Named imports

1
 import { an_IMPORT } from "mod"

解构对象属性

¥Destructured object properties

1
const { destructed_PROP } = obj;

标记为 override 的类成员：

¥Class members marked with override:

1
class C extends B {
2
  override overridden_METHOD() {}
3
}

外部 TypeScript 模块中的声明

¥Declarations inside an external TypeScript module

1
declare module "myExternalModule" {
2
  export interface my_INTERFACE {}
3
}

全局声明中的声明

¥Declarations inside a global declaration

1
declare global {
2
  interface HTMLElement {}
3
}

选项

¥Options

规则提供了几个选项，详见以下小节。

¥The rule provides several options that are detailed in the following subsections.

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "strictCase": false,
8
            "requireAscii": false,
9
            "conventions": [
10
              {
11
                "selector": {
12
                  "kind": "classMember",
13
                  "modifiers": [
14
                    "private"
15
                  ]
16
                },
17
                "match": "_(.+)",
18
                "formats": [
19
                  "camelCase"
20
                ]
21
              }
22
            ]
23
          }
24
        }
25
      }
26
    }
27
  }
28
}

strictCase

当此选项设置为 true 时，它禁止在 camelCase 和 PascalCase 中使用连续的大写字符。

¥When this option is set to true, it forbids consecutive uppercase characters in camelCase and PascalCase.

默认：true

¥Default: true

例如，strictCase: true 不允许使用 HTTPServer 或 aHTTPServer。这些名称应重命名为 HttpServer 和 aHttpServer：

¥For instance, HTTPServer or aHTTPServer are not permitted for strictCase: true. These names should be renamed to HttpServer and aHttpServer:

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "strictCase": true
8
          }
9
        }
10
      }
11
    }
12
  }
13
}

1
class HTTPServer {
2
}

code-block.js:1:7 lint/style/useNamingConvention  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Two consecutive uppercase characters are not allowed in PascalCase because strictCase is set to `true`.
  
  > 1 │ class HTTPServer {
      │       ^^^^^^^^^^
    2 │ }
    3 │ 
  
  ℹ If you want to use consecutive uppercase characters in PascalCase, then set the strictCase option to `false`.
    See the rule options for more details.
  
  ℹ Safe fix: Rename this symbol in PascalCase.
  
    1   │ - class·HTTPServer·{
      1 │ + class·HttpServer·{
    2 2 │   }
    3 3 │

当 strictCase 设置为 false 时，允许使用连续的大写字母。例如，HTTPServer 和 aHTTPServer 都被认为是有效的：

¥When strictCase is set to false, consecutive uppercase characters are allowed. For example, HTTPServer and aHTTPServer would be considered valid then:

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "strictCase": false
8
          }
9
        }
10
      }
11
    }
12
  }
13
}

1
class HTTPServer {
2
}

requireAscii

使用 true 时，名称必须仅包含 ASCII 字符，禁止使用包含非 ASCII 字符的名称，例如 café 或 안녕하세요。

¥When true, names must only consist of ASCII characters only, forbidding names like café or 안녕하세요 that include non-ASCII characters.

当 requireAscii 设置为 false 时，名称可以包含非 ASCII 字符。例如，café 和 안녕하세요 将被视为有效。

¥When requireAscii is set to false, names may include non-ASCII characters. For example, café and 안녕하세요 would be considered valid then.

默认：true

¥Default: true

conventions

conventions 选项允许应用自定义约定。该选项采用一组约定。每个约定都是一个对象，它包含一个可选的 selector 和一个或多个要求（match 和 formats）。

¥The conventions option allows applying custom conventions. The option takes an array of conventions. Every convention is an object that includes an optional selector and one or more requirements (match and formats).

例如，你可以强制使用 CONSTANT_CASE 进行全局 const 声明：

¥For example, you can enforce the use of CONSTANT_CASE for global const declarations:

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "const",
11
                  "scope": "global"
12
                },
13
                "formats": [
14
                  "CONSTANT_CASE"
15
                ]
16
              }
17
            ]
18
          }
19
        }
20
      }
21
    }
22
  }
23
}

选择器描述约定适用于哪些声明。你可以根据几个标准选择一个声明：

¥A selector describes which declarations the convention applies to. You can select a declaration based on several criteria:

kind：声明的类型如下：

¥kind: the kind of the declaration among:
- any（如果未设置类型，则为默认类型）
  
  ¥any (default kind if the kind is unset)
- typeLike：类、枚举、类型别名和接口
  
  ¥typeLike: classes, enums, type aliases, and interfaces
- class
- enum
- enumMember
- interface
- typeAlias
- function：命名函数声明和表达式
  
  ¥function: named function declarations and expressions
- namespaceLike：TypeScript 命名空间、导入和导出命名空间 (import * as namespace from)
  
  ¥namespaceLike: TypeScript namespaces, import and export namespaces (import * as namespace from)
- namespace：TypeScript 命名空间
  
  ¥namespace: TypeScript namespaces
- importNamespace
- exportNamespace
- importAlias：默认导入和命名导入的别名
  
  ¥importAlias: default imports and aliases of named imports
- exportAlias：重新导出名称的别名
  
  ¥exportAlias: aliases of re-exported names
- variable：const、let、using 和 var 声明
  
  ¥variable: const, let, using, and var declarations
- const
- let
- var
- using
- functionParameter
- catchParameter
- indexParameter：索引签名的参数
  
  ¥indexParameter: parameters of index signatures
- typeParameter：通用类型参数
  
  ¥typeParameter: generic type parameter
- classMember：类属性、参数属性、方法、getter 和 setter
  
  ¥classMember: class properties, parameter properties, methods, getters, and setters
- classProperty：类属性，包括参数属性
  
  ¥classProperty: class properties, including parameter properties
- classMethod
- classGetter
- classSetter
- objectLiteralMember：文字对象属性、方法、getter 和 setter
  
  ¥objectLiteralMember: literal object properties, methods, getters, and setters
- objectLiteralProperty
- objectLiteralMethod
- objectLiteralGetter
- objectLiteralSetter
- typeMember：在类型别名和接口中声明的属性、方法、getter 和 setter
  
  ¥typeMember: properties, methods, getters, and setters declared in type aliases and interfaces
- typeProperty
- typeMethod
- typeGetter
- typeSetter
modifiers：修饰符数组，其中包括：

¥modifiers: an array of modifiers among:
- abstract：适用于类成员和类
  
  ¥abstract: applies to class members and classes
- private：适用于类成员
  
  ¥private: applies to class members
- protected：适用于类成员
  
  ¥protected: applies to class members
- readonly：适用于类成员和类型成员
  
  ¥readonly: applies to class members and type members
- static：适用于类成员
  
  ¥static: applies to class members
scope：声明出现的位置。允许的值：

¥scope: where the declaration appears. Allowed values:
- any：任何地方（如果未设置范围，则为默认值）
  
  ¥any: anywhere (default value if the scope is unset)
- global：全局范围（还包括命名空间范围）
  
  ¥global: the global scope (also includes the namespace scopes)

对于每个声明，系统会按顺序遍历 conventions 数组，直到找到选择器选中该声明为止。约定的要求在声明中得到验证。

¥For each declaration, the conventions array is traversed in-order until a selector selects the declaration. The requirements of the convention are so verified on the declaration.

约定必须至少设置以下一项要求：

¥A convention must set at least one requirement among:

match：声明名称必须匹配的正则表达式。

¥match: a regular expression that the name of the declaration must match.
formats：名称必须遵循的字符串 case。支持的情况是：PascalCase、CONSTANT_CASE、camelCase 和 snake_case。

¥formats: the string case that the name must follow. The supported cases are: PascalCase, CONSTANT_CASE, camelCase, and snake_case.

如果仅设置了 formats，则将与声明名称进行比对。在以下配置中，我们要求 static readonly 类属性必须位于 CONSTANT_CASE 中。

¥If only formats is set, it’s checked against the name of the declaration. In the following configuration, we require static readonly class properties to be in CONSTANT_CASE.

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "classProperty",
11
                  "modifiers": [
12
                    "static",
13
                    "readonly"
14
                  ]
15
                },
16
                "formats": [
17
                  "CONSTANT_CASE"
18
                ]
19
              }
20
            ]
21
          }
22
        }
23
      }
24
    }
25
  }
26
}

以下代码随后会被规则报告：

¥The following code is then reported by the rule:

1
class C {
2
    static readonly prop = 0;
3
}

code-block.ts:2:21 lint/style/useNamingConvention ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ This readonly static class property name should be in CONSTANT_CASE.
  
    1 │ class C {
  > 2 │     static readonly prop = 0;
      │                     ^^^^
    3 │ }
    4 │

一个约定可能会使另一个约定失效。在以下配置中，第二个约定无效，因为第一个约定始终适用于类成员，包括类属性。你应该始终将更具体的约定放在首位。

¥A convention can make another one useless. In the following configuration, the second convention is useless because the first one always applies to class members, including class properties. You should always place first more specific conventions.

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "classMember"
11
                },
12
                "formats": [
13
                  "camelCase"
14
                ]
15
              },
16
              {
17
                "selector": {
18
                  "kind": "classProperty"
19
                },
20
                "formats": [
21
                  "camelCase",
22
                  "CONSTANT_CASE"
23
                ]
24
              }
25
            ]
26
          }
27
        }
28
      }
29
    }
30
  }
31
}

如果仅设置了 match 且正则表达式没有捕获组，则 match 将直接与声明名称进行比对。在以下配置中，所有变量名必须至少包含 3 个字符，最多包含 20 个字符。

¥If only match is set and the regular expression has no capturing groups, then match is checked against the name of the declaration directly. In the following configuration, all variable names must have a minimum of 3 characters and a maximum of 20 characters.

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "variable"
11
                },
12
                "match": ".{3,20}"
13
              }
14
            ]
15
          }
16
        }
17
      }
18
    }
19
  }
20
}

如果同时设置了 match 和 formats，则根据正则表达式的第一次捕获检查 formats。仅测试第一次捕获。其他捕获被忽略。如果未捕获任何内容，则忽略 formats。

¥If both match and formats are set, then formats is checked against the first capture of the regular expression. Only the first capture is tested. Other captures are ignored. If nothing is captured, then formats is ignored.

在以下示例中，我们要求：

¥In the following example, we require that:

私有属性以 _ 开头，且至少包含两个字符。

¥A private property starts with _ and consists of at least two characters.
捕获的名称（不带前导 _ 的名称）在 camelCase 中。

¥The captured name (the name without the leading _) is in camelCase.

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "classMember",
11
                  "modifiers": [
12
                    "private"
13
                  ]
14
                },
15
                "match": "_(.+)",
16
                "formats": [
17
                  "camelCase"
18
                ]
19
              }
20
            ]
21
          }
22
        }
23
      }
24
    }
25
  }
26
}

如果设置了 match 而未设置 formats，则正则表达式捕获的名称部分将传递给选择该声明的数组的下一个约定。以下配置与上一个配置的效果完全相同。第一条约定适用于任何私有类成员名称。它规定名称必须以一个下划线开头。正则表达式捕获名称中不带前导下划线的部分。由于 formats 未设置，捕获将转发到适用于私有类成员名称的下一个约定。在我们的例子中，适用以下约定。捕获的内容会与 formats 进行比较。

¥If match is set and formats is unset, then the part of the name captured by the regular expression is forwarded to the next conventions of the array that selects the declaration. The following configuration has exactly the same effect as the previous one. The first convention applies to any private class member name. It stipulates that the name must have a leading underscore. The regular expression captures the part of the name without the leading underscore. Because formats is not set, the capture is forwarded to the next convention that applies to a private class member name. In our case, the next convention applies. The capture is then checked against formats.

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "classMember",
11
                  "modifiers": [
12
                    "private"
13
                  ]
14
                },
15
                "match": "_(.+)"
16
                // We don't need to specify `formats` because the capture is forwarded to the next conventions.
17
              },
18
              {
19
                "selector": {
20
                  "kind": "classMember",
21
                  "modifiers": [
22
                    "private"
23
                  ]
24
                },
25
                "formats": [
26
                  "camelCase"
27
                ]
28
              }
29
            ]
30
          }
31
        }
32
      }
33
    }
34
  }
35
}

转发机制对于分解某些约定尤为有用。例如，以下配置……

¥The forwarding has particularly useful to factorize some conventions. For example, the following configuration…

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "classMember",
11
                  "modifiers": [
12
                    "private"
13
                  ]
14
                },
15
                "match": "_(.+)",
16
                "formats": [
17
                  "camelCase"
18
                ]
19
              },
20
              {
21
                "selector": {
22
                  "kind": "classMember"
23
                },
24
                "formats": [
25
                  "camelCase"
26
                ]
27
              }
28
            ]
29
          }
30
        }
31
      }
32
    }
33
  }
34
}

可以分解为……

¥can be factorized to…

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "classMember",
11
                  "modifiers": [
12
                    "private"
13
                  ]
14
                },
15
                "match": "_(.+)"
16
              },
17
              {
18
                "selector": {
19
                  "kind": "classMember"
20
                },
21
                "formats": [
22
                  "camelCase"
23
                ]
24
              }
25
            ]
26
          }
27
        }
28
      }
29
    }
30
  }
31
}

如果未选择声明，或者在没有更多约定的情况下转发捕获，则将根据默认约定验证声明名称。因为默认约定已经确保类成员在 [“camelCase”] 中，所以前面的示例可以简化为：

¥If a declaration is not selected or if a capture is forwarded while there are no more conventions, then the declaration name is verified against the default conventions. Because the default conventions already ensure that class members are in [“camelCase”], the previous example can be simplified to:

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "classMember",
11
                  "modifiers": [
12
                    "private"
13
                  ]
14
                },
15
                "match": "_(.+)"
16
                // We don't need to specify `formats` because the capture is forwarded to the next conventions.
17
              }
18
              // default conventions
19
            ]
20
          }
21
        }
22
      }
23
    }
24
  }
25
}

如果捕获与初始名称相同（它不是初始名称的一部分），则在根据默认约定进行检查之前，会修剪前导和尾随下划线和美元符号。在前面的示例中，捕获的内容是名称的一部分，因为 _ 不包含在捕获的内容中，因此不会执行任何修剪操作。

¥If the capture is identical to the initial name (it is not a part of the initial name), then, leading and trailing underscore and dollar signs are trimmed before being checked against default conventions. In the previous example, the capture is a part of the name because _ is not included in the capture, thus, no trimming is performed.

你可以通过在数组末尾添加一个接受任何内容的约定来重置所有默认约定：

¥You can reset all default conventions by adding a convention at the end of the array that accepts anything:

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              // your conventions
9
              // ...
10

11
              // Otherwise, accept anything
12
              {
13
                "match": ".*"
14
              }
15
            ]
16
          }
17
        }
18
      }
19
    }
20
  }
21
}

让我们举一个更复杂的例子，遵循以下约定：

¥Let’s take a more complex example with the following conventions:

变量名可以是 i、j，或者遵循下一个选定的约定（约定 (2)）。

¥A variable name is i, j, or follows the next selected convention (convention (2)).
标识符至少包含两个字符，并遵循下一个选定的约定（默认约定）。

¥An identifier contains at least two characters and follow the next selected convention (the default convention).
private 类成员名称以下划线 _ 开头，去掉下划线后的名称遵循下一个选定的约定（某些成员遵循约定 (4)，其他成员遵循默认约定）。

¥A private class member name starts with an underscore _ and the name without the underscore follows the next selected convention (convention (4) for some of them, and the default convention for others).
static readonly 类属性名称位于 CONSTANT_CASE 中。

¥A static readonly class property name is in CONSTANT_CASE.
全局常量位于 CONSTANT_CASE 中，可以用双下划线括起来，也可以命名为 _SPECIAL_。

¥A global constant is in CONSTANT_CASE and can be enclosed by double underscores or to be named _SPECIAL_.
接口名称以 I 开头，以 Error 结尾的接口除外，并且符合 PascalCase 规则。

¥An interface name starts with I, except for interfaces ending with Error, and is in PascalCase.
所有其他名称遵循默认约定

¥All other names follow the default conventions

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useNamingConvention": {
6
          "options": {
7
            "conventions": [
8
              {
9
                "selector": {
10
                  "kind": "variable"
11
                },
12
                "match": "[ij]|(.*)"
13
              },
14
              {
15
                "match": "(.{2,})"
16
              },
17
              {
18
                "selector": {
19
                  "kind": "classMember",
20
                  "modifiers": [
21
                    "private"
22
                  ]
23
                },
24
                "match": "_(.*)"
25
              },
26
              {
27
                "selector": {
28
                  "kind": "classProperty",
29
                  "modifiers": [
30
                    "static",
31
                    "readonly"
32
                  ]
33
                },
34
                "formats": [
35
                  "CONSTANT_CASE"
36
                ]
37
              },
38
              {
39
                "selector": {
40
                  "kind": "const",
41
                  "scope": "global"
42
                },
43
                "match": "__(.+)__|_SPECIAL_|(.+)",
44
                "formats": [
45
                  "CONSTANT_CASE"
46
                ]
47
              },
48
              {
49
                "selector": {
50
                  "kind": "interface"
51
                },
52
                "match": "I(.*)|(.*?)Error",
53
                "formats": [
54
                  "PascalCase"
55
                ]
56
              }
57
              // default conventions
58
            ]
59
          }
60
        }
61
      }
62
    }
63
  }
64
}

以下是一些示例：

¥Hers some examples:

规则报告了名为 _ 的私有类属性，因为它包含单个字符。根据第二种约定，名称应至少包含两个字符。

¥A private class property named _ is reported by the rule because it contains a single character. According to the second convention, the name should contain at least two characters.
规则会报告变量 a_variable，因为它不符合禁止使用 snake_case 类型变量名的默认约定。首先根据第一种约定验证变量名。它会被转发到第二个约定，该约定也同样有效，因为它既不是 i 也不是 j。文件名会被捕获并传递给下一个约定。在我们的例子中，以下约定是默认约定。

¥A variable a_variable is reported by the rule because it doesn’t respect the default convention that forbid variable names in snake_case. The variable name is first verified against the first convention. It is forwarded to the second convention, which is also respected, because it is neither i nor j. The name is captured and is forwarded to the next convention. In our case, the next convention is the default one.

正则表达式语法

¥Regular expression syntax

match 选项采用支持以下语法的正则表达式：

¥The match option takes a regular expression that supports the following syntaxes:

贪婪量词 *、?、+、{n}、{n,m}、{n,}、{m}

¥Greedy quantifiers *, ?, +, {n}, {n,m}, {n,}, {m}
非贪婪量词 *?、??、+?、{n}?、{n,m}?、{n,}?、{m}?

¥Non-greedy quantifiers *?, ??, +?, {n}?, {n,m}?, {n,}?, {m}?
任何字符匹配器 .

¥Any character matcher .
更改已建立语法的格式。

¥Character classes [a-z], [xyz], [^a-z]
替代 |

¥Alternations |
捕获组 ()

¥Capturing groups ()
非捕获组 (?:)

¥Non-capturing groups (?:)
不区分大小写的组 (?i:) 和区分大小写的组 (?-i:)

¥Case-insensitive groups (?i:) and case-sensitive groups (?-i:)
包含所有特殊字符和常规字符串转义字符 \f、\n、\r、\t、\v 的有限转义字符集。请注意，你还可以使用字符类转义特殊字符。例如，\$ 和 [$] 是两个有效的模式，它们可以转义 $。

¥A limited set of escaped characters including all special characters and regular string escape characters \f, \n, \r, \t, \v. Note that you can also escape special characters using character classes. For example, \$ and [$] are two valid patterns that escape $.