eslintのルールで気になったもの
recommendedで有効にならないもの

eslint - Possible Problems

https://eslint.org/docs/rules/#possible-problems

array-callback-return

配列のmapメソッドのコールバックで必ず return する

• "allowImplicit" : boolean
  デフォルト: false
return の値を省略した場合は undefined を返す
• "checkForEach" : boolean
  デフォルト: false
forEach メソッドで return しない

constructor-super

派生クラスではコンストラクターで必ず super() を呼び出す

• eslint:recommended で error

for-direction

for ループではループ変数をカウントアップさせて条件式を正しく終了するようにする

• eslint:recommended で error

getter-return

ゲッターで retrun する

• "allowImplicit": boolean
  デフォルト: false
return の値を省略した場合は undefined を返す

• eslint:recommended で error

no-async-promise-executor

Promise コンストラクターの関数に async キーワードを使わない

• eslint:recommended で error

[no-await-in-loop]

ループ内で await しない

[no-class-assign]

クラス宣言した変数に再代入しない

[no-compare-neg-zero]

-0 と === で比較しない

[no-cond-assign]

if for while 文の条件式で代入をしない

[no-const-assign]

const 宣言した変数に再代入しない

[no-constant-binary-expression]

変数、|| && ?? 演算子で常に true か常に false に評価される式を許さない

[no-constant-condition]

if for while 文、三項演算子の条件式で常に true か常に false に評価される式を許さない

[no-constructor-return]

コンストラクターで値を return しない

[no-control-regex]

正規表現で 0x00 から 0x1F までの文字コードエスケープを使わない

[no-debugger]

debugger 文を使わない

[no-dupe-args]

function 定義で引数の変数名を重複させない

no-dupe-class-members

クラス宣言でメンバー名を重複させない

no-dupe-else-if

if else if 文で条件式を重複させない

no-dupe-keys

オブジェクトリテラルでキーを重複させない

no-duplicate-case

switch 文で case を重複させない

no-duplicate-imports

import 文で同じモジュールから複数回インポートしない

no-empty-character-class

正規表現で空の文字クラス [] を許さない

no-empty-pattern

デストラクチャーでパターンを空にしない

no-ex-assign

catch 文で例外の変数に再代入しない

no-fallthrough

switch 文の case 節でフォールスルーをしない

no-func-assign

関数宣言した変数に再代入しない

no-import-assign

インポートした変数に再代入しない

no-inner-declarations

var 変数と関数をプログラムと関数のルート以外で宣言しない

no-invalid-regexp

RegExp コンストラクターで不正な正規表現を許さない

no-irregular-whitespace

タブとスペース以外の空白文字を使わない

no-loss-of-precision

倍精度浮動小数点数で精度を失う数値リテラルを使わない

no-misleading-character-class

正規表現の文字クラスで複数のコードポイントでできた文字を使わない

no-new-symbol

Symbol オブジェクトは new 演算子を使わない

no-obj-calls

Math JSON Reflect Atomics オブジェクトなどを関数として呼び出ししない

no-promise-executor-return

Promise コンストラクターの関数で return しない

no-prototype-builtins

Object.prototype のメソッドを直接呼び出さない

no-self-assign

まったく同じ変数に再代入しない

no-self-compare

まったく同じ変数を比較しない

no-setter-return

セッター関数で return しない

no-sparse-arrays

配列リテラルで値を省略してまばらな配列を作らない

no-template-curly-in-string

文字列リテラルでテンプレートリテラルのプレークスホルダー記法を使わない

no-this-before-super

コンストラクターで super() を呼び出す前に this super キーワードを使わない

no-undef

宣言されていない変数を使わない

no-unexpected-multiline

セミコロンなしで文が終わることを期待したとき、期待しないで続くような文を書かない

no-unmodified-loop-condition

ループ内で条件式の変数を変更する

no-unreachable

return throw continue break 文の後に実行されないコードを書かない

no-unreachable-loop

1回までしか実行しないループを書かない

no-unsafe-finally

finally ブロックで return throw continue break文を使わない

no-unsafe-negation

in instanceof 演算子の左辺で ! 演算子を使わない

no-unsafe-optional-chaining

undefined が許可されていないとき ?. 演算子を使わない

no-unused-private-class-members

使っていないプライベートメンバーを書かない

no-unused-vars

使っていない変数を書かない

no-use-before-define

変数を定義する前に使わない

no-useless-backreference

正規表現で常に空になる後方参照を使わない

require-atomic-updates

await yield を使った変更はアトミック(不可分な操作)にする

use-isnan

