Javascript

Recipes

• Disallow awaiting non-promise values.

• Disallow classes that only have static members.

• Disallow comparing undefined using typeof.

• Disallow else blocks after return statements in if statements

• Disallow equal signs explicitly at the beginning of regular expressions

• Disallow if statements as the only statement in else blocks

• Disallow initializing variables to undefined

• Disallow member access from await expression.

• Disallow negated conditions.

• Disallow nested ternary expressions.

• Disallow new Array().

• Disallow number literals with zero fractions or dangling dots.

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

• Disallow redundant return statements

• Disallow renaming import, export, and destructured assignments to the same name

• Disallow returning/yielding Promise.resolve()/reject() in async functions or promise callbacks.

• Disallow shorthand type conversions

• Disallow ternary operators when simpler alternatives exist

• Disallow the use of Math.pow in favor of the ** operator

• Disallow the use of the null literal.

• Disallow unnecessary calls to .bind()

• Disallow unnecessary computed property keys in objects and classes

• Disallow unnecessary labels

• Disallow unnecessary spread.

• Disallow unreadable array destructuring.

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

• Disallow useless array length check.

• Disallow useless fallback when spreading in object literals.

• Disallow useless undefined.

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

• Disallow using the this argument in array methods.

• Do not use a for loop that can be replaced with a for-of loop.

• Do not use leading/trailing space between console.log parameters.

• Enforce a convention in module import order

• Enforce a newline after import statements

• Enforce a particular style for multiline comments

• Enforce a specific parameter name in catch clauses.

• Enforce better string content.

• Enforce combining multiple Array#push() into one call.

• Enforce consistent brace style for all control statements

• Enforce consistent brace style for case clauses.

• Enforce consistent case for text encoding identifiers.

• Enforce consistent relative URL style.

• Enforce correct Error subclassing.

• Enforce dot notation whenever possible

• Enforce explicitly comparing the length or size property of a value.

• Enforce no spaces between braces.

• Enforce or ban the use of inline type-only markers for named imports

• Enforce or disallow capitalization of the first letter of a comment

• Enforce proper case for numeric literals.

• Enforce sorted import declarations within modules

• Enforce the style of numeric separators by correctly grouping digits.

• Enforce the use of Buffer.from() and Buffer.alloc() instead of the deprecated new Buffer().

• Enforce the use of Math.trunc() instead of bitwise operators.

• Enforce the use of Unicode escapes instead of hexadecimal escapes.

• Enforce the use of new for all builtins, except String, Number, Boolean, Symbol, and BigInt.

• Enforce throwing TypeError in type checking conditions.

• Enforce using the digits argument with Number#toFixed().

• Enforce using the separator argument with Array#join().

• Enforce variables to be declared either together or separately in functions

• Ensure all imports appear before other statements

• Fix whitespace-insensitive template indentation.

• Forbid empty named import

• Forbid import of modules using absolute paths

• Forbid import statements with CommonJS module.exports

• Forbid importing packages through relative paths

• Forbid namespace (a.k.a. "wildcard" *) imports.

• Forbid repeated import of the same module in multiple places

• Forbid unnecessary path segments in import and require statements

• Improve regexes by making them shorter, consistent, and safer.

• Prefer .addEventListener() and .removeEventListener() over on-functions.

• Prefer .at() method for index access and String#charAt().

• Prefer .before() over .insertBefore(), .replaceWith() over .replaceChild(), prefer one of .before(), .after(), .append() or .prepend() over insertAdjacentText() and insertAdjacentElement().

• Prefer .find() and .findLast() over the first or last element from .filter().

• Prefer .flatMap() over .map().flat().

• Prefer .includes() over .indexOf() and Array#some() when checking for existence or non-existence.

• Prefer .querySelector() over .getElementById(), .querySelectorAll() over .getElementsByClassName() and .getElementsByTagName().

• Prefer .some() over .filter().length check and .{find,findLast}().

• Prefer Array#flat() over legacy techniques to flatten arrays.

• Prefer Array#{indexOf,lastIndexOf}() over Array#{findIndex,findLastIndex}() when looking for the index of an item.

• Prefer Date.now() to get the number of milliseconds since the Unix Epoch.

• Prefer JavaScript modules (ESM) over CommonJS.

• Prefer KeyboardEvent#key over KeyboardEvent#keyCode.

• Prefer Node#append() over Node#appendChild().

• Prefer Number static properties over global ones.

• Prefer Reflect.apply() over Function#apply().

• Prefer RegExp#test() over String#match() and RegExp#exec().

• Prefer Set#has() over Array#includes() when checking for existence or non-existence.

• Prefer String#replaceAll() over regex searches with the global flag.

• Prefer String#slice() over String#substr() and String#substring().

• Prefer String#startsWith() & String#endsWith() over RegExp#test().

• Prefer String#trimStart() / String#trimEnd() over String#trimLeft() / String#trimRight().

• Prefer borrowing methods from the prototype instead of the instance.

• Prefer childNode.remove() over parentNode.removeChild(childNode).

• Prefer default parameters over reassignment.

• Prefer export…from when re-exporting.

• Prefer for…of over the forEach method.

• Prefer modern Math APIs over legacy patterns.

• Prefer negative index over .length - index when possible.

• Prefer omitting the catch binding parameter.

• Prefer reading a JSON file as a buffer.

• Prefer switch over multiple else-if.

• Prefer ternary expressions over simple if-else statements.

• Prefer the spread operator over Array.from(), Array#concat(), Array#{slice,toSpliced}() and String#split('').

• Prefer using .dataset on DOM elements over calling attribute methods.

• Prefer using Object.fromEntries() to transform a list of key-value pairs into an object.

• Prefer using Set#size instead of Array#length.

• Prefer using String, Number, BigInt, Boolean, and Symbol directly.

• Prefer using the node: protocol when importing Node.js builtin modules.

• Prevent abbreviations.

• Require Array.isArray() instead of instanceof Array.

• Require braces around arrow function bodies

• Require const declarations for variables that are never reassigned after declared

• Require destructuring from arrays and/or objects

• Require escape sequences to use uppercase values.

• Require let or const instead of var

• Require new when throwing an error.

• Require or disallow "Yoda" conditions

• Require or disallow Unicode byte order mark (BOM)

• Require or disallow assignment operator shorthand where possible

• Require or disallow logical assignment operator shorthand

• Require or disallow method and property shorthand syntax for object literals

• Require or disallow strict mode directives

• Require template literals instead of string concatenation

• Require the use of === and !==

• Require using arrow functions for callbacks

• Require variables within the same declaration block to be sorted

• Use destructured variables over properties.