筆者花了一個下午的時間把 ESLint 推薦的 rules 進行了總結。把官網rules打勾的部分寫成了
MD
文件,並把每個 rules 裡面的說明和示例也搞出來放一起了。在這裡把它貢獻出來。
部落格維護在github上,歡迎給一個star!!!
個人小站 => huangmiantong.cnno-compare-neg-zero
禁止與 -0 進行比較
Rule Details
該規則對試圖與 -0 進行比較的程式碼發出警告,因為並不會達到預期。也就是說像 x === -0 的程式碼對於 +0 和 -0 都有效。作者可能想要用 Object.is(x, -0)。
錯誤 程式碼示例:
if (x === -0) {
// doSomething()...
}
複製程式碼
正確 程式碼示例:
if (x === 0) {
//a doSomething()...
}
複製程式碼
if (Object.is(x, -0)) {
// doSomething()...
}
複製程式碼
no-cond-assign
禁止條件表示式中出現賦值操作符
Rule Details
該規則禁止在 if、for、while 和 do...while 語句中出現模稜兩可的賦值操作符。
options
該規則有一個字串選項:
- "except-parens" (預設) 允許條件語句中出現賦值操作符,前提是它們被圓括號括起來 (例如,在 while 或 do...while 迴圈條件中,允許賦值給一個變數)
- "always" 禁止條件語句中出現賦值語句
預設選項 "except-parens" 的 錯誤 程式碼示例:
/*eslint no-cond-assign: "error"*/
// Unintentional assignment
var x;
if (x = 0) {
var b = 1;
}
// Practical example that is similar to an error
function setHeight(someNode) {
"use strict";
do {
someNode.height = "100px";
} while (someNode = someNode.parentNode);
}
複製程式碼
預設選項 "except-parens" 的 正確 程式碼示例:
/*eslint no-cond-assign: "error"*/
// Assignment replaced by comparison
var x;
if (x === 0) {
var b = 1;
}
// Practical example that wraps the assignment in parentheses
function setHeight(someNode) {
"use strict";
do {
someNode.height = "100px";
} while ((someNode = someNode.parentNode));
}
// Practical example that wraps the assignment and tests for 'null'
function setHeight(someNode) {
"use strict";
do {
someNode.height = "100px";
} while ((someNode = someNode.parentNode) !== null);
}
複製程式碼
選項 "always" 的 錯誤 程式碼示例:
/*eslint no-cond-assign: ["error", "always"]*/
// Unintentional assignment
var x;
if (x = 0) {
var b = 1;
}
// Practical example that is similar to an error
function setHeight(someNode) {
"use strict";
do {
someNode.height = "100px";
} while (someNode = someNode.parentNode);
}
// Practical example that wraps the assignment in parentheses
function setHeight(someNode) {
"use strict";
do {
someNode.height = "100px";
} while ((someNode = someNode.parentNode));
}
// Practical example that wraps the assignment and tests for 'null'
function setHeight(someNode) {
"use strict";
do {
someNode.height = "100px";
} while ((someNode = someNode.parentNode) !== null);
}
複製程式碼
選項 "always" 的 正確 程式碼示例:
/*eslint no-cond-assign: ["error", "always"]*/
// Assignment replaced by comparison
var x;
if (x === 0) {
var b = 1;
}
複製程式碼
no-console
禁用 console
Rule Details
該規則禁止呼叫 console 物件的方法。
錯誤 程式碼示例:
/*eslint no-console: "error"*/
console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");
複製程式碼
正確 程式碼示例:
/*eslint no-console: "error"*/
// custom console
Console.log("Hello world!");
複製程式碼
options
該規則有例外情況,是個物件:
- "allow" 是個字串陣列,包含允許使用的console 物件的方法
選項 { "allow": ["warn", "error"] } 的 正確 程式碼示例:
/*eslint no-console: ["error", { allow: ["warn", "error"] }] */
console.warn("Log a warn level message.");
console.error("Log an error level message.");
複製程式碼
When Not To Use It
如果你在使用 Node.js,然後,console 主要用來向使用者輸出資訊,所以不是嚴格用於除錯目的。如果你正在做 Node.js 開發,那麼你很可能不想啟用此規則。
另一個可能不使用此規則的情況是,如果你想執行控制檯呼叫,而不是控制檯重寫。例如:
/*eslint no-console: ["error", { allow: ["warn"] }] */
console.error = function (message) {
throw new Error(message);
};
複製程式碼
在上面使用 no-console 規則的示例中,ESLint 將報告一個錯誤。對於上面的例子,你可以禁用該規則:
// eslint-disable-next-line no-console
console.error = function (message) {
throw new Error(message);
};
// or
console.error = function (message) { // eslint-disable-line no-console
throw new Error(message);
};
複製程式碼
然而,你可能不希望手動新增 eslint-disable-next-line 或 eslint-disable-line。你可以使用 no-restricted-syntax 規則來實現控制檯呼叫僅接收錯誤的效果:
{
"rules": {
"no-restricted-syntax": [
"error",
{
"selector": "CallExpression[callee.object.name='console'][callee.property.name=/^(log|warn|error|info|trace)$/]",
"message": "Unexpected property on console object was called"
}
]
}
}
複製程式碼
no-constant-condition
禁止在條件中使用常量表示式
Rule Details
該規則禁止在以下語句的條件中出現常量表示式:
- if、for、while 或 do...while 語句
- ?: 三元表示式
錯誤 程式碼示例:
/*eslint no-constant-condition: "error"*/
if (false) {
doSomethingUnfinished();
}
if (void x) {
doSomethingUnfinished();
}
for (;-2;) {
doSomethingForever();
}
while (typeof x) {
doSomethingForever();
}
do {
doSomethingForever();
} while (x = -1);
var result = 0 ? a : b;
複製程式碼
正確 程式碼示例:
/*eslint no-constant-condition: "error"*/
if (x === 0) {
doSomething();
}
for (;;) {
doSomethingForever();
}
while (typeof x === "undefined") {
doSomething();
}
do {
doSomething();
} while (x);
var result = x !== 0 ? a : b;
複製程式碼
options
checkLoops
預設為 true。設定該選項為 false 允許在迴圈中使用常量表示式。
當 checkLoops 為 false 時的 正確 程式碼示例:
/*eslint no-constant-condition: ["error", { "checkLoops": false }]*/
while (true) {
doSomething();
if (condition()) {
break;
}
};
for (;true;) {
doSomething();
if (condition()) {
break;
}
};
do {
doSomething();
if (condition()) {
break;
}
} while (true)
複製程式碼
no-control-regex
禁止在正規表示式中使用控制字元
Rule Details
該規則禁止在正規表示式中出現控制字元。
錯誤 程式碼示例:
/*eslint no-control-regex: "error"*/
var pattern1 = /\x1f/;
var pattern2 = new RegExp("\x1f");
複製程式碼
正確 程式碼示例:
/*eslint no-control-regex: "error"*/
var pattern1 = /\x20/;
var pattern2 = new RegExp("\x20");
複製程式碼
When Not To Use It
如果你需要使用控制字元進行模式匹配,你應該關閉該規則。
no-debugger
禁用 debugger
Rule Details
該規則禁止 debugger 語句。
錯誤 程式碼示例:
/*eslint no-debugger: "error"*/
function isTruthy(x) {
debugger;
return Boolean(x);
}
複製程式碼
正確 程式碼示例:
/*eslint no-debugger: "error"*/
function isTruthy(x) {
return Boolean(x); // set a breakpoint at this line
}
複製程式碼
When Not To Use It
如果你的程式碼在很大程度上仍處於開發階段,不想擔心剝離 debugger 語句,那麼就關閉此規則。通常在部署測試程式碼之前,你會想重新開啟此規則。
no-dupe-args
禁止 function 定義中出現重名引數
Rule Details
該規則禁止在函式定義或表達中出現重名引數。該規則並不適用於箭頭函式或類方法,因為解析器會報告這樣的錯誤。
如果 ESLint 在嚴格模式下解析程式碼,解析器(不是該規則)將報告這樣的錯誤。
錯誤 程式碼示例:
/*eslint no-dupe-args: "error"*/
function foo(a, b, a) {
console.log("value of the second a:", a);
}
var bar = function (a, b, a) {
console.log("value of the second a:", a);
};
複製程式碼
正確 程式碼示例:
/*eslint no-dupe-args: "error"*/
function foo(a, b, c) {
console.log(a, b, c);
}
var bar = function (a, b, c) {
console.log(a, b, c);
};
複製程式碼
no-dupe-keys
禁止物件字面量中出現重複的 key
Rule Details
該規則禁止在物件字面量中出現重複的鍵。
錯誤 程式碼示例:
/*eslint no-dupe-keys: "error"*/
var foo = {
bar: "baz",
bar: "qux"
};
var foo = {
"bar": "baz",
bar: "qux"
};
var foo = {
0x1: "baz",
1: "qux"
};
複製程式碼
正確 程式碼示例:
/*eslint no-dupe-keys: "error"*/
var foo = {
bar: "baz",
quxx: "qux"
};
複製程式碼
no-duplicate-case
禁止出現重複的 case 標籤
Rule Details
該規則禁止在 switch 語句中的 case 子句中出現重複的測試表示式。
錯誤 程式碼示例:
/*eslint no-duplicate-case: "error"*/
var a = 1,
one = 1;
switch (a) {
case 1:
break;
case 2:
break;
case 1: // duplicate test expression
break;
default:
break;
}
switch (a) {
case one:
break;
case 2:
break;
case one: // duplicate test expression
break;
default:
break;
}
switch (a) {
case "1":
break;
case "2":
break;
case "1": // duplicate test expression
break;
default:
break;
}
複製程式碼
正確 程式碼示例:
/*eslint no-duplicate-case: "error"*/
var a = 1,
one = 1;
switch (a) {
case 1:
break;
case 2:
break;
case 3:
break;
default:
break;
}
switch (a) {
case one:
break;
case 2:
break;
case 3:
break;
default:
break;
}
switch (a) {
case "1":
break;
case "2":
break;
case "3":
break;
default:
break;
}
複製程式碼
no-empty
禁止出現空語句塊
Rule Details
該規則禁止空語句塊出現。該規則忽略包含一個註釋的語句塊(例如,在 try 語句中,一個空的 catch 或 finally 語句塊意味著程式應該繼續執行,無論是否出現錯誤)。
錯誤 程式碼示例:
/*eslint no-empty: "error"*/
if (foo) {
}
while (foo) {
}
switch(foo) {
}
try {
doSomething();
} catch(ex) {
} finally {
}
複製程式碼
正確 程式碼示例:
/*eslint no-empty: "error"*/
if (foo) {
// empty
}
while (foo) {
/* empty */
}
try {
doSomething();
} catch (ex) {
// continue regardless of error
}
try {
doSomething();
} finally {
/* continue regardless of error */
}
複製程式碼
Options
該規則有例外情況,是個物件:
- "allowEmptyCatch": true 允許出現空的 catch 子句 (也就是說,不包含註釋)
allowEmptyCatch
選項 { "allowEmptyCatch": true } 的 正確 程式碼示例:
/* eslint no-empty: ["error", { "allowEmptyCatch": true }] */
try {
doSomething();
} catch (ex) {}
try {
doSomething();
}
catch (ex) {}
finally {
/* continue regardless of error */
}
複製程式碼
When Not To Use It
如果你打算使用空語句塊,那麼你可以禁用此規則。
no-empty-character-class
禁止在正規表示式中使用空字符集
Rule Details
該規則禁止在正規表示式中出現空字符集。
錯誤 程式碼示例:
/*eslint no-empty-character-class: "error"*/
/^abc[]/.test("abcdefg"); // false
"abcdefg".match(/^abc[]/); // null
複製程式碼
正確 程式碼示例:
/*eslint no-empty-character-class: "error"*/
/^abc/.test("abcdefg"); // true
"abcdefg".match(/^abc/); // ["abc"]
/^abc[a-z]/.test("abcdefg"); // true
"abcdefg".match(/^abc[a-z]/); // ["abcd"]
複製程式碼
Known Limitations
該規則不會報告 RegExp 建構函式的字串引數中空字符集的使用情況。
當該規則報告了正確程式碼時,漏報的示例:
/*eslint no-empty-character-class: "error"*/
var abcNeverMatches = new RegExp("^abc[]");
複製程式碼
no-ex-assign
禁止對 catch 子句的引數重新賦值
Rule Details
該規則禁止對 catch 子句中的異常重新賦值。
錯誤 程式碼示例:
/*eslint no-ex-assign: "error"*/
try {
// code
} catch (e) {
e = 10;
}
複製程式碼
正確 程式碼示例:
/*eslint no-ex-assign: "error"*/
try {
// code
} catch (e) {
var foo = 10;
}
複製程式碼
Further Reading
- The “catch” with try…catch by Ben Alman explains how the exception identifier can leak into the outer scope in IE 6-8
no-extra-boolean-cast
禁止不必要的布林轉換
Rule Details
該規則禁止不必要的布林型別轉換。
錯誤 程式碼示例:
/*eslint no-extra-boolean-cast: "error"*/
var foo = !!!bar;
var foo = !!bar ? baz : bat;
var foo = Boolean(!!bar);
var foo = new Boolean(!!bar);
if (!!foo) {
// ...
}
if (Boolean(foo)) {
// ...
}
while (!!foo) {
// ...
}
do {
// ...
} while (Boolean(foo));
for (; !!foo; ) {
// ...
}
複製程式碼
正確 程式碼示例:
/*eslint no-extra-boolean-cast: "error"*/
var foo = !!bar;
var foo = Boolean(bar);
function foo() {
return !!bar;
}
var foo = bar ? !!baz : !!bat;
複製程式碼
no-extra-semi
禁止不必要的分號
Rule Details
該規則禁用不必要的分號。
錯誤 程式碼示例:
/*eslint no-extra-semi: "error"*/
var x = 5;;
function foo() {
// code
};
複製程式碼
正確 程式碼示例:
/*eslint no-extra-semi: "error"*/
var x = 5;
var foo = function() {
// code
};
複製程式碼
When Not To Use It
如果你有意使用額外的分號,那麼你可以禁用此規則。
no-func-assign
禁止對 function 宣告重新賦值
Rule Details
該規則禁止對 function 宣告重新賦值。
錯誤 程式碼示例:
/*eslint no-func-assign: "error"*/
function foo() {}
foo = bar;
function foo() {
foo = bar;
}
複製程式碼
與 JSHint 中對應的規則不同,該規則的 錯誤 程式碼示例:
/*eslint no-func-assign: "error"*/
foo = bar;
function foo() {}
複製程式碼
正確 程式碼示例:
/*eslint no-func-assign: "error"*/
var foo = function () {}
foo = bar;
function foo(foo) { // `foo` is shadowed.
foo = bar;
}
function foo() {
var foo = bar; // `foo` is shadowed.
}
複製程式碼
no-inner-declarations
禁止在巢狀的塊中出現變數宣告或 function 宣告
Rule Details
該規則要求函式宣告和變數宣告(可選的)在程式或函式體的頂部。
Options
該規則有一個字串選項:
- "functions" (預設) 禁止 function 宣告出現在巢狀的語句塊中
- "both" 禁止 function 和 var 宣告出現在巢狀的語句塊中
functions
預設選項 "functions" 的 錯誤 程式碼示例:
/*eslint no-inner-declarations: "error"*/
if (test) {
function doSomething() { }
}
function doSomethingElse() {
if (test) {
function doAnotherThing() { }
}
}
複製程式碼
預設選項 "functions" 的 正確 程式碼示例:
/*eslint no-inner-declarations: "error"*/
function doSomething() { }
function doSomethingElse() {
function doAnotherThing() { }
}
if (test) {
asyncCall(id, function (err, data) { });
}
var fn;
if (test) {
fn = function fnExpression() { };
}
複製程式碼
both
選項 "both" 的 錯誤 程式碼示例:
/*eslint no-inner-declarations: ["error", "both"]*/
if (test) {
var foo = 42;
}
function doAnotherThing() {
if (test) {
var bar = 81;
}
}
複製程式碼
選項 "both" 的 正確 程式碼示例:
/*eslint no-inner-declarations: "error"*/
/*eslint-env es6*/
var bar = 42;
if (test) {
let baz = 43;
}
function doAnotherThing() {
var baz = 81;
}
複製程式碼
When Not To Use It
當 block-scoped functions 出現在 ES6 中時,函式宣告的部分規則將被廢棄,但在那之前,它應該是行之有效的。當使用 block-scoped-var 規則時或者在巢狀塊中宣告變數是可以接受的(儘管有變數宣告提升)時候,可以不再檢測變數宣告。
no-invalid-regexp
禁止 RegExp 建構函式中存在無效的正規表示式字串
Rule Details
該規則禁止在 RegExp 建構函式中出現無效的正規表示式。
錯誤 程式碼示例:
/*eslint no-invalid-regexp: "error"*/
RegExp('[')
RegExp('.', 'z')
new RegExp('\\')
複製程式碼
正確 程式碼示例:
/*eslint no-invalid-regexp: "error"*/
RegExp('.')
new RegExp
this.RegExp('[')
複製程式碼
Environments
ECMAScript 6 為 RegExp 建構函式增加了以下標誌引數:
- "u" (unicode)
- "y" (sticky) 你可以在你的 ESLint 配置 中通過設定 ECMAScript 為 6 ,來使這些標誌被有效地識別。
如果你想允許使用額外的標誌,也不論出於什麼目的,你可以在 .eslintrc 使用 allowConstructorFlags 選項指定它們。這樣,不管是否有 ecmaVersion 設定,這些標記將會被該規則忽略。
Options
該規則有例外情況,是個物件:
- "allowConstructorFlags" 是個標誌的陣列
allowConstructorFlags
選項 { "allowConstructorFlags": ["u", "y"] } 的 正確 程式碼示例:
/*eslint no-invalid-regexp: ["error", { "allowConstructorFlags": ["u", "y"] }]*/
new RegExp('.', 'y')
new RegExp('.', 'yu')
複製程式碼
Further Reading
no-irregular-whitespace
禁止在字串和註釋之外不規則的空白
Rule Details
該規則旨在捕獲無效的不是正常的tab和空格的空白。這些字元有的會在現代瀏覽器中引發問題,其它的會引起除錯問題。
該規則禁止出現以下字元,除非該規則選項允許:
\u000B - Line Tabulation (\v) - <VT>
\u000C - Form Feed (\f) - <FF>
\u00A0 - No-Break Space - <NBSP>
\u0085 - Next Line
\u1680 - Ogham Space Mark
\u180E - Mongolian Vowel Separator - <MVS>
\ufeff - Zero Width No-Break Space - <BOM>
\u2000 - En Quad
\u2001 - Em Quad
\u2002 - En Space - <ENSP>
\u2003 - Em Space - <EMSP>
\u2004 - Tree-Per-Em
\u2005 - Four-Per-Em
\u2006 - Six-Per-Em
\u2007 - Figure Space
\u2008 - Punctuation Space - <PUNCSP>
\u2009 - Thin Space
\u200A - Hair Space
\u200B - Zero Width Space - <ZWSP>
\u2028 - Line Separator
\u2029 - Paragraph Separator
\u202F - Narrow No-Break Space
\u205f - Medium Mathematical Space
\u3000 - Ideographic Space
複製程式碼
Options
該規則有例外情況,是個物件:
- "skipStrings": true (預設) 允許在字串字面量中出現任何空白字元
- "skipComments": true 允許在註釋中出現任何空白字元
- "skipRegExps": true 允許在正規表示式中出現任何空白字元
- "skipTemplates": true 允許在模板字面量中出現任何空白字元
skipStrings
預設選項 { "skipStrings": true } 的 錯誤 程式碼示例:
/*eslint no-irregular-whitespace: "error"*/
function thing() /*<NBSP>*/{
return 'test';
}
function thing( /*<NBSP>*/){
return 'test';
}
function thing /*<NBSP>*/(){
return 'test';
}
function thing/*<MVS>*/(){
return 'test';
}
function thing() {
return 'test'; /*<ENSP>*/
}
function thing() {
return 'test'; /*<NBSP>*/
}
function thing() {
// Description <NBSP>: some descriptive text
}
/*
Description <NBSP>: some descriptive text
*/
function thing() {
return / <NBSP>regexp/;
}
/*eslint-env es6*/
function thing() {
return `template <NBSP>string`;
}
複製程式碼
預設選項 { "skipStrings": true } 正確 程式碼示例:
/*eslint no-irregular-whitespace: "error"*/
function thing() {
return ' <NBSP>thing';
}
function thing() {
return '<ZWSP>thing';
}
function thing() {
return 'th <NBSP>ing';
}
複製程式碼
skipComments
選項 { "skipComments": true } 的 正確 程式碼示例:
/*eslint no-irregular-whitespace: ["error", { "skipComments": true }]*/
function thing() {
// Description <NBSP>: some descriptive text
}
/*
Description <NBSP>: some descriptive text
*/
複製程式碼
skipRegExps
選項 { "skipRegExps": true } 的 正確 程式碼示例:
/*eslint no-irregular-whitespace: ["error", { "skipRegExps": true }]*/
function thing() {
return / <NBSP>regexp/;
}
複製程式碼
skipTemplates
選項 { "skipTemplates": true } 的 正確 程式碼示例:
/*eslint no-irregular-whitespace: ["error", { "skipTemplates": true }]*/
/*eslint-env es6*/
function thing() {
return `template <NBSP>string`;
}
複製程式碼
When Not To Use It
如果你想在你的應用中使用 tab 和空格之外的空白字元,可以關閉此規則。
no-obj-calls
禁止把全域性物件作為函式呼叫
Rule Details
該規則禁止將 Math、JSON 和 Reflect 物件當作函式進行呼叫。
錯誤 程式碼示例:
/*eslint no-obj-calls: "error"*/
var math = Math();
var json = JSON();
var reflect = Reflect();
複製程式碼
正確 程式碼示例:
/*eslint no-obj-calls: "error"*/
function area(r) {
return Math.PI * r * r;
}
var object = JSON.parse("{}");
var value = Reflect.get({ x: 1, y: 2 }, "x");
複製程式碼
no-regex-spaces
禁止正規表示式字面量中出現多個空格
Rule Details
該規則禁止在正規表示式字面量中出現多個空格。
錯誤 程式碼示例:
/*eslint no-regex-spaces: "error"*/
var re = /foo bar/;
var re = new RegExp("foo bar");
複製程式碼
正確 程式碼示例:
/*eslint no-regex-spaces: "error"*/
var re = /foo {3}bar/;
var re = new RegExp("foo {3}bar");
複製程式碼
no-sparse-arrays
禁用稀疏陣列
Rule Details
該規則禁止使用稀疏陣列,也就是逗號之前沒有任何元素的陣列。該規則不適用於緊隨最後一個元素的拖尾逗號的情況。
錯誤 程式碼示例:
/*eslint no-sparse-arrays: "error"*/
var items = [,];
var colors = [ "red",, "blue" ];
複製程式碼
正確 程式碼示例:
/*eslint no-sparse-arrays: "error"*/
var items = [];
var items = new Array(23);
// trailing comma (after the last element) is not a problem
var colors = [ "red", "blue", ];
複製程式碼
no-unexpected-multiline
禁止出現令人困惑的多行表示式
Rule Details
該規則禁止使用令人困惑的多行表示式。
錯誤 程式碼示例:
/*eslint no-unexpected-multiline: "error"*/
var foo = bar
(1 || 2).baz();
var hello = 'world'
[1, 2, 3].forEach(addNumber);
let x = function() {}
`hello`
let x = function() {}
x
`hello`
let x = foo
/regex/g.test(bar)
複製程式碼
正確 程式碼示例:
/*eslint no-unexpected-multiline: "error"*/
var foo = bar;
(1 || 2).baz();
var foo = bar
;(1 || 2).baz()
var hello = 'world';
[1, 2, 3].forEach(addNumber);
var hello = 'world'
void [1, 2, 3].forEach(addNumber);
let x = function() {};
`hello`
let tag = function() {}
tag `hello`
複製程式碼
no-unreachable
禁止在return、throw、continue 和 break 語句之後出現不可達程式碼
Rule Details
該規則禁止在 return、throw、continue 和 break 語句後出現不可達程式碼。
錯誤 程式碼示例:
/*eslint no-unreachable: "error"*/
function foo() {
return true;
console.log("done");
}
function bar() {
throw new Error("Oops!");
console.log("done");
}
while(value) {
break;
console.log("done");
}
throw new Error("Oops!");
console.log("done");
function baz() {
if (Math.random() < 0.5) {
return;
} else {
throw new Error();
}
console.log("done");
}
for (;;) {}
console.log("done");
複製程式碼
正確 程式碼示例,因為 JavaScript 函式和變數提升:
/*eslint no-unreachable: "error"*/
function foo() {
return bar();
function bar() {
return 1;
}
}
function bar() {
return x;
var x;
}
switch (foo) {
case 1:
break;
var x;
}
複製程式碼
no-unsafe-finally
禁止在 finally 語句塊中出現控制流語句
Rule Details
該規則禁止在 finally 語句塊中出現 return、throw、break 和 continue 語句。它允許間接使用,比如在 function 或 class 的定義中。
錯誤 程式碼示例:
/*eslint no-unsafe-finally: "error"*/
let foo = function() {
try {
return 1;
} catch(err) {
return 2;
} finally {
return 3;
}
};
複製程式碼
/*eslint no-unsafe-finally: "error"*/
let foo = function() {
try {
return 1;
} catch(err) {
return 2;
} finally {
throw new Error;
}
};
複製程式碼
正確 程式碼示例:
/*eslint no-unsafe-finally: "error"*/
let foo = function() {
try {
return 1;
} catch(err) {
return 2;
} finally {
console.log("hola!");
}
};
複製程式碼
/*eslint no-unsafe-finally: "error"*/
let foo = function() {
try {
return 1;
} catch(err) {
return 2;
} finally {
let a = function() {
return "hola!";
}
}
};
複製程式碼
/*eslint no-unsafe-finally: "error"*/
let foo = function(a) {
try {
return 1;
} catch(err) {
return 2;
} finally {
switch(a) {
case 1: {
console.log("hola!")
break;
}
}
}
};
複製程式碼
no-unsafe-negation
禁止對關係運算子的左運算元使用否定操作符
Rule Details
該規則禁止對關係運算子的左運算元使用否定操作符。
關係運算子有:
- in 運算子.
- instanceof 運算子.
錯誤 程式碼示例:
/*eslint no-unsafe-negation: "error"*/
if (!key in object) {
// operator precedence makes it equivalent to (!key) in object
// and type conversion makes it equivalent to (key ? "false" : "true") in object
}
if (!obj instanceof Ctor) {
// operator precedence makes it equivalent to (!obj) instanceof Ctor
// and it equivalent to always false since boolean values are not objects.
}
複製程式碼
正確 程式碼示例:
/*eslint no-unsafe-negation: "error"*/
if (!(key in object)) {
// key is not in object
}
if (!(obj instanceof Ctor)) {
// obj is not an instance of Ctor
}
if(("" + !key) in object) {
// make operator precedence and type conversion explicit
// in a rare situation when that is the intended meaning
}
複製程式碼
Options 無。
use-isnan
該規則禁止與 ‘NaN’ 的比較。
Rule Details
該規則禁止在正規表示式字面量中出現多個空格。
錯誤 程式碼示例:
/*eslint use-isnan: "error"*/
if (foo == NaN) {
// ...
}
if (foo != NaN) {
// ...
}
複製程式碼
正確 程式碼示例:
/*eslint use-isnan: "error"*/
if (isNaN(foo)) {
// ...
}
if (!isNaN(foo)) {
// ...
}
複製程式碼
valid-typeof
強制 typeof 表示式與有效的字串進行比較
Rule Details
該規則強制 typeof 表示式與有效的字串進行比較。
Options
該規則有一個物件選項:
- "requireStringLiterals": true 要求 typeof 表示式只與字串字面量或其它 typeof 表示式 進行比較,禁止與其它值進行比較。
錯誤 程式碼示例:
/*eslint valid-typeof: "error"*/
typeof foo === "strnig"
typeof foo == "undefimed"
typeof bar != "nunber"
typeof bar !== "function"
複製程式碼
正確 程式碼示例:
/*eslint valid-typeof: "error"*/
typeof foo === "string"
typeof bar == "undefined"
typeof foo === baz
typeof bar === typeof qux
複製程式碼
選項 { "requireStringLiterals": true } 的 錯誤 程式碼示例:
typeof foo === undefined
typeof bar == Object
typeof baz === "strnig"
typeof qux === "some invalid type"
typeof baz === anotherVariable
typeof foo == 5
複製程式碼
選項 { "requireStringLiterals": true } 的 正確 程式碼示例:
typeof foo === "undefined"
typeof bar == "object"
typeof baz === "string"
typeof bar === typeof qux
複製程式碼
no-case-declarations
不允許在 case 子句中使用詞法宣告
Rule Details
該規則旨在避免訪問未經初始化的詞法繫結以及跨 case 語句訪問被提升的函式。
錯誤 程式碼示例:
/*eslint no-case-declarations: "error"*/
/*eslint-env es6*/
switch (foo) {
case 1:
let x = 1;
break;
case 2:
const y = 2;
break;
case 3:
function f() {}
break;
default:
class C {}
}
複製程式碼
正確 程式碼示例:
/*eslint no-case-declarations: "error"*/
/*eslint-env es6*/
// Declarations outside switch-statements are valid
const a = 0;
switch (foo) {
// The following case clauses are wrapped into blocks using brackets
case 1: {
let x = 1;
break;
}
case 2: {
const y = 2;
break;
}
case 3: {
function f() {}
break;
}
case 4:
// Declarations using var without brackets are valid due to function-scope hoisting
var z = 4;
break;
default: {
class C {}
}
}
複製程式碼
no-empty-pattern
禁止使用空解構模式
Rule Details
此規則目的在於標記出在解構物件和陣列中的任何的空模式,每當遇到一個這樣的空模式,該規則就會報告一個問題。
錯誤 程式碼示例:
/*eslint no-empty-pattern: "error"*/
var {} = foo;
var [] = foo;
var {a: {}} = foo;
var {a: []} = foo;
function foo({}) {}
function foo([]) {}
function foo({a: {}}) {}
function foo({a: []}) {}
複製程式碼
正確 程式碼示例:
/*eslint no-empty-pattern: "error"*/
var {a = {}} = foo;
var {a = []} = foo;
function foo({a = {}}) {}
function foo({a = []}) {}
複製程式碼
no-fallthrough
禁止 case 語句落空
Rule Details
該規則旨在消除非故意 case 落空行為。因此,它會標記處沒有使用註釋標明的落空情況。
錯誤 程式碼示例:
/*eslint no-fallthrough: "error"*/
switch(foo) {
case 1:
doSomething();
case 2:
doSomething();
}
複製程式碼
正確 程式碼示例:
/*eslint no-fallthrough: "error"*/
switch(foo) {
case 1:
doSomething();
break;
case 2:
doSomething();
}
function bar(foo) {
switch(foo) {
case 1:
doSomething();
return;
case 2:
doSomething();
}
}
switch(foo) {
case 1:
doSomething();
throw new Error("Boo!");
case 2:
doSomething();
}
switch(foo) {
case 1:
case 2:
doSomething();
}
switch(foo) {
case 1:
doSomething();
// falls through
case 2:
doSomething();
}
複製程式碼
注意,在上面的例子中,最後的 case 語句,不會引起警告,因為沒有可落空的語句了。
Options
該規則接受單個選項引數:
- 設定 commentPattern 選項為一個正規表示式字串,來改變對有意為之的落空註釋的檢索
commentPattern
選項 { "commentPattern": "break[\s\w]*omitted" } 的 正確 程式碼示例:
/*eslint no-fallthrough: ["error", { "commentPattern": "break[\\s\\w]*omitted" }]*/
switch(foo) {
case 1:
doSomething();
// break omitted
case 2:
doSomething();
}
switch(foo) {
case 1:
doSomething();
// caution: break is omitted intentionally
default:
doSomething();
}
複製程式碼
no-global-assign
禁止對原生物件或只讀的全域性物件進行賦值
Rule Details
該規則禁止修改只讀的全域性變數。
ESLint 可以配置全域性變數為只讀。
- Specifying Environments
- Specifying Globals
錯誤 程式碼示例:
/*eslint no-global-assign: "error"*/
Object = null
undefined = 1
複製程式碼
/*eslint no-global-assign: "error"*/
/*eslint-env browser*/
window = {}
length = 1
top = 1
複製程式碼
/*eslint no-global-assign: "error"*/
/*globals a:false*/
a = 1
複製程式碼
正確 程式碼示例:
/*eslint no-global-assign: "error"*/
a = 1
var b = 1
b = 2
複製程式碼
/*eslint no-global-assign: "error"*/
/*eslint-env browser*/
onload = function() {}
複製程式碼
/*eslint no-global-assign: "error"*/
/*globals a:true*/
a = 1
複製程式碼
Options
該規則接受一個 exceptions 選項,可以用來指定允許進行賦值的內建物件列表:
{
"rules": {
"no-global-assign": ["error", {"exceptions": ["Object"]}]
}
}
複製程式碼
no-octal
禁用八進位制字面量
Rule Details
該規則禁用八進位制字面量。
如果 ESLint 是在嚴格模式下解析程式碼,解析器(而不是該規則)會報告錯誤。
錯誤 程式碼示例:
/*eslint no-octal: "error"*/
var num = 071;
var result = 5 + 07;
複製程式碼
正確 程式碼示例:
/*eslint no-octal: "error"*/
var num = "071";
複製程式碼
no-redeclare
禁止多次宣告同一變數
Rule Details
此規則目旨在消除同一作用域中多次宣告同一變數。
錯誤 程式碼示例:
/*eslint no-redeclare: "error"*/
var a = 3;
var a = 10;
複製程式碼
正確 程式碼示例:
/*eslint no-redeclare: "error"*/
var a = 3;
// ...
a = 10;
複製程式碼
Options
該規則有一個選項引數,是個物件,該物件有個布林屬性為 "builtinGlobals"。預設為false。
如果設定為 true,該規則也會檢查全域性內建物件,比如Object、Array、Number…
builtinGlobals
"builtinGlobals" 選項將會在全域性範圍檢查被重新宣告的內建全域性變數。
選項 { "builtinGlobals": true } 的 錯誤 程式碼示例:
/*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
var Object = 0;
複製程式碼
在 browser 環境下,選項 {"builtinGlobals": true} 的 錯誤 程式碼示例:
/*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
/*eslint-env browser*/
var top = 0;
複製程式碼
browser 環境有很多內建的全域性變數(例如,top)。一些內建的全域性變數不能被重新宣告。
注意,當使用 node 或 commonjs 環境 (或 ecmaFeatures.globalReturn,如果使用預設解析器)時,則程式的最大作用域不是實際的全域性作用域,而是一個模組作用域。當出現這種情況時,宣告一個以內建的全域性變數命令的變數,不算是重宣告,只是遮蔽了全域性變數。在這種情況下,應該使用 no-shadow 規則的 "builtinGlobals" 選項。
no-self-assign
禁止自我賦值
Rule Details
該規則旨在消除自身賦值的情況。
錯誤 程式碼示例:
/*eslint no-self-assign: "error"*/
foo = foo;
[a, b] = [a, b];
[a, ...b] = [x, ...b];
({a, b} = {a, x});
複製程式碼
正確 程式碼示例:
/*eslint no-self-assign: "error"*/
foo = bar;
[a, b] = [b, a];
// This pattern is warned by the `no-use-before-define` rule.
let foo = foo;
// The default values have an effect.
[foo = 1] = [foo];
複製程式碼
Options
該規則也有可以檢查屬性的選項。
{
"no-self-assign": ["error", {"props": false}]
}
複製程式碼
- props - 如果為 true,no-self-assign 規則將對屬性的自我賦值發出警告。預設為 false.
props
選項 { "props": true } 的 錯誤 程式碼示例:
/*eslint no-self-assign: [error, {props: true}]*/
// self-assignments with properties.
obj.a = obj.a;
obj.a.b = obj.a.b;
obj["a"] = obj["a"];
obj[a] = obj[a];
複製程式碼
選項 { "props": true } 的 正確 程式碼示例:
/*eslint no-self-assign: [error, {props: true}]*/
// non-self-assignments with properties.
obj.a = obj.b;
obj.a.b = obj.c.b;
obj.a.b = obj.a.c;
obj[a] = obj["a"]
// This ignores if there is a function call.
obj.a().b = obj.a().b
a().b = a().b
// Known limitation: this does not support computed properties except single literal or single identifier.
obj[a + b] = obj[a + b];
obj["a" + "b"] = obj["a" + "b"];
複製程式碼
no-unused-labels
禁用出現未使用過的標
Rule Details
該規則旨在消除未使用過的標籤。
錯誤 程式碼示例:
/*eslint no-unused-labels: "error"*/
A: var foo = 0;
B: {
foo();
}
C:
for (let i = 0; i < 10; ++i) {
foo();
}
複製程式碼
正確 程式碼示例:
/*eslint no-unused-labels: "error"*/
A: {
if (foo()) {
break A;
}
bar();
}
B:
for (let i = 0; i < 10; ++i) {
if (foo()) {
break B;
}
bar();
}
複製程式碼
no-useless-escape
禁用不必要的轉義字元
Rule Details
該規則標記在不改變程式碼行為的情況下可以安全移除的轉義。
錯誤 程式碼示例:
/*eslint no-useless-escape: "error"*/
"\'";
'\"';
"\#";
"\e";
`\"`;
`\"${foo}\"`;
`\#{foo}`;
/\!/;
/\@/;
複製程式碼
正確 程式碼示例:
/*eslint no-useless-escape: "error"*/
"\"";
'\'';
"\x12";
"\u00a9";
"\371";
"xs\u2111";
`\``;
`\${${foo}}`;
`$\{${foo}}`;
/\\/g;
/\t/g;
/\w\$\*\^\./;
複製程式碼
no-delete-var
禁用不必要的轉義字元
Rule Details
該規則禁止對變數使用 delete 操作符。
如果 ESLint 是在嚴格模式下解析程式碼,解析器(而不是該規則)會報告錯誤。
錯誤 程式碼示例:
/*eslint no-delete-var: "error"*/
var x;
delete x;
複製程式碼
no-undef
禁用未宣告的變數,除非它們在 /*global */ 註釋中被提到
Rule Details
對任何未宣告的變數的引用都會引起一個警告,除非顯式地在 /global .../ 註釋中指定,或在 globals key in the configuration file 中指定。另一個常見的用例是,你有意使用定義在其他地方的全域性變數(例如來自 HTML 的指令碼)。
錯誤 程式碼示例:
/*eslint no-undef: "error"*/
var a = someFunction();
b = 10;
複製程式碼
有 global 宣告時,該規則的 正確 程式碼示例:
/*global someFunction b:true*/
/*eslint no-undef: "error"*/
var a = someFunction();
b = 10;
複製程式碼
有 global 宣告時,該規則的 錯誤 程式碼示例:
/*global b*/
/*eslint no-undef: "error"*/
b = 10;
複製程式碼
預設情況下,/*global */ 中宣告的變數是隻讀的,因此對其進行賦值是錯誤的。
Options
- typeof 設定為 true,將對 typeof 中用到的變數發出警告(預設為false)。
typeof
預設選項 { "typeof": false } 的 正確 程式碼示例:
/*eslint no-undef: "error"*/
if (typeof UndefinedIdentifier === "undefined") {
// do something ...
}
複製程式碼
如果想阻止在 typeof 運算中有未申明的變數導致的警告,可以用此項。
選項 { "typeof": true } 的 錯誤 程式碼示例:
/*eslint no-undef: ["error", { "typeof": true }] */
if(typeof a === "string"){}
複製程式碼
有 global 宣告時,選項 { "typeof": true } 的 正確 程式碼示例:
/*global a*/
/*eslint no-undef: ["error", { "typeof": true }] */
if(typeof a === "string"){}
複製程式碼
Environments
為了方便,ESlint 提供了預定義流行類庫和執行時環境暴露的全域性變數的快捷方式。該規則支援這些環境,如 指定 Environments 中列出的。使用如下:
browser
browser 環境下的 正確 程式碼示例:
/*eslint no-undef: "error"*/
/*eslint-env browser*/
setTimeout(function() {
alert("Hello");
});
複製程式碼
Node.js
node 環境下的 正確 程式碼示例:
/*eslint no-undef: "error"*/
/*eslint-env node*/
var fs = require("fs");
module.exports = function() {
console.log(fs);
};
複製程式碼
no-unused-vars
禁止出現未使用過的變數
Rule Details
此規則旨在消除未使用過的變數,方法和方法中的引數名,當發現這些存在,發出警告。
符合下面條件的變數被認為是可以使用的:
- 作為回撥函式
- 被讀取 (var y = x)
- 傳入函式中作為argument物件(doSomething(x))
- 在傳入到另一個函式的函式中被讀取
一個變數僅僅是被賦值為 (var x = 5) 或者是被宣告過,則認為它是沒被考慮使用。
錯誤 程式碼示例:
/*eslint no-unused-vars: "error"*/
/*global some_unused_var*/
// It checks variables you have defined as global
some_unused_var = 42;
var x;
// Write-only variables are not considered as used.
var y = 10;
y = 5;
// A read for a modification of itself is not considered as used.
var z = 0;
z = z + 1;
// By default, unused arguments cause warnings.
(function(foo) {
return 5;
})();
// Unused recursive functions also cause warnings.
function fact(n) {
if (n < 2) return 1;
return n * fact(n - 1);
}
// When a function definition destructures an array, unused entries from the array also cause warnings.
function getY([x, y]) {
return y;
}
複製程式碼
正確 程式碼示例:
/*eslint no-unused-vars: "error"*/
var x = 10;
alert(x);
// foo is considered used here
myFunc(function foo() {
// ...
}.bind(this));
(function(foo) {
return foo;
})();
var myFunc;
myFunc = setTimeout(function() {
// myFunc is considered used
myFunc();
}, 50);
// Only the second argument from the descructured array is used.
function getY([, y]) {
return y;
}
複製程式碼
exported
在 CommonJS 或者 ECMAScript 模組外部,可用 var建立一個被其他模組程式碼引用的變數。你也可以用 /* exported variableName */ 註釋快表明此變數已匯出,因此此變數不會被認為是未被使用過的。
需要注意的是 /* exported */ 在下列情況下是無效的:
- node 或 commonjs 環境
- parserOptions.sourceType 是 module
- ecmaFeatures.globalReturn 為 true
行註釋 // exported variableName 將不起作用,因為 exported 不是特定於行的。
選項 /* exported variableName */ 的 正確 程式碼示例:
/* exported global_var */
var global_var = 42;
複製程式碼
Options
該規則接受一個字串或者對像型別的引數。字串設定正如同 vars 一樣(如下所示)。
配置項的預設值,變數選項是 all,引數的選項是 after-used 。
{
"rules": {
"no-unused-vars": ["error", { "vars": "all", "args": "after-used", "ignoreRestSiblings": false }]
}
}
複製程式碼
vars
此配置項有兩個值:
- all 檢測所有變數,包括全域性環境中的變數。這是預設值。
- local 僅僅檢測本作用域中宣告的變數是否使用,允許不使用全域性環境中的變數。
vars: local
選項 { "vars": "local" } 的 正確 程式碼示例:
/*eslint no-unused-vars: ["error", { "vars": "local" }]*/
/*global some_unused_var */
some_unused_var = 42;
複製程式碼
varsIgnorePattern
這個 varsIgnorePattern 選項指定了不需要檢測的異常:變數名稱匹配正則模式。例如,變數的名字包含 ignored 或者 Ignored。
選項 { "varsIgnorePattern": "[iI]gnored" } 的 正確 程式碼示例:
/*eslint no-unused-vars: ["error", { "varsIgnorePattern": "[iI]gnored" }]*/
var firstVarIgnored = 1;
var secondVar = 2;
console.log(secondVar);
複製程式碼
args
args 選項有三個值:
- after-used - 最後一個引數必須使用。如:一個函式有兩個引數,你使用了第二個引數,ESLint 不會報警告。
- all - 所有命名引數必須使用。
- none - 不檢查引數。
args: after-used
選項 { "args": "after-used" } 的 錯誤 程式碼示例:
/*eslint no-unused-vars: ["error", { "args": "after-used" }]*/
// 1 error
// "baz" is defined but never used
(function(foo, bar, baz) {
return bar;
})();
複製程式碼
選項 { "args": "after-used" } 的 正確 程式碼示例:
/*eslint no-unused-vars: ["error", {"args": "after-used"}]*/
(function(foo, bar, baz) {
return baz;
})();
複製程式碼
args: all
選項 { "args": "all" } 的 錯誤 程式碼示例:
/*eslint no-unused-vars: ["error", { "args": "all" }]*/
// 2 errors
// "foo" is defined but never used
// "baz" is defined but never used
(function(foo, bar, baz) {
return bar;
})();
複製程式碼
args: none
選項 { "args": "none" } 的 正確 程式碼示例:
/*eslint no-unused-vars: ["error", { "args": "none" }]*/
(function(foo, bar, baz) {
return bar;
})();
複製程式碼
ignoreRestSiblings
ignoreRestSiblings 選項是個布林型別 (預設: false)。使用 Rest 屬性 可能會“省略”物件中的屬性,但是預設情況下,其兄弟屬性被標記為 “unused”。使用該選項可以使 rest 屬性的兄弟屬性被忽略。
選項 { "ignoreRestSiblings": true } 的 正確 程式碼示例:
/*eslint no-unused-vars: ["error", { "ignoreRestSiblings": true }]*/
// 'type' is ignored because it has a rest property sibling.
var { type, ...coords } = data;
複製程式碼
argsIgnorePattern
argsIgnorePattern 選項指定排除不需要檢測:這些引數的名字元合正則匹配。例如,下劃線開頭的變數。
選項 { "argsIgnorePattern": "^_" } 的 正確 程式碼示例:
/*eslint no-unused-vars: ["error", { "argsIgnorePattern": "^_" }]*/
function foo(x, _y) {
return x + 1;
}
foo();
複製程式碼
caughtErrors
caughtErrors 選項被用來驗證 catch 塊的引數。
它有兩個設定:
- none - 不檢查錯誤物件。這是預設設定。
- all - 所有引數必須被使用。
caughtErrors: none 沒有指定該規則,相當於將它賦值為 none。
選項 { "caughtErrors": "none" } 的 正確 程式碼示例:
/*eslint no-unused-vars: ["error", { "caughtErrors": "none" }]*/
try {
//...
} catch (err) {
console.error("errors");
}
複製程式碼
caughtErrors: all
選項 { "caughtErrors": "all" } 的 錯誤 程式碼示例:
/*eslint no-unused-vars: ["error", { "caughtErrors": "all" }]*/
// 1 error
// "err" is defined but never used
try {
//...
} catch (err) {
console.error("errors");
}
複製程式碼
caughtErrorsIgnorePattern
caughtErrorsIgnorePattern 選項指定例外情況,不會檢查匹配正規表示式 catch 引數。例如,名字以 ‘ignore’ 開頭的變數。
選項 { "caughtErrorsIgnorePattern": "^ignore" } 的 正確 程式碼示例:
/*eslint no-unused-vars: ["error", { "caughtErrorsIgnorePattern": "^ignore" }]*/
try {
//...
} catch (ignoreErr) {
console.error("errors");
}
複製程式碼
no-mixed-spaces-and-tabs
禁止空格和 tab 的混合縮排
Rule Details
該規則禁止使用 空格 和 tab 混合縮排。
錯誤 程式碼示例:
/*eslint no-mixed-spaces-and-tabs: "error"*/
function add(x, y) {
// --->..return x + y;
return x + y;
}
function main() {
// --->var x = 5,
// --->....y = 7;
var x = 5,
y = 7;
}
複製程式碼
正確 程式碼示例:
/*eslint no-mixed-spaces-and-tabs: "error"*/
function add(x, y) {
// --->return x + y;
return x + y;
}
複製程式碼
Options
該規則有一個字串選項。
- "smart-tabs" 當 tab 是為了對齊,允許混合使用空格和 tab。
smart-tabs
選項 "smart-tabs" 的 正確 程式碼示例:
/*eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
function main() {
// --->var x = 5,
// --->....y = 7;
var x = 5,
y = 7;
}
複製程式碼
constructor-super
要求在建構函式中有 super() 的呼叫
Rule Details
該規則旨在標記無效或缺失的 super() 呼叫。
錯誤 程式碼示例:
/*eslint constructor-super: "error"*/
/*eslint-env es6*/
class A {
constructor() {
super(); // This is a SyntaxError.
}
}
class A extends B {
constructor() { } // Would throw a ReferenceError.
}
// Classes which inherits from a non constructor are always problems.
class A extends null {
constructor() {
super(); // Would throw a TypeError.
}
}
class A extends null {
constructor() { } // Would throw a ReferenceError.
}
複製程式碼
正確 程式碼示例:
/*eslint constructor-super: "error"*/
/*eslint-env es6*/
class A {
constructor() { }
}
class A extends B {
constructor() {
super();
}
}
複製程式碼
no-class-assign
禁止修改類宣告的變數
Rule Details
該規則旨在標記類宣告中變數的修改情況。
錯誤 程式碼示例:
/*eslint no-class-assign: "error"*/
/*eslint-env es6*/
class A { }
A = 0;
複製程式碼
/*eslint no-class-assign: "error"*/
/*eslint-env es6*/
A = 0;
class A { }
複製程式碼
/*eslint no-class-assign: "error"*/
/*eslint-env es6*/
class A {
b() {
A = 0;
}
}
複製程式碼
/*eslint no-class-assign: "error"*/
/*eslint-env es6*/
let A = class A {
b() {
A = 0;
// `let A` is shadowed by the class name.
}
}
複製程式碼
正確 程式碼示例:
/*eslint no-class-assign: "error"*/
/*eslint-env es6*/
let A = class A { }
A = 0; // A is a variable.
複製程式碼
/*eslint no-class-assign: "error"*/
/*eslint-env es6*/
let A = class {
b() {
A = 0; // A is a variable.
}
}
複製程式碼
/*eslint no-class-assign: 2*/
/*eslint-env es6*/
class A {
b(A) {
A = 0; // A is a parameter.
}
}
複製程式碼
no-const-assign
禁止修改 const 宣告的變數
Rule Details
該規則旨在標記修改用const關鍵字宣告的變數。
錯誤 程式碼示例:
/*eslint no-const-assign: "error"*/
/*eslint-env es6*/
const a = 0;
a = 1;
複製程式碼
/*eslint no-const-assign: "error"*/
/*eslint-env es6*/
const a = 0;
a += 1;
複製程式碼
/*eslint no-const-assign: "error"*/
/*eslint-env es6*/
const a = 0;
++a;
複製程式碼
正確 程式碼示例:
/*eslint no-const-assign: "error"*/
/*eslint-env es6*/
const a = 0;
console.log(a);
複製程式碼
/*eslint no-const-assign: "error"*/
/*eslint-env es6*/
for (const a in [1, 2, 3]) { // `a` is re-defined (not modified) on each loop step.
console.log(a);
}
複製程式碼
/*eslint no-const-assign: "error"*/
/*eslint-env es6*/
for (const a of [1, 2, 3]) { // `a` is re-defined (not modified) on each loop step.
console.log(a);
}
複製程式碼
no-dupe-class-members
禁止類成員中出現重複的名稱
Rule Details
該規則旨在標記類成員中重複名稱的使用。
錯誤 程式碼示例:
/*eslint no-dupe-class-members: "error"*/
/*eslint-env es6*/
class Foo {
bar() { }
bar() { }
}
class Foo {
bar() { }
get bar() { }
}
class Foo {
static bar() { }
static bar() { }
}
複製程式碼
正確 程式碼示例:
/*eslint no-dupe-class-members: "error"*/
/*eslint-env es6*/
class Foo {
bar() { }
qux() { }
}
class Foo {
get bar() { }
set bar(value) { }
}
class Foo {
static bar() { }
bar() { }
}
複製程式碼
no-new-symbol
禁止 Symbolnew 操作符和 new 一起使用
Rule Details
該規則旨在阻止使用 new 操作符呼叫 Symbol。
錯誤 程式碼示例:
/*eslint no-new-symbol: "error"*/
/*eslint-env es6*/
var foo = new Symbol('foo');
複製程式碼
正確 程式碼示例:
/*eslint no-new-symbol: "error"*/
/*eslint-env es6*/
var foo = Symbol('foo');
// Ignores shadowed Symbol.
function bar(Symbol) {
const baz = new Symbol("baz");
}
複製程式碼
no-this-before-super
禁止在建構函式中,在呼叫 super() 之前使用 this 或 super
Rule Details
該規則旨在標記出在呼叫 super() 之前使用 this 或 super 的情況。
錯誤 程式碼示例:
/*eslint no-this-before-super: "error"*/
/*eslint-env es6*/
class A extends B {
constructor() {
this.a = 0;
super();
}
}
class A extends B {
constructor() {
this.foo();
super();
}
}
class A extends B {
constructor() {
super.foo();
super();
}
}
class A extends B {
constructor() {
super(this.foo());
}
}
複製程式碼
正確 程式碼示例:
/*eslint no-this-before-super: "error"*/
/*eslint-env es6*/
class A {
constructor() {
this.a = 0; // OK, this class doesn't have an `extends` clause.
}
}
class A extends B {
constructor() {
super();
this.a = 0; // OK, this is after `super()`.
}
}
class A extends B {
foo() {
this.a = 0; // OK. this is not in a constructor.
}
}
複製程式碼