JSHint - JavaScript Static Analysis Tool

Common errors

• 'variableName' is not defined. (E008)

  cause A variable was used without being declared, or it's a global variable not explicitly defined in JSHint's globals option.
  fix Declare the variable using `var`, `let`, or `const`. If it's a global, add it to your `.jshintrc` `globals` array (e.g., `"globals": { "jQuery": true }`) or pass it in the `globals` argument when calling `JSHINT` programmatically.

• Missing semicolon. (W033)

  cause JSHint expects a semicolon at the end of a statement, following JavaScript's Automatic Semicolon Insertion (ASI) rules but enforcing explicit semicolons.
  fix Add a semicolon (`;`) at the end of the problematic statement. You can configure JSHint to be more lenient with semicolons using the `asi` option (e.g., `"asi": true`) or disable the warning for unused expressions (`"expr": true`).

• Expected an identifier and instead saw 'keyword'. (E002)

  cause This often occurs when using newer ECMAScript keywords (e.g., `const`, `let`, `async`, `await`) without enabling the appropriate ECMAScript version in JSHint options.
  fix Update your JSHint configuration to specify the target ECMAScript version using the `esversion` option (e.g., `"esversion": 2017` for `async/await`). Ensure your JSHint version itself supports the desired ES version.

• Too many errors. (E043)

  cause JSHint stopped linting after encountering a large number of errors to prevent excessive output, often indicating a fundamental issue or misconfiguration.
  fix Address the initial errors reported by JSHint. This error is a threshold, not a specific syntax problem. Once some errors are fixed, JSHint will process more of the file. Check your `maxerr` option if you intentionally expect many errors.

Warnings

• gotcha JSHint's development has significantly slowed, with the last major update in late 2022. For new projects, or those requiring support for the latest ECMAScript features (ES2023+), JSX, or TypeScript, more actively maintained alternatives like ESLint are generally preferred due to their extensibility and ecosystem.
  Fix: Consider migrating to ESLint for projects requiring modern JavaScript features, plugin ecosystems, or TypeScript support. ESLint offers broader community support and more frequent updates.
• gotcha JSHint does not natively support TypeScript or JSX. Attempting to lint such files will likely result in numerous parsing errors.
  Fix: Use dedicated linters for TypeScript (e.g., ESLint with `@typescript-eslint/parser`) or JSX (e.g., ESLint with `eslint-plugin-react`). JSHint is strictly for JavaScript.
• gotcha The primary programmatic interface for JSHint uses CommonJS modules (`require`). Direct ESM `import` statements for `jshint` might not work as expected in all Node.js environments without transpilation or specific bundler configurations.
  Fix: When using JSHint programmatically in Node.js, stick to CommonJS `require` statements. For browser environments, include `jshint.js` via a `<script>` tag or use a bundler.
• breaking The `shelljs` dependency was removed in JSHint v2.13.4. While this primarily affected JSHint's internal build process, any user who might have implicitly relied on `shelljs` being a transient dependency of `jshint` could experience issues if they upgrade and `shelljs` is no longer available.
  Fix: Ensure `shelljs` is explicitly listed as a direct dependency in your project's `package.json` if your code has a direct reliance on it, rather than depending on transitive dependencies.

Install

• npm install jshint npm
• yarn add jshint yarn
• pnpm add jshint pnpm

Imports

• JSHINT
  wrong:

  import { JSHINT } from 'jshint';

  correct:

  const { JSHINT } = require('jshint');

  JSHint is primarily a CommonJS module. While bundlers can handle ESM imports, direct Node.js ESM usage for programmatic linting is not the standard or officially supported way for the core library.
• cli
  wrong:

  require('jshint').cli.run()

  correct:

  npx jshint your-file.js

  The primary way to use JSHint is via its command-line interface, typically invoked through `npx` or a globally installed package. Direct programmatic access to the CLI runner is not a documented API for users.
• JSHINT.data()

  const result = JSHINT(code, options, globals); const data = JSHINT.data();

  After running JSHINT on code, detailed analysis data (e.g., global variables, functions) can be accessed via `JSHINT.data()`.

Quickstart

Demonstrates programmatic usage of JSHint to lint a JavaScript string, configured for a Node.js environment, and prints any detected errors or warnings.

const { JSHINT } = require('jshint');

const javascriptCode = `
function greet(name) {
    console.log('Hello, ' + name)
    // Missing semicolon here intentionally
}

const myName = 'World';
greet(myName);

// A variable not defined in this scope
undefinedVar = 1;
`;

// JSHint options: enforce strict mode, allow console
const options = {
    strict: true,
    browser: false, // For Node.js environment
    node: true,     // For Node.js globals like console
    undef: true     // Warn if variables are used without being declared
};

// Lint the code
JSHINT(javascriptCode, options);

// Log any errors found
if (JSHINT.errors.length > 0) {
    console.log('JSHint found issues:');
    JSHINT.errors.forEach(error => {
        if (error) {
            console.error(`  Line ${error.line}, Col ${error.character}: ${error.reason} (${error.code})`);
        }
    });
} else {
    console.log('No JSHint issues found.');
}