Code Inspections in JavaScript

Runs JSLint validator for specified JavaScript file.

Runs Closure Linter that enforces the guidelines set by the Google JavaScript Style Guide. The linter handlesstyle issues so that you can focus on the code.

Runs ESLint validator for specified JavaScript file.

The severity level of the inspection is applied only for the 'Inspect code...' action.Severity levels used in the editor can be configured in the ESLint configuration file for each individual rule.

This inspection is for ability to suppress irrelevant JavaScript errors like assignment to const, continue without loop, e.t.c.
Generally, this is not required, but there may be cases when such errors are unexpectedly reported due to dynamic nature of JavaScriptor bugs in IDE's annotator implementation.

Checks JavaScript called functions to be valid ones.The validation works in JavaScript, html or jsp files.

Checks JavaScript source code for unneeded semicolons.The validation works in JavaScript, html or jsp files.

Reports when a trailing comma is used in object literals in JavaScript code.

The warning is reported only when the JavaScript language version is set to JavaScript 1.8.5, ECMAScript 3 or 5.1.

Trailing commas in object literals are allowed according to these specifications, however, some browsers might throw an error when a trailing comma is used.

You can configure formatting options for trailing commas in Code Style | JavaScript or TypeScript | Punctuation.

Checks JavaScript for unused assignments.The validation works in JavaScript, ActionScript, HTML and JSP files.

Checks JavaScript called function arguments, return values, assigned expressions to be of correct type.The validation works in JavaScript, html or jsp files.

Checks JavaScript declaration to be declared once in current scope.The validation works in JavaScript, html, or jsp files.

Checks for using deprecated JavaScript functions and variables.The validation works in JavaScript, html, or jsp files.

This inspection reports JavaScript potentially invalid indexed property access such as Array[1].The validation works in JavaScript, html, or jsp files.

Warns against a common mistake of trying to reference a member of an ECMAScript class via this. qualifier in a nested function that is not a lambda.
this in a nested function that is not a lambda is the function's own 'this' and doesn't relate to the outer class.

Checks JavaScript parameter, local variable, function, classes and private member declarationsto be used in given file scope.The validation works in JavaScript, ActionScript, HTML and JSP files.

Missing await call for an async function can produce unexpected behaviour.

Highlights functions that were possibly intended to be async but are missing the async modifier.

This inspection highlights arrow functions where the body contains exactly one statement and can be converted to concise syntax without braces.

let incrementer = (x) => {return x + 1};

let incrementer = (x) => x + 1;

Warns if bind is used together with arrow function.
Since arrow functions use lexical this, bind call will have no effect on them.
Please read more here.

Reports when require() is used and helps to replace the require() call with the import statement.

Enable Convert require() inside inner scopes with Fix all actionto convert all require() calls inside the nested functions and statements when using the Fix all action.

Please note that converting the require() statements inside inner scopes to the import statementsmay cause changes in the semantics of the code.Import statements are static module dependencies and are hoisted,which means that they are moved to the top of the current module. require() calls load modules dynamically.They can be executed conditionally and their scope is defined by the expression in which they are used.
Clear Convert require() inside inner scopes with Fix all action option to prevent any changes in these complex cases when using Fix all action.

Helps to replace function expressions with arrow functions.

Converts for..inloops on arrays to for..of loops.
for..of loops, introduced in ECMAScript 6, iterate over iterable objects.For arrays, this construction should be preferred to for..in, since it is executed only for array values and not for array object's properties.

Checks if JavaScript public functions, variables, classes, and properties are used in global scope.The validation works in JavaScript, ActionScript, HTML and JSP files.

Checks that URL of an external JavaScript library is associated witha locally stored file used for code completion and navigation.
Use 'Download library' quick fix (Alt+Enter) to solve the problem.

This inspection reports suspicious usages of bitwise AND ("&") and OR ("|") operators.Usually it is a common typo and user expect a result according to the boolean operations AND ("&&") and OR ("||").

This inspection reports assignments to undefined properties of explicitly type-annotated variables.

Checks for improper usage of wrappers for JavaScript primitive types. Also, warning will be produced when property of primitive type ismodified, as assigned value will be lost.

Checks that jQuery selectors are used in an efficient way.It warns about duplicated selectors which could be cached and optionally about attribute and pseudo-selectors usage.

Checks that function recognized as constructor does not return primitive values.When called with new, this value will be lost and object will be returned instead. To avoid warnings, you can explicitly specifyfunction's return type with @return tag.

