ESLint 推薦的rules收集

mton95發表於2019-02-02

EsLint

筆者花了一個下午的時間把 ESLint 推薦的 rules 進行了總結。把官網rules打勾的部分寫成了 MD 文件，並把每個 rules 裡面的說明和示例也搞出來放一起了。在這裡把它貢獻出來。

部落格維護在git上，歡迎給一個star!!! https://github.com/mtonhuang/blog

no-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')

複製程式碼

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.
    }
}
複製程式碼

redis常用demo收集(二)——基於redis的簡單使用者協同推薦
2018-07-21
Redis
Mahout的taste推薦系統引擎（影片推薦案例）
2024-04-04
AST
【推薦演算法】推薦系統的評估
2024-12-03
演算法
[推薦]
2020-02-05
好用的工具推薦
2024-08-09
推薦系統應該如何保障推薦的多樣性？
2019-11-13
求推薦
2018-06-28
GPT 推薦
2024-05-13
GPT
推薦序
2019-09-20
商品推薦
2021-07-16
ChatGPT的外掛推薦
2023-03-09
ChatGPT
學習Django的推薦
2021-06-12
Django
固執的推薦引擎
2021-02-09
【院校推薦】計算機考研“易推倒”的211院校推薦（三）
2018-10-29
計算機
Rust中的macro_rules
2024-10-14
RustMac
推薦系統論文之序列推薦：KERL
2021-05-17
大家有推薦的go方面的i18n的庫嗎，求推薦
2018-06-29
Go
基於物件特徵的推薦
2018-12-12
物件特徵
推薦好用的JavaScript模組
2018-12-18
JavaScript
推薦：好用的 Laravel Repository 包
2018-07-04
Laravel
推薦幾個好用的工具
2023-04-19
【推薦】好用的 XPath 外掛
2020-11-22
強烈推薦的軟體
2020-04-07
Golang 推薦的命名規範
2019-02-19
Golang
便宜的SSL證書推薦
2022-11-24
賽爾推薦
2018-05-28
副業推薦
2024-05-13
推薦書目
2024-08-09
DDD文章推薦
2021-12-14
Spotify 每週推薦功能：基於機器學習的音樂推薦
2019-02-27
機器學習
雲音樂推薦系統（二）：推薦系統的核心演算法
2020-11-11
演算法
只推薦一本 JavaScript 書，你推薦哪本？
2020-07-05
JavaScript
【推薦系統篇】--推薦系統之訓練模型
2018-03-26
模型
一些個人認為值得推薦的IT程式設計技術社群、部落格或文章收集與分享
2018-06-19
程式設計
工具推薦｜2020年最值得推薦的10款UI動效設計工具
2020-01-16
UI
為什麼有人不推薦使用spring官方推薦的@Transactional宣告式註解
2022-06-30
Spring
推薦 vue2、vue3 中功能最強大的表格元件，效能最強大的表格元件推薦、可編輯表格推薦
2024-11-21
Vue元件
react router為什麼推薦使用browserHistory而不推薦hashHistory？
2020-04-05
React

ESLint 推薦的rules收集

no-compare-neg-zero

no-cond-assign

no-console

no-constant-condition

no-control-regex

no-debugger

no-dupe-args

no-dupe-keys

no-duplicate-case

no-empty

no-empty-character-class

no-ex-assign

no-extra-boolean-cast

no-extra-semi

no-func-assign

no-inner-declarations

no-invalid-regexp

no-irregular-whitespace

no-obj-calls

no-regex-spaces

no-sparse-arrays

no-unexpected-multiline

no-unreachable

no-unsafe-finally

no-unsafe-negation

use-isnan

valid-typeof

no-case-declarations

no-empty-pattern

no-fallthrough

no-global-assign

no-octal

no-redeclare

no-self-assign

no-unused-labels

no-useless-escape

no-delete-var

no-undef

no-unused-vars

no-mixed-spaces-and-tabs

constructor-super

no-class-assign

no-const-assign

no-dupe-class-members

no-new-symbol

no-this-before-super

相關文章