変数が NaN かどうか調べるために isNaN() 関数を使用する

valid-typeof

typeof 演算子との比較は決まった文字列にする

Suggestions

https://eslint.org/docs/rules/#suggestions

accessor-pairs

ゲッター関数とセッター関数が対になるようにする

arrow-body-style

アロー関数の本体に中括弧をつける

block-scoped-var

ブロックスコープの中で var 宣言した変数をブロックスコープの外で使わない

camelcase

命名をキャメルケースにする

capitalized-comments

コメントの最初の文字を大文字で書く

class-methods-use-this

クラスの静的でないメソッドの中で必ず this を使う

complexity

関数の循環的複雑度の上限を設定する

consistent-return

同じ関数の中で return が値を返すか返さないかを統一する

consistent-this

現在の this をキャプチャーするためのエイリアスを統一する

curly

if else for while 文でブロック文を使う

default-case

switch 文の中で default 節を書く

default-case-last

switch 文の中で default 節は最後に書く

default-param-last

関数の引数リストでデフォルト引数は最後に書く

dot-notation

プロパティアクセサーでブラケット表記法 [] の代わりにドット表記法 . が使えるなら使う

eqeqeq

等値比較で厳密同値演算子 === !== を使う

func-name-matching

名前付き function 式を変数に代入するとき関数名と変数名を揃える

func-names

function 式を名前付きにする

func-style

関数の定義に function 宣言と function 式でどちらかに統一する

grouped-accessor-pairs

同じプロパティのゲッター関数とセッター関数を隣り合わせる

guard-for-in

for-in ループの中で Object.prototype.hasOwnProperty を使ってフィルタリングする

id-denylist

指定した識別子を使わない

id-length

識別子の文字数を制限する

id-match

識別子を指定した正規表現にマッチするものにする

init-declarations

変数を宣言した時に初期化する

max-classes-per-file

１つのファイルでクラス定義の上限を設定する

max-depth

コードブロックのネスト数の上限を設定する

max-lines

１つのファイルで行数の上限を設定する

max-lines-per-function

関数の中で行数の上限を設定する

max-nested-callbacks

コールバック関数のネスト数の上限を設定する

max-params

関数の引数の数の上限を設定する

max-statements

関数の中で文の数の上限を設定する

multiline-comment-style

複数行のコメントの書き方を統一する

new-cap

new 演算子で使うコンストラクターは大文字で始める

no-alert

alert confirm prompt 関数を使わない

no-array-constructor

Array コンストラクターを使わない

no-bitwise

ビット演算子を使わない

no-caller

arguments.caller arguments.callee を使わない

no-case-declarations

switch 文の case 節で変数の宣言をしない

no-confusing-arrow

比較演算子と間違われるようなアロー演算子を使わない

no-console

console オブジェクトを使わない

no-continue

continue 文を使わない

no-delete-var

delete 文で変数を削除しない

no-div-regex

除算演算子と間違われるような正規表現リテラルを使わない

no-else-return

if 文で return した後に else 文を使わない

no-empty

空のブロック文を書かない

no-empty-function

空の関数を書かない

no-eq-null

null と比較 == null != null をしない

no-eval

eval() 関数を使わない

no-extend-native

組み込みオブジェクトを拡張しない

no-extra-bind

this を使わない関数やアロー関数で不要な .bind() メソッドの呼び出しをしない

no-extra-boolean-cast

disallow unnecessary boolean casts

no-extra-boolean-cast

条件式で不要な論理型へ型変換をしない

no-extra-label

ネストされていないループや switch 文で不要なラベルを使わない

no-extra-semi

不要なセミコロンを書かない

no-floating-decimal

小数は常にドットの前後ともに数字を書く

no-global-assign

組み込みのグローバル変数に代入しない

no-implicit-coercion

型変換のショートハンドを使わない

no-implicit-globals

グローバル変数を宣言しない

no-implied-eval

eval() のような関数 setTimeout() setInterval() execScript() を文字列を渡して使わない

no-inline-comments

コードと同じ行にコメントを書かない

no-invalid-this

this が undefined の可能性があるとき this を使わない

no-iterator

オブジェクトの __iterator__ プロパティを使わない

no-label-var

変数とラベルを同じ名前にしない

no-labels

ラベル付き文を使わない

no-lone-blocks

不要なブロック文を使わない

no-lonely-if

else ブロックの中で if 文１つだけ書くことをしない

no-loop-func

ループの中で外側の変数を使った関数を定義しない

no-magic-numbers

マジックナンバーを使わない

no-mixed-operators

論理演算子 && || を混ぜて使わない

no-multi-assign

