本文翻譯自 JETBRAINS Blog 的 JavaScript Best Practices，原作者是 David Watson
JavaScript 無疑是世界上使用最廣泛的編程語言，並且對我們所依賴的最大技術之一 —— 互聯網具有巨大的影響。這種能力伴隨著巨大的責任，JavaScript 生態系統一直在快速發展，使得跟上最新的 JavaScript 最佳實踐變得極其困難。
在這篇博文中，我們將介紹現代 JavaScript 中的幾種關鍵最佳實踐，以編寫更乾淨、更易於維護、性能更高的代碼。
項目定義的實踐勝過所有其他實踐#
您編寫代碼的項目可以有自己的嚴格規則。項目規則比任何最佳實踐文章中的任何建議都更有意義 —— 包括這篇文章！如果您想使用特定的做法，請確保將其與項目規則和代碼庫同步，並確保團隊中的每個人都參與其中。
使用最新的 JavaScript#
JavaScript 於 1995 年 12 月 4 日被發明。從那時起，它就一直在不斷地發展。在網上，您可以找到很多過時的建議和做法。要小心並驗證您想要使用的做法是否是最新的。
另外，使用最新的 JavaScript 功能時要小心謹慎。最好開始使用至少經過 Ecma TC39 Stage 3 的新 JavaScript 功能。
話雖如此，這裡還是匯集了一些當前常見的 JavaScript 最佳實踐：
聲明變量#
您可能會遇到使用許多 var 聲明的代碼。這可能是故意的，但如果是舊代碼，則可能是因為這是舊方法。
建議： 使用 let 和 const 而不是 var 來聲明變量。
為什麼這很重要： 儘管 var 仍然可用，但 let 和 const 提供塊作用域，它更可預測，並減少了使用 var（函數作用域）聲明變量時可能發生的意外錯誤。
for (let j = 1; j < 5; j++) {
console.log(j);
}
console.log(j);
// you get 'Uncaught ReferenceError: j is not defined'
//If we did this using var:
for (var j = 1; j < 5; j++) {
console.log(j);
}
// <-- logs the numbers 1 to 4
console.log(j);
//You’d get 5 as it still exists outside the loop
類代替函數：原型#
在許多有關 JavaScript 中 OOP 的舊代碼庫或文章中，您可能會遇到用於模擬類的函數原型方法。例如：
function Person(name) {
this.name = name;
}
Person.prototype.getName = function () {
return this.name;
}
const p = new Person('A');
console.log(p.getName()); // 'A'
建議： 這種方法使用構造函數來控制原型鏈。但是，在這種情況下，使用類幾乎總是更好的。
class Person {
constructor(name) {
this.name = name;
}
getName() {
return this.name;
}
}
const p = new Person('A');
console.log(p.getName()); // 'A'
為什麼重要： 使用類的主要原因是它們具有更清晰的語法。
私有類字段#
在較舊的 JavaScript 代碼中，通常使用下劃線 (_) 作為約定來表示類中的私有屬性或方法。然而，這實際上並沒有強制隱私 —— 它只是向開發人員發出信號，表明某些東西應該是私密的。
class Person {
constructor(name) {
this._name = name; // Conventionally treated as private, but not truly private
}
getName() {
return this._name;
}
}
const p = new Person('A');
console.log(p.getName()); // 'A'
console.log(p._name); // 'A' (still accessible from outside)
建議： 當您確實需要類中的私有字段時，JavaScript 現在使用 # 語法擁有真正的私有字段。這是強制實施真正隱私的官方語言功能。
箭頭函數表達式#
箭頭函數通常用於使回調函數或匿名函數更簡潔、更易讀。它們在使用 map、filter 或 Reduce 等高階函數時尤其有用。
const numbers = [1, 2];
// Using arrow function
numbers.map(num => num * 2);
// Instead of
numbers.map(function (num) {
return num * 2;
});
建議： 箭頭函數提供了更簡潔的語法，尤其是當函數體是單個表達式時。它們還會自動綁定 this 上下文，這在類方法中特別有用，因為 this 很容易丟失。
為什麼重要： 箭頭函數通過刪除樣板代碼，使回調函數和內聯表達式更加簡潔，從而提高了可讀性。此外，它們在使用類或事件處理程序時特別有價值，因為它們會自動將 this 綁定到周圍的詞法範圍。這避免了傳統函數表達式中與 this 相關的常見錯誤，尤其是在異步或回調密集型代碼中。
空值合併（??）#
在 JavaScript 中，當變量為 undefined 或 null 時，開發人員經常使用邏輯或（||）運算符來分配默認值。但是，當變量保存諸如 0、false 或空字符串 ("") 之類的值時，可能會出現意外行為，因為 || 將它們視為假值並替換為默認值。
例如：
const value = 0;
const result = value || 10;
console.log(result); // 10 (unexpected if 0 is a valid value)
建議： 解析默認值時，使用空值合併運算符 (??) 代替 ||。它僅檢查是否為undefined 或 null ，而其他假值（如 0、false、""）保持不變。
const value = 0;
const result = value ?? 10;
console.log(result); // 0 (expected behavior)
為什麼重要： 當 null 或 undefined 應觸發回退時，?? 運算符提供了一種更精確的方式來處理默認值。它可以防止因使用||而導致的錯誤，因為 || 可能會無意中覆蓋有效的假值。使用空值合併可實現更可預測的行為，從而提高代碼清晰度和可靠性。
可選鏈接（?.）：#
處理深層嵌套的對象或數組時，通常必須在嘗試訪問下級之前檢查每個屬性或數組元素是否存在。如果沒有可選鏈，這需要冗長而重複的代碼。
例如：
const product = {};
// Without optional chaining
const tax = (product.price && product.price.tax) ?? undefined;
建議： 可選鏈接運算符（?.）通過在嘗試訪問屬性或方法之前自動檢查其是否存在來簡化此過程。如果鏈中的任何部分為空或未定義，它將返回未定義而不是拋出錯誤。
const product = {};
// Using optional chaining
const tax = product?.price?.tax;
為什麼重要： 可選鏈接減少了樣板代碼的數量，並使處理深度嵌套的結構變得更加容易。它可以通過優雅地處理空值或未定義值來確保您的代碼更乾淨、更少出錯，而無需進行多次檢查。這使得代碼更具可讀性和可維護性，特別是在處理動態數據或複雜對象時。
async/await#
在較舊的 JavaScript 中，處理異步操作通常依賴於回調或鏈接承諾，這很快就會導致複雜且難以閱讀的代碼。例如，使用 .then() 進行承諾鏈可能會使流程更難遵循，尤其是在多個異步操作的情況下：
function fetchData() {
return fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => {
console.log(data);
})
.catch(error => {
console.error(error);
});
}
建議： 使用 async 和 await 使異步代碼看起來更像常規同步代碼。這提高了可讀性，並使 try...catch 的錯誤處理更加容易。
async function fetchData() {
try {
const response = await fetch('https://api.example.com/data');
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}
}
為什麼重要： async/await 語法消除了鏈接 .then() 和 .catch() 的需要，從而簡化了異步操作。它使您的代碼更易讀、更易於維護且更易於理解，尤其是在處理多個異步調用時。使用 try...catch 錯誤處理也更直接，從而產生更清晰、更可預測的邏輯。
與對象鍵和值的交互#
在較舊的 JavaScript 代碼中，與對象的鍵和值的交互通常涉及使用 for...in 或 Object.keys() 手動循環，然後通過括號符號或點符號訪問值。這可能會導致代碼冗長且不太直觀。
const obj = { a: 1, b: 2, c: 3 };
// Older approach with Object.keys()
Object.keys(obj).forEach(key => {
console.log(key, obj[key]);
});
建議： 使用現代方法（例如 Object.entries()、Object.values() 和 Object.keys()）來處理對象鍵和值。這些方法簡化了流程並返回有用的結構（如數組），使您的代碼更簡潔且更易於使用。
const obj = { a: 1, b: 2, c: 3 };
// Using Object.entries() to iterate over key-value pairs
Object.entries(obj).forEach(([key, value]) => {
console.log(key, value);
});
// Using Object.values() to work directly with values
Object.values(obj).forEach(value => {
console.log(value);
});
為什麼重要： 使用現代對象方法（例如 Object.entries()、Object.values() 和 Object.keys()）可以生成更清晰、更易讀的代碼。這些方法減少了迭代對象所需的樣板量並提高了代碼清晰度，特別是在處理複雜或動態數據結構時。它們還支持更輕鬆地將對象轉換為其他形式（例如數組），從而使數據操作更加靈活和高效。
檢查變量的數組類型#
過去，開發人員使用各種非直接的方法來檢查變量是否是數組。這些方法包括檢查構造函數或使用 instanceof 等方法，但它們通常不可靠，尤其是在處理不同的執行上下文（如 iframe）時。
const arr = [1, 2, 3];
// Older approach
console.log(arr instanceof Array); // true, but not always reliable across different contexts
建議： 使用現代的 Array.isArray() 方法，該方法提供了一種簡單可靠的方法來檢查變量是否為數組。此方法在不同環境和執行上下文中均能一致地工作。
const arr = [1, 2, 3];
console.log(Array.isArray(arr)); // true
為什麼重要： Array.isArray() 是一種檢查數組的清晰、可讀且可靠的方法。它消除了對諸如 instanceof 之類的冗長或容易出錯的方法的需要，確保您的代碼正確處理數組檢測，即使在複雜或跨環境場景中也是如此。當使用不同類型的數據結構時，這會減少錯誤並使行為更可預測。
Map#
在早期的 JavaScript 中，開發人員經常使用普通對象將鍵映射到值。然而，這種方法有局限性，尤其是當鍵不是字符串或符號時。普通對象只能使用字符串或符號作為鍵，因此如果需要將非原始對象（如數組或其他對象）映射到值，則會變得麻煩且容易出錯。
const obj = {};
const key = { id: 1 };
// Trying to use a non-primitive object as a key
obj[key] = 'value';
console.log(obj); // Object automatically converts key to a string: '[object Object]: value'
建議： 當您需要映射非原始對象或需要更強大的數據結構時，請使用 Map。與普通對象不同，Map 允許任何類型的值（原始和非原始）作為鍵。
const map = new Map();
const key = { id: 1 };
// Using a non-primitive object as a key in a Map
map.set(key, 'value');
console.log(map.get(key)); // 'value'
為什麼重要： Map 是一種更靈活、更可預測的方式，可以將值與任何類型的鍵（無論是原始鍵還是非原始鍵）關聯起來。它保留了鍵的類型和順序，而普通對象則將鍵轉換為字符串。這使得鍵值對的處理更強大和高效，特別是在處理複雜數據或需要在更大的集合中快速查找時。
隱藏值的符號#
在 JavaScript 中，對象通常用於存儲鍵值對。但是，當您需要向對象添加 “隱藏” 或唯一值，而又不冒與其他屬性發生名稱衝突的風險，或者您希望將它們對外部代碼保密時，使用 Symbol 會非常有用。符號創建唯一的鍵，無法通過正常枚舉或意外屬性查找來訪問。
const obj = { name: 'Alice' };
const hiddenKey = Symbol('hidden');
obj[hiddenKey] = 'Secret Value';
console.log(obj.name); // 'Alice'
console.log(obj[hiddenKey]); // 'Secret Value'
建議： 當您想要向對象添加不可枚舉的隱藏屬性時，請使用 Symbol。在典型的對象操作（例如 for...in 循環或 Object.keys()）期間無法訪問符號，這使得它們非常適合不應意外暴露的內部或私有數據。
const obj = { name: 'Alice' };
const hiddenKey = Symbol('hidden');
obj[hiddenKey] = 'Secret Value';
console.log(Object.keys(obj)); // ['name'] (Symbol keys won't appear)
console.log(Object.getOwnPropertySymbols(obj)); // [Symbol(hidden)] (accessible only if specifically retrieved)
為什麼重要： 符號允許您安全地向對象添加唯一和 “隱藏” 屬性，而不必擔心密鑰衝突或將內部細節暴露給代碼庫的其他部分。它們在庫或框架中特別有用，您可能需要存儲元數據或內部狀態而不影響或干擾其他屬性。這確保了更好的封裝並降低了意外覆蓋或誤用的風險。
使用額外的格式化庫之前請檢查 Intl API#
過去，開發人員通常依賴第三方庫來完成諸如格式化日期、數字和貨幣等任務以適應不同的地區。雖然這些庫提供了強大的功能，但它們會給您的項目增加額外的負擔，並且可能會重複 JavaScript 中已經內置的功能。
// Using a library for currency formatting
const amount = 123456.78;
// formatLibrary.formatCurrency(amount, 'USD');
建議： 在使用外部庫之前，請考慮使用內置的 ECMAScript 國際化 API（Intl）。它提供了強大的現成功能，可根據區域設置格式化日期、數字、貨幣等。這通常可以滿足您的大部分國際化和本地化需求，而無需第三方庫的額外開銷。
const amount = 123456.78;
// Using Intl.NumberFormat for currency formatting
const formatter = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' });
console.log(formatter.format(amount)); // $123,456.78
為什麼重要性： Intl API 為國際化提供本機和高度優化的支持，因此無需為簡單的格式化需求導入大型庫。通過使用內置功能，您可以保持項目輕量級、減少依賴性，同時仍然提供全面的基於語言環境的格式化解決方案。這不僅提高了性能，而且還減少了與第三方庫相關的維護負擔。
常見做法#
現在，讓我們看一下一些應該是最佳實踐的常見做法。
如果可能的話，使用嚴格相等（===）#
JavaScript 中最棘手和最令人驚訝的行為之一來自鬆散相等運算符 (==)。它執行類型強制，這意味著它會在比較操作數之前嘗試將其轉換為相同類型。它執行類型強制轉換，這意味著它會在比較操作數之前嘗試將其轉換為相同類型。這可能會導致奇怪且意想不到的結果，正如 Brian Leroux 的演講中著名的 “WTFJS” 案例所示：
console.log([] == ![]); // 返回 true (什麼叫做驚喜？！)
在這種情況下，鬆散相等運算符（==）會以意想不到的方式轉換雙方，從而導致不直觀的結果。
建議： 儘可能使用嚴格相等 (===) 而不是鬆散相等 (==)。嚴格相等不會執行類型強制轉換 - 它直接比較值和類型，從而產生更可預測和更可靠的行為。
console.log([] === ![]); // 返回 false (和預期一樣)
下面是一個更典型的例子來強調差異：
// Loose equality (==) performs type coercion
console.log(0 == ''); // true
// Strict equality (===) compares both value and type
console.log(0 === ''); // false (as expected)
為什麼重要： 使用嚴格相等（===）有助於避免 JavaScript 中類型強制帶來的意外行為。它使比較更加可預測，並降低了出現細微錯誤的風險，尤其是在處理數字、字符串或布爾值等不同數據類型時。默認使用 === 是一種很好的做法，除非您有特殊理由使用鬆散相等性並且理解其含義。
明確處理 if 語句中的表達式：#
在 JavaScript 中，if 語句將其計算的表達式的結果隱式轉換為 “真” 值或 “假” 值。這意味著 0、""（空字符串）、null、undefined 和 false 等值都被視為假值，而大多數其他值（甚至像 [] 或 {} 這樣的值）都是真值。如果不小心，這種隱式轉換有時會導致意外的結果。
例如：
const value = 0;
if (value) {
console.log('This will not run because 0 is falsy.');
}
建議： 明確說明 if 語句中的條件是一種很好的做法，尤其是當您使用的值在真 / 假評估中可能表現不正常時。這會使代碼更可預測且更易於理解。
例如，不依賴於隱式類型強制：
const value = 0;
// Implicit check (may behave unexpectedly for some values)
if (value) {
console.log('This won’t run');
}
您可以使用明確的條件：
// Explicitly check for the type or value you expect
if (value !== 0) {
console.log('This will run only if value is not 0.');
}
或者，檢查是否為 null 或 undefined 時：
const name = null;
if (name != null) { // Explicitly checking for null or undefined
console.log('Name is defined');
} else {
console.log('Name is null or undefined');
}
為什麼重要： 通過明確定義 if 語句中的條件，可以減少因 JavaScript 自動類型強制而出現意外行為的可能性。這使得您的代碼更清晰，並有助於在使用可能存在歧義的值（如 0、false、null 或“”）時防止出現錯誤。明確說明您要檢查的條件是一種很好的做法，尤其是在複雜邏輯中。
不要使用內置 Number 進行敏感計算#
JavaScript 的內置 Number 類型是基於 IEEE 754 標準的浮點數。雖然這對於大多數用途來說都很有效，但它可能會導致令人驚訝的不準確性，尤其是在十進制算術中。這不是 JavaScript 特有的問題，但當您處理敏感數據（例如財務計算）時，它可能會導致嚴重問題。
例如，您可能會遇到這個著名的浮點問題：
console.log(0.1 + 0.2); // 0.30000000000000004
建議： 當精度至關重要時（例如在財務計算中），請避免使用標準 Number 類型進行算術運算。相反，使用專門的庫，如 decimal.js 或 big.js，它們旨在處理精確的十進制計算而不會出現浮點錯誤。
以下是它與 decimal.js 等庫一起工作的方式：
const Decimal = require('decimal.js');
const result = new Decimal(0.1).plus(0.2);
console.log(result.toString()); // '0.3'
這些庫確保計算的精確性，並且舍入誤差不會影響結果，使其成為處理金錢等敏感任務的理想選擇。
為什麼重要： 處理財務數據等時，計算不準確會導致嚴重問題，即使是微小的差異也會造成嚴重影響。JavaScript 的浮點數學可能會產生意外的結果，雖然該語言正在不斷改進，但目前最好依靠 decimal.js 或 big.js 等庫來確保精度。通過使用這些庫，您可以避免常見的陷阱並確保您的計算準確、可信且適合關鍵應用。
謹慎使用 JSON 和大整數#
JavaScript 在處理非常大的數字時有限制。JavaScript 中的最大安全整數是 9007199254740991（也稱為 Number.MAX_SAFE_INTEGER）。大於此值的數字可能會失去精度並產生錯誤的結果。在使用 JavaScript 以外的 API 或系統時，這會成為一個問題，因為大數字（例如數據庫 ID 字段）很容易超出 JavaScript 的安全範圍。
例如，解析包含大量數字的 JSON 時：
console.log(
JSON.parse('{"id": 9007199254740999}')
);
// 輸出: { id: 9007199254741000 } (精度丟失)
建議： 處理 JSON 數據中的大量數字時，為了避免出現此精度問題，可以使用 JSON.parse() 的 reviver 參數。這使您可以手動處理特定值（例如 id 字段）並以安全格式（例如字符串）保存它們。
console.log(
JSON.parse(
'{"id": 9007199254740999}',
(key, value, ctx) => {
if (key === 'id') {
return ctx.source; // Preserve the original value as a string
}
return value;
}
)
);
// Output: { id: '9007199254740999' }
使用 BigInt： JavaScript 引入了 BigInt 來安全地處理大於 Number.MAX_SAFE_INTEGER 的數字。但是，BigInt 不能直接序列化為 JSON。如果您嘗試將包含 BigInt 的對象字符串化，則會收到 TypeError：
const data = { id: 9007199254740999n };
try {
JSON.stringify(data);
} catch (e) {
console.log(e.message); // '不知道如何序列化 BigInt'
}
為了解決這個問題，請使用 **JSON.stringify () ** 中的 replacer 參數將 BigInt 值轉換為字符串：
const data = { id: 9007199254740999n };
console.log(
JSON.stringify(data, (key, value) => {
if (typeof value === 'bigint') {
return value.toString() + 'n'; // Append 'n' to denote BigInt
}
return value;
})
);
// Output: {"id":"9007199254740999n"}
⚠️重要注意事項： 如果使用這些技術處理 JSON 中的大整數，請確保應用程序的客戶端和服務器端都同意如何序列化和反序列化數據。例如，如果服務器以特定格式的字符串或 BigInt 形式發送 id，則客戶端必須準備在反序列化期間處理該格式。
為什麼重要： 在處理來自外部系統的大量數字時，JavaScript 的數字精度限制可能會導致嚴重的錯誤。通過使用 BigInt 等技術以及 JSON.parse() 和 JSON.stringify() 的 reviver/replacer 參數，您可以確保正確處理大整數，從而避免數據損壞。在精度至關重要的情況下，這一點尤其重要，例如處理大型身份證或金融交易。
使用 JSDoc 幫助代碼閱讀者和編輯者#
使用 JavaScript 時，函數和對象簽名通常缺少文檔，這使得其他開發人員（甚至是您未來的自己）更難理解參數和對象包含什麼或如何使用函數。如果沒有適當的文檔，代碼可能會產生歧義，尤其是在對象結構不清楚的情況下：
例如：
const printFullUserName = user =>
// Does user have the `middleName` or `surName`?
`${user.firstName} ${user.lastName}`;
在這種情況下，沒有任何文檔，無法立即清楚用戶對象應該具有哪些屬性。user 是否包含 middleName？是否應該使用 surName 而不是 lastName？
建議： 通過使用 JSDoc，您可以定義對象、函數參數和返回類型的預期結構。這使得代碼閱讀器更容易理解功能，也有助於代碼編輯器提供更好的自動完成、類型檢查和工具提示。
下面展示了如何使用 JSDoc 改進前面的示例：
/**
* @typedef {Object} User
* @property {string} firstName
* @property {string} [middleName] // Optional property
* @property {string} lastName
*/
/**
* Prints the full name of a user.
* @param {User} user - The user object containing name details.
* @return {string} - The full name of the user.
*/
const printFullUserName = user =>
`${user.firstName} ${user.middleName ? user.middleName + ' ' : ''}${user.lastName}`;
重要性： JSDoc 通過清楚地指示函數或對象中所需的值類型來提高代碼的可讀性和可維護性。它還通過在許多編輯器和 IDE（例如 Visual Studio Code 或 WebStorm）中啟用自動完成和類型檢查來增強開發人員體驗。這減少了出現錯誤的可能性，並使新開發人員更容易加入並理解代碼。
使用 JSDoc，編輯器可以提供提示、對象屬性的自動完成，甚至在開發人員誤用函數或提供錯誤的參數類型時發出警告，使您的代碼更易於理解和健壯。
使用測試#
隨著代碼庫的增長，手動驗證新更改不會破壞重要功能會變得非常耗時且容易出錯。自動測試有助於確保您的代碼按預期運行，並允許您放心地進行更改。
在 JavaScript 生態系統中，有許多可用的測試框架，但從 Node.js 版本 20 開始，您不再需要外部框架來開始編寫和運行測試。Node.js 現在包含一個內置的穩定測試運行器。
這是一個使用 Node.js 內置測試運行器的簡單示例：
import { test } from 'node:test';
import { equal } from 'node:assert';
// A simple function to test
const sum = (a, b) => a + b;
// Writing a test for the sum function
test('sum', () => {
equal(sum(1, 1), 2); // Should return true if 1 + 1 equals 2
});
您可以使用以下命令運行此測試：
node --test
此內置解決方案簡化了在 Node.js 環境中編寫和運行測試的過程。您不再需要配置或安裝 Jest 或 Mocha 等其他工具，儘管這些選項對於較大的項目仍然非常有用。
瀏覽器中的 E2E 測試： 對於瀏覽器中的端到端 (E2E) 測試，Playwright 是一款出色的工具，可讓您輕鬆地自動化和測試瀏覽器內的交互。使用 Playwright，您可以測試用戶流程，模擬跨多個瀏覽器（例如 Chrome、Firefox 和 Safari）的交互，並確保您的應用從用戶的角度按照預期運行。
其他環境： 兩個備選的 JavaScript 運行時 Bun 和 Deno 也提供了類似於 Node.js 的內置測試運行器，因此無需額外設置即可輕鬆編寫和運行測試。
為什麼重要： 從長遠來看，編寫測試可以節省時間，因為它可以盡早發現錯誤，並減少每次更改後進行手動測試的需要。它還能讓您确信新功能或重構不會引入回歸。事實上，Node.js、Bun 和 Deno 等現代運行時包含內置測試運行器，這意味著您可以以最少的設置立即開始編寫測試。Playwright 等測試工具有助於確保您的應用程序在真實的瀏覽器環境中無縫運行，為關鍵的用戶交互增加額外的保證。
最後的想法#
雖然這看起來似乎有很多內容需要學習。但希望它能讓您深入了解一些您以前沒有考慮過並希望在您的 JavaScript 項目中實現的領域。再次強調，請隨意將此內容添加到書籤中並在需要時隨時參考。JavaScript 慣例不斷變化和發展，框架也是如此。跟上最新的工具和最佳實踐將不斷改進和優化您的代碼，但這可能很難做到。我們建議關注 ECMAScript 版本的動向，因為這通常會指向最新的 JavaScript 代碼中普遍採用的新約定。TC39 通常會針對最新的 ECMAScript 版本提出建議，您也可以關注這些建議。
通過採用這些現代 JavaScript 最佳實踐，您不僅可以編寫可用的代碼，還可以創建更清晰、更高效、更易於維護的解決方案。無論是使用 async/await 等較新的語法，避免浮點數的陷阱，還是利用強大的 Intl API，這些實踐都將幫助您保持最新狀態並對代碼庫充滿信心。隨著 JavaScript 生態系統的持續發展，現在花點時間採用最佳實踐將使您免於未來的麻煩並為長期成功做好準備。
今天就到這裡！我們希望這篇文章對您有所幫助 —— 歡迎評論提問、討論和分享建議。祝您編碼愉快！