Checks that array literal doesn't contain consecutive commas. Skipped element takes undefined value,but it could be done unintentionally, e.g. when commas are at the end of one line and at the beginning of the following.

This inspection reports JavaScript accesses to DOM nodes as text using the innerHTML property. Most uses of innerHTML are better performed using explicit DOM calls such as getElementByID() and createElement() . Additionally, innerHTML will not work with XML DOMs, including DOMs for XHTML if viewed as XML. This can lead to difficult to diagnose bugs.

This inspection reports common JavaScript DOM patterns which may present problems with XHTML documents. In particular, the patterns detected will behave completely differently depending on whether the document is loaded as XML or HTML. This can result in subtle bugs where script behaviour is dependent on the MIME-type of the document, rather than its content. Patterns detected include document.body , document.images , document.applets , document.links , document.forms , and document.anchors .

This inspection reports any instances of for , while , or do statements which can only exit by throwing an exception. While such statements may be correct, they are often a symptom of coding errors.

This inspection reports any instances of pointless or pointlessly complicated boolean expressions in JavaScript content. Such expressions include anding with true, oring with false, equality comparison with a boolean literal, or negation of a boolean literal. Such expressions may be the result of automated refactorings not completely followed through to completion, and in any case are unlikely to be what the developer intended to do.

This inspection reports any instances of if statements in JavaScript content which contain else branches and whose conditions are negated. Flipping the order of the if and else branches will usually increase the clarity of such statements.

This inspection reports any break statements in Javascript content. break statements that end case blocks are not reported.

This inspection reports any continue statements in Javascript content.

This inspection reports any instances of JavaScript switch statements where the default casecomes before some other case. This construct is unnecessarily confusing.

This inspection reports on any unnecessary return statements in JavaScript functions. Unnecessary return statements are those which return no value and occur just before the function would have "fallen through" to the bottom. These statements may be safely removed.

This inspection reports any labelled continue statements in Javascript content whose labels may be removed without changing the flow of control.

This inspection reports any switch statements in Javascript content which lack default branches. Such statements may result in difficult bugs, if unexpected cases are silently ignored

This inspection reports any switch statements in Javascript content which are nested in other switch statements. Such nested switch statements can be very confusing, particularly if proper indenting is not followed.

This inspection reports any instances of conditional expressions of the form true?result1:result2 or false?result1:result2 .These expressions sometimes occur as the result of automatic refactorings, and may obviously be simplified.

This inspection reports any instances of ternary conditional expressions with identical "then" and "else" branches in JavaScript content. Such statements are almost certainly programmer error.

This inspection reports any instances of JavaScript conditional expressions of the form condition?true:false or condition?false:true . These expressions may be safely simplified to condition or !condition , respectively.

This inspection reports any instances of JavaScript for loops where the condition or update does not use the for loop variable.

This inspection reports any instances of JavaScript for loopswhich contain neither initialization or update components, and can thus be replaced bysimpler while statements.

Use the checkbox below if you wish this inspection to ignore for loops with trivial or non-existent conditions.

This inspection reports any instances of JavaScript assignment expressions nested inside other expressions. While admirably terse,such expressions may be confusing, and violate the general design priniciple that a given construct should do precisely one thing.

This inspection reports any assignments of the form x = x in JavaScript content. These are pointless, and usually indicate programmer error.

This inspection reports on any uses in JavaScript code of the non-short-circuit forms of boolean 'and' and 'or' ( & and | ). The non-short-circuit versions are occasionally useful, buttheir presence is often due to typos of the short-circuit forms ( && and || ), and may lead to subtle bugs.

This inspection reports any instances of division by zero or remainder by zero in JavaScript code.

This inspection reports JavaScript 'debugger' statements, used for interaction with Javascript debuggers. Such statements should probably not be found in production code.

This inspection reports any duplicated case labels on JavaScript switch statements. Such switch statements are normally an indication of programmer error.

This inspection reports any instances of JavaScript functions which return a value in some circumstances and return without a value in others. While legal, such code almost certainly represents a programming error

This inspection reports on any uses of JavaScript reserved words being used as a name. The JavaScript specificationreserves a number of words which are currently not used as JavaScript keywords. Using those words as identifiers mayresult in broken code if later versions of JavaScript use them as keywords.

This inspection reports on any uses of the caller property in a JavaScript function.Use of this property to access the stack frame of the calling method can be extremely confusing, and result in subtle bugs.

This inspection reports ternary conditional expressions. Some coding standards prohibit such expressions, in favor of explicit if statements.