連鎖した代入をしない

no-multi-str

\ を使用した複数行の文字列を使わない

no-negated-condition

if-else や三項演算子で否定的な条件式を使わない

no-nested-ternary

三項演算子をネストしない

no-new

代入しない所で new operators演算子を使わない

no-new-func

disallow new operators with the Function object

no-new-object

disallow Object constructors

no-new-wrappers

disallow new operators with the String, Number, and Boolean objects

no-nonoctal-decimal-escape

disallow \8 and \9 escape sequences in string literals

no-octal

disallow octal literals

no-octal-escape

disallow octal escape sequences in string literals

no-param-reassign

disallow reassigning function parameters

no-plusplus

disallow the unary operators ++ and --

no-proto

disallow the use of the __proto__ property

no-redeclare

disallow variable redeclaration

no-regex-spaces

disallow multiple spaces in regular expressions

no-restricted-exports

disallow specified names in exports

no-restricted-globals

disallow specified global variables

no-restricted-imports

disallow specified modules when loaded by import

no-restricted-properties

disallow certain properties on certain objects

no-restricted-syntax

disallow specified syntax

no-return-assign

disallow assignment operators in return statements

no-return-await

disallow unnecessary return await

no-script-url

disallow javascript: urls

no-sequences

disallow comma operators

no-shadow

disallow variable declarations from shadowing variables declared in the outer scope

no-shadow-restricted-names

disallow identifiers from shadowing restricted names

no-ternary

disallow ternary operators

no-throw-literal

disallow throwing literals as exceptions

no-undef-init

disallow initializing variables to undefined

no-undefined

disallow the use of undefined as an identifier

no-underscore-dangle

disallow dangling underscores in identifiers

no-unneeded-ternary

disallow ternary operators when simpler alternatives exist

no-unused-expressions

disallow unused expressions

no-unused-labels

disallow unused labels

no-useless-call

disallow unnecessary calls to .call() and .apply()

no-useless-catch

disallow unnecessary catch clauses

no-useless-computed-key

disallow unnecessary computed property keys in objects and classes

no-useless-concat

disallow unnecessary concatenation of literals or template literals

no-useless-constructor

disallow unnecessary constructors

no-useless-escape

disallow unnecessary escape characters

no-useless-rename

disallow renaming import, export, and destructured assignments to the same name

no-useless-return

disallow redundant return statements

no-var

require let or const instead of var

no-void

disallow void operators

no-warning-comments

disallow specified warning terms in comments

no-with

disallow with statements

object-shorthand

require or disallow method and property shorthand syntax for object literals

one-var

enforce variables to be declared either together or separately in functions

one-var-declaration-per-line

require or disallow newlines around variable declarations

operator-assignment

require or disallow assignment operator shorthand where possible

prefer-arrow-callback

require using arrow functions for callbacks

prefer-const

require const declarations for variables that are never reassigned after declared

prefer-destructuring

require destructuring from arrays and/or objects

prefer-exponentiation-operator

disallow the use of Math.pow in favor of the ** operator

prefer-named-capture-group

enforce using named capture group in regular expression

prefer-numeric-literals

disallow parseInt() and Number.parseInt() in favor of binary, octal, and hexadecimal literals

prefer-object-has-own

disallow use of Object.prototype.hasOwnProperty.call() and prefer use of Object.hasOwn()

prefer-object-spread

disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.

prefer-promise-reject-errors

require using Error objects as Promise rejection reasons

prefer-regex-literals

disallow use of the RegExp constructor in favor of regular expression literals

prefer-rest-params

require rest parameters instead of arguments

prefer-spread

require spread operators instead of .apply()

prefer-template

require template literals instead of string concatenation

quote-props

require quotes around object literal property names

radix

enforce the consistent use of the radix argument when using parseInt()

require-await

disallow async functions which have no await expression

require-unicode-regexp

enforce the use of u flag on RegExp

require-yield

require generator functions to contain yield

sort-imports

enforce sorted import declarations within modules

sort-keys

require object keys to be sorted

sort-vars

require variables within the same declaration block to be sorted

spaced-comment

enforce consistent spacing after the // or /* in a comment

strict

require or disallow strict mode directives

symbol-description

require symbol descriptions

vars-on-top

require var declarations be placed at the top of their containing scope

yoda

require or disallow "Yoda" conditions

デフォルト: [ ["+", "-", "*", "/", "%", "**"], ["&", "|", "^", "~", "<<", ">>", ">>>"], ["==", "!=", "===", "!==", ">", ">=", "<", "<="], ["&&", "||"], ["in", "instanceof"], ]