跳至主要內容

命名規則

強制程式碼庫中所有內容的命名規則。

💭

此規則需要 類型資訊 才能執行。

強制執行命名規則有助於保持程式碼庫的一致性，並減少思考如何命名變數的負擔。此外，精心設計的風格指南可以幫助傳達意圖，例如強制所有私有屬性以 _ 開頭，並且所有全域層級的常數都以 UPPER_CASE 撰寫。

注意

此規則已功能凍結：它將不再接收新功能，例如新增選項。它仍然會接受針對其現有功能區域的錯誤和文件修復，並支援新的 TypeScript 版本。

強制執行命名和/或排序規則的風格規則往往會隨著越來越難以理解的功能請求而變得異常複雜。此規則已達到 typescript-eslint 專案可以維護的合理極限。請參閱 eslint-plugin：功能凍結命名和排序風格規則 以了解更多資訊。

.eslintrc.cjs
module.exports = {
  "rules": {
    "@typescript-eslint/naming-convention": "error"
  }
};

在 Playground 中試試看此規則 ↗

範例​

此規則允許您使用精細的選擇器為任何識別碼強制執行規則，以建立精細的風格指南。

注意

此規則僅在特定情況下需要類型資訊，詳情如下。

選項​

此規則接受一個物件陣列，每個物件描述不同的命名規則。每個屬性將在下面詳細說明。另請參閱下面的範例章節以獲取圖示範例。

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'],
  },
];

格式選項​

每個選擇器都可以具有相同的格式選項集。有關如何套用每個選擇器的資訊，請參閱 「規則如何評估名稱的格式？」。

format​

format 選項定義識別碼的允許格式。此選項接受以下值的陣列，識別碼可以匹配其中任何一個

  • camelCase - 標準 camelCase 格式 - 字元之間不允許出現底線，並且允許連續大寫（即 myID 和 myId 都有效）。
  • PascalCase - 與 camelCase 相同，但第一個字元必須是大寫。
  • snake_case - 標準 snake_case 格式 - 所有字元都必須是小寫，並且允許出現底線。
  • strictCamelCase - 與 camelCase 相同，但不允許連續大寫（即 myId 有效，但 myID 無效）。
  • StrictPascalCase - 與 strictCamelCase 相同，但第一個字元必須是大寫。
  • UPPER_CASE - 與 snake_case 相同，但所有字元都必須是大寫。

您也可以傳遞 null 而不是陣列。這表示「不應檢查此選擇器的格式」。如果您想在套用群組選擇器後，對特定選擇器不強制執行任何特定格式，這會很有用。

custom​

custom 選項定義識別碼必須（或不得）匹配的自訂正規表達式。此選項允許您對識別碼進行更精細的控制，讓您可以禁止（或強制）某些模式和子字串。接受具有以下屬性的物件

  • match - 如果識別碼必須匹配 regex，則為 true，如果識別碼不得匹配 regex，則為 false。
  • regex - 傳遞給 RegExp 以建立新的正規表達式的字串：new RegExp(regex)

filter​

filter 選項的操作類似於 custom，接受形狀相同的物件，只是它控制是否應將其餘配置套用於識別碼。

您可以使用它來包含或排除特定配置中的特定識別碼。

接受具有以下屬性的物件

  • match - 如果識別碼必須匹配 regex，則為 true，如果識別碼不得匹配 regex，則為 false。
  • regex - 傳遞給 RegExp 以建立新的正規表達式的字串：new RegExp(regex)

或者，filter 接受正規表達式（任何可以接受到 new RegExp(filter) 中的內容）。在這種情況下，它會被視為您已傳遞一個帶有正規表達式和 match: true 的物件。

leadingUnderscore / trailingUnderscore​

leadingUnderscore / trailingUnderscore 選項控制前導/尾隨底線是否被視為有效。接受以下值之一

  • allow - 不明確強制執行單個前導/尾隨底線的存在。
  • allowDouble - 不明確強制執行雙重前導/尾隨底線的存在。
  • allowSingleOrDouble - 不明確強制執行單個或雙重前導/尾隨底線的存在。
  • forbid - 根本不允許前導/尾隨底線。
  • require - 必須包含單個前導/尾隨底線。
  • requireDouble - 必須包含兩個前導/尾隨底線。

prefix / suffix​

prefix / suffix 選項控制識別碼必須存在哪些前綴/後綴字串。接受字串陣列。

如果提供了這些選項，則識別碼必須以提供的其中一個值開頭。例如，如果您提供 { prefix: ['Class', 'IFace', 'Type'] }，則以下名稱有效：ClassBar、IFaceFoo、TypeBaz，但名稱 Bang 無效，因為它不包含任何前綴。

注意：如上文所述，在驗證格式之前會先修剪前綴，因此必須使用 PascalCase 才能允許使用前綴 is 的變數，例如 isEnabled。