This inspection reports ternary conditional expressions contained within other ternary conditions. Such nested conditionals may be extremely confusing, and best replaced by more explicit conditional logic.

This inspection reports any with statements in Javascript content. with statements result in potentially confusing implicit bindings, and may behave strangely in setting new variables.

This inspection reports JavaScript functions nested inside other functions. While JavaScript allows functions to be nested, such constructs may be confusing. Additionally, nested functions are prone to cause difficult-to-diagnose memory leaks in certain browsers, including Microsoft Internet Explorer.

Use the checkbox below to prevent this inspection from reporting anonymous nested functions.

This inspection reports instances of JavaScript if , while , for , and with statements whose bodies are empty. While occasionally useful, such statements are often the result of typos, and may cause confusion.

Use the checkbox below to select whether statements whose bodies are empty block statements will be reported by this inspection.

This inspection reports any JavaScript floating point numbers which do not have a decimal point, numbers before the decimal point,and numbers after the decimal point. Such literals may be confusing, and violate several coding standards.

This inspection reports on any uses of the eval , setTimeout , setInterval functions, or allocation of a Function object in JavaScript. These functions are used to execute arbitrary strings of JavaScript text, often dynamically generated. This can be very confusing, and may be a security risk.

This inspection reports any empty catch blocks in Javascript content. Empty catch blocks are a sign that errors are simply being ignored, rather than properly handled.

This inspection reports any empty finally blocks in Javascript content. Empty finally are usually the result of a coding error.

This inspection reports any instances of throw statements inside of finally blocks. While occasionally intended, such throw statements may mask exceptions thrown, and tremendously complicate debugging.

This inspection reports any instances of JavaScript throw statements whose exceptions are always caught by containing try statements. Using throw statements as a "goto" to change the local flow of control is likely to be confusing.

This inspection reports on comparison operations with constant values on their left-hand side. Some coding conventions specify that constants should be on the right-hand side of comparisons.

This inspection reports any JavaScript function calls whose target is another function call.

This inspection reports on comparison operations with constant values on their right-hand side. Some coding conventions specify that constants should be on the left-hand side of comparisons.

This inspection reports instances of JavaScript if , while , for , and with statements whose bodies are not block statements. While such statements are legal JavaScript, it is usually safer for downstream maintenance to use the code blocks for statement bodies.

This inspection reports JavaScript functions with three or more negation operations ( ! or != ). Such functions may be unnecessarily confusing.

This inspection reports any instances of JavaScript functions have multiple return points. Some coding standards warn against functions with multiple returns, as they may make functions more difficult to understand and maintain.

This inspection reports any instances of unnecessary JavaScript local variables, which addnothing to the comprehensibility of a function. Variables caught include local variableswhich are immediately returned, local variables that are immediately assigned to anothervariable and then not used, and local variables which always have the same value as anotherlocal variable or parameter.

Use the checkbox below to have this inspection ignore variables which are immediatelyreturned or thrown. Some coding styles suggest using such variables for clarity andease of debugging.

This inspection reports any instances of pointless bitwiseexpressions in JavaScript. Such expressions include and ing with zero, ori ng by zero,and shift by zero. Such expressions may be the result of automated refactoringsnot completely followed through to completion, and in any case are unlikely to be what the developerintended to do.

This inspection reports any instances of JavaScript bitwise mask expressions which are guaranteed toevaluate to true or false in JavaScript code.Expressions checked are of the form (var & constant1) == constant2 or (var | constant1) == constant2 , where constant1 and constant2 are incompatible bitmask constants.

Reports unresolved file references in JavaScript files, including CommonJS and AMD modules references.

Inside an AMD module definition, checks that all used modules are specified as dependencies.

Suggests inserting the module dependency.

Works only in files in the scope of "HTML" JavaScript library.

Reports names containing non-ASCII symbols.

If 'Allow only ASCII names' option is used, reports all names containing non-ASCII symbols.
Otherwise reports all names, containing both ASCII and non-ASCII symbols.

Checks whether the module in the "require()" call or import statement exists, whether it is listed in package.json dependencies, and whether it is locally installed.

Suggests installing the module and/or including it into package.json.

For require() calls, works only in files in the scope of "Node.js Core" JavaScript library.

Checks that JavaScript files are in strict mode.

Checks that there’s a .flowconfig file in the project that covers a JavaScript file with the // @flow flag.

Checks that the // @flow flag is located on the top of the file – otherwise this file will not be checked by Flow.

Reports dependencies in package.json that are not installed or don't match the specified version range.

Suggests configuring coding assistance for Node.js core modules.