選擇器選項​

  • 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 的類型

選擇器的順序無關緊要。實作將自動排序選擇器，以確保它們從最特定到最不特定匹配。它會按照該順序繼續檢查選擇器，直到找到匹配名稱的選擇器為止。請參閱「"規則如何自動排序選擇器？"」

允許的選擇器、修飾符和類型​

選擇器有兩種類型：個別選擇器和分組選擇器。

個別選擇器​

個別選擇器匹配特定、定義明確的集合。每個個別選擇器之間沒有重疊。

  • classicAccessor - 匹配任何存取器。它指的是附加到 get 和 set 語法的函數。
    • 允許的 modifiers：abstract、override、private、protected、public、requiresQuotes、static。
    • 允許的 types：array、boolean、function、number、string。
  • autoAccessor - 匹配任何自動存取器。自動存取器只是以 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。
分組選擇器​

提供分組選擇器是為了方便起見，並且基本上捆綁了多組個別選擇器。

  • default - 匹配所有內容。
    • 允許的 modifiers：所有修飾符。
    • 允許的 types：無。
  • accessor - 匹配與 classicAccessor 和 autoAccessor 相同的內容。
    • 允許的 modifiers：abstract、override、private、protected、public、requiresQuotes、static。
    • 允許的 types：array、boolean、function、number、string。
  • memberLike - 匹配與 classicAccessor、autoAccessor、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：無。

常見問題​

這是一個很大的規則，並且有很多文件。以下是一些人們經常詢問或透過反覆試驗才弄清楚的問題。

規則如何評估選擇器？​

每個選擇器都按以下方式檢查

  1. 檢查 filter
    1. 如果省略 filter → 跳過此步驟。
    2. 如果名稱與 filter 匹配 → 繼續評估此選擇器。
    3. 如果名稱與 filter 不匹配 → 跳過此選擇器並繼續檢查下一個選擇器。
  2. 檢查 selector
    1. 如果 selector 是一個個別選擇器 → 名稱的類型必須是該類型。
    2. 如果 selector 是一個分組選擇器 → 名稱的類型必須是分組類型之一。
    3. 如果 selector 是一個選擇器陣列 → 對陣列中的每個選擇器套用上述步驟。
  3. 檢查 types
    1. 如果省略 types → 跳過此步驟。
    2. 如果名稱在 types 中具有類型 → 繼續評估此選擇器。
    3. 如果名稱在 types 中沒有類型 → 跳過此選擇器並繼續檢查下一個選擇器。

如果名稱符合以下條件，則認為它通過了配置

  1. 匹配一個選擇器並通過該選擇器的所有格式檢查。
  2. 不匹配任何選擇器。

如果名稱匹配一個選擇器但未通過該選擇器的格式檢查，則認為它未通過配置。

規則如何自動排序選擇器？​

每個識別符號應完全匹配一個選擇器。它可能匹配多個分組選擇器 - 但只會匹配一個選擇器。考慮到這一點 - 基本排序順序如下

  1. 個別選擇器
  2. 分組選擇器
  3. 預設選擇器

在每個類別中，會根據提供的選擇器選項進行一些進一步的排序

  1. filter 的優先順序高於其他所有選項。
  2. 類型
  3. 修飾符
  4. 其他所有選項

例如，如果您提供以下配置

[
  /* 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。清楚說明如下

  • （3）首先測試，因為它具有 types 且是一個個別選擇器。
  • （2）接下來測試，因為它是一個個別選擇器。
  • （4）接下來測試，因為它是一個分組選擇器。
  • （1）最後測試，因為它是基本預設選擇器。

值得注意的是，雖然套用了此順序，但並非所有選擇器都可能在名稱上運行。這在「"規則如何評估名稱的格式？"」中進行了解釋

規則如何評估名稱的格式？​

檢查識別符號的格式時，會按以下順序檢查

  1. 驗證前導底線
  2. 驗證尾隨底線
  3. 驗證前綴
  4. 驗證後綴
  5. 驗證自訂格式
  6. 驗證格式

對於步驟 1-4，如果識別符號與選項匹配，則匹配的部分將被移除。這樣做是為了讓您可以在應用 PascalCase 之類的格式時，不必擔心前綴或底線導致它不匹配。

最後一點需要注意的是，如果名稱通過此修剪過程變为空，則認為它與所有 format 匹配。這種情況的一個例子是泛型類型參數，您希望所有名稱都以 T 作為前綴，但也希望允許單個字符 T 作為名稱。

以下是一些有助於說明的範例

名稱：_IMyInterface 選擇器

{
  "leadingUnderscore": "require",
  "prefix": ["I"],
  "format": ["UPPER_CASE", "StrictPascalCase"]
}
  1. name = _IMyInterface
  2. 驗證前導底線
    1. 已提供 config
    2. 檢查名稱 → 通過
    3. 修剪底線 → name = IMyInterface
  3. 驗證尾隨底線
    1. 未提供 config → 跳過
  4. 驗證前綴
    1. 已提供 config
    2. 檢查名稱 → 通過
    3. 修剪前綴 → name = MyInterface
  5. 驗證後綴
    1. 未提供 config → 跳過
  6. 驗證自訂格式
    1. 未提供 config → 跳過
  7. 驗證格式
    1. 對於每個格式...
      1. format = 'UPPER_CASE'
        1. 檢查格式 → 失敗。
          • 需要注意的是，如果您提供多個格式 - 名稱只需要匹配其中一個！
      2. format = 'StrictPascalCase'
        1. 檢查格式 → 成功。
  8. 成功

名稱：IMyInterface 選擇器

{
  "format": ["StrictPascalCase"],
  "trailingUnderscore": "allow",
  "custom": {
    "regex": "^I[A-Z]",
    "match": false
  }
}
  1. name = IMyInterface
  2. 驗證前導底線
    1. 未提供 config → 跳過
  3. 驗證尾隨底線
    1. 已提供 config
    2. 檢查名稱 → 通過
    3. 修剪底線 → name = IMyInterface
  4. 驗證前綴
    1. 未提供 config → 跳過
  5. 驗證後綴
    1. 未提供 config → 跳過
  6. 驗證自訂格式
    1. 已提供 config
    2. regex = new RegExp("^I[A-Z]")
    3. regex.test(name) === custom.match
    4. 失敗 → 報告並退出

如果我為群組選擇器提供 modifiers 會發生什麼？​

一些群組選擇器接受 modifiers。在大多數情況下，這些與個別選擇器的作用完全相同。有一個例外是修飾符可能不適用於群組選擇器涵蓋的所有個別選擇器。

例如 - memberLike 包含 enumMember 選擇器，並且允許 protected 修飾符。enumMember 永遠不能是 protected，這意味著以下配置永遠不會匹配任何 enumMember

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

為了幫助匹配，不能指定存取範圍的成員將始終具有 public 修飾符。這意味著以下配置將始終匹配任何 enumMember

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

範例​

強制所有變數、函數和屬性遵循 camelCase​

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

強制私有成員以底線作為前綴​

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

強制布林變數以允許的動詞作為前綴​

注意：如上文所述，在驗證格式之前會修剪前綴，因此必須使用 PascalCase 才能允許諸如 isEnabled 之類的變數。

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

強制所有變數採用 camelCase 或 UPPER_CASE​

{
  "@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 規則。

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

強制介面名稱不要以 I 開頭​

這允許您模擬舊的 interface-name-prefix 規則。

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

強制函數名稱採用 camelCase 或 PascalCase​

函數名稱通常採用 camelCase，但 UI 函式庫組件（尤其是 JSX，例如 React 和 Solid）使用 PascalCase 來區分它們與內建元素。如果您正在編寫函數組件，請考慮允許函數同時使用 camelCase 和 PascalCase。

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

強制變數和函數名稱採用 camelCase​

這允許您使用相同的模式檢查多種類型。

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

忽略需要引號的屬性​

有時您必須使用違反約定的引號名稱（例如，HTTP 標頭）。如果這在您的程式碼庫中很常見，那麼您有幾個選擇。

如果您只想允許所有需要引號的屬性名稱，則可以使用 requiresQuotes 修飾符來匹配任何需要引號的屬性名稱，並使用 format: null 來忽略該名稱。

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

如果您只有少量已知的例外，則可以使用 filter 選項僅忽略這些特定名稱

{
  "@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 選項忽略具有特定字符的名稱

{
  "@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 註釋。

忽略解構的名稱​

有時您可能希望允許解構的屬性保留其原始名稱，即使它違反了您的命名約定。

您可以使用 destructured 修飾符來匹配這些名稱，並顯式設定 format: null 以不套用任何格式

{
  "@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"]
    }
  ]
}

何時不使用它​

此規則可能非常嚴格。如果您對強制執行命名約定沒有強烈需求，我們建議僅使用它來標記嚴重違反您的命名標準的情況。如果您有這樣的流程，請考慮記錄您的命名約定並在程式碼審查中強制執行它們。

如果您不想對任何內容強制執行命名約定，則可以停用此規則。

但是，請記住，不一致的樣式可能會損害專案的可讀性。我們建議如果您關心命名約定，請為此規則選擇最適合您專案的單一選項。

類型檢查程式碼規則比傳統程式碼規則更強大，但也需要配置類型檢查程式碼。如果您在啟用類型檢查規則後遇到效能下降，請參閱效能疑難排解。

資源​