jslint

JSLint, The JavaScript Code Quality and Coverage Tool

3,654

473

3,654

View on GitHub View on NPM

Top Related Projects

jslint

3,654

JSLint, The JavaScript Code Quality and Coverage Tool

eslint

27,571

Find and fix problems in your JavaScript code.

jshint

9,078

JSHint is a tool that helps to detect errors and potential problems in your JavaScript code

standard

29,425

🌟 JavaScript Style Guide, with linter & automatic code fixer

prettier

52,385

Prettier is an opinionated code formatter.

Quick Overview

JSLint is a static code analysis tool for JavaScript, created by Douglas Crockford. It scans JavaScript code for potential errors, coding style violations, and suspicious constructs, helping developers write cleaner and more reliable code.

Pros

Helps maintain consistent coding style across projects
Identifies potential errors and problematic patterns early in development
Encourages best practices and safer coding habits
Can be integrated into various development environments and build processes

Cons

Some developers find its rules too strict or opinionated
May require configuration adjustments to fit specific project needs
Can produce false positives in certain scenarios
Limited customization options compared to some other linting tools

Code Examples

Basic usage:

// Assuming JSLint is available as a global function
var source = "var x = 1; // This is a comment";
var result = JSLINT(source);

if (result) {
    console.log("No errors found.");
} else {
    console.log("Errors found:");
    console.log(JSLINT.errors);
}

Using JSLint with Node.js:

const jslint = require('jslint');

const source = "function add(a, b) { return a + b; }";
const options = { node: true };

const result = jslint(source, options);

if (result.ok) {
    console.log("No errors found.");
} else {
    console.log("Errors found:", result.warnings);
}

Configuring JSLint options:

// Set JSLint options
JSLINT.config({
    browser: true,
    devel: true,
    plusplus: true
});

var source = "for (var i = 0; i < 10; i++) { console.log(i); }";
var result = JSLINT(source);

console.log(result ? "No errors" : "Errors found");

Getting Started

To use JSLint in your project:

Install JSLint via npm:
```
npm install jslint
```

Create a JavaScript file (e.g., lint.js) with the following content:

const jslint = require('jslint');
const fs = require('fs');

const source = fs.readFileSync('your-file.js', 'utf8');
const result = jslint(source);

if (result.ok) {
    console.log("No errors found.");
} else {
    console.log("Errors found:");
    result.warnings.forEach(warning => {
        console.log(`Line ${warning.line}: ${warning.message}`);
    });
}

Run the linter:
```
node lint.js
```

This will lint the specified file and output any errors or warnings found by JSLint.

Competitor Comparisons

jslint

3,654

JSLint, The JavaScript Code Quality and Coverage Tool

Pros of jslint

More actively maintained with recent updates
Includes additional features and improvements
Better documentation and examples

Cons of jslint

Potentially less stable due to frequent changes
May have compatibility issues with older projects
Steeper learning curve for new users

Code Comparison

jslint:

function lint(source, options) {
    "use strict";
    let warnings;
    options = Object.assign(Object.create(null), options);
    warnings = jslint_core(source, options);
    return {
        warnings,
        options,
        directives: options.directives
    };
}

jslint>:

function lint(source, options) {
    var warnings;
    options = Object.create(options || {});
    warnings = jslint_core(source, options);
    return {
        warnings: warnings,
        options: options,
        directives: options.directives
    };
}

The main differences in the code are:

Use of "use strict" in jslint
ES6 features like let and object shorthand in jslint
More modern JavaScript syntax in jslint overall

Both repositories serve the same primary purpose of providing a JavaScript linting tool, but jslint appears to be more up-to-date and feature-rich, while jslint> might be more suitable for projects requiring older JavaScript syntax or greater stability.

eslint

27,571

Find and fix problems in your JavaScript code.

Pros of ESLint

Highly configurable with numerous rules and plugins
Supports modern JavaScript features and frameworks
Active development and large community support

Cons of ESLint

Steeper learning curve due to extensive configuration options
Can be slower than JSLint for large codebases
Requires more setup and maintenance

Code Comparison

JSLint:

/*jslint browser: true, devel: true */
(function () {
    "use strict";
    // Your code here
}());

ESLint:

/* eslint-env browser, node */
/* eslint-disable no-console */
(() => {
  'use strict';
  // Your code here
})();

Key Differences

JSLint is more opinionated and less flexible
ESLint offers more customization and modern JavaScript support
JSLint focuses on enforcing good practices, while ESLint allows for team-specific preferences

Community and Ecosystem

ESLint has a larger ecosystem with numerous plugins and integrations
JSLint has a smaller but dedicated user base
ESLint is more widely adopted in modern JavaScript development

Performance

JSLint is generally faster for small to medium-sized projects
ESLint's performance can be optimized with careful configuration
Both tools can be integrated into CI/CD pipelines for automated linting

jshint

9,078

JSHint is a tool that helps to detect errors and potential problems in your JavaScript code

Pros of JSHint

More flexible and configurable than JSLint
Supports a wider range of JavaScript coding styles
Actively maintained with regular updates

Cons of JSHint

Less strict than JSLint, potentially allowing some code quality issues
Can be more complex to set up due to numerous configuration options
May produce more false positives in certain scenarios

Code Comparison

JSLint (more strict):

function example(a, b) {
    "use strict";
    return a + b;
}

JSHint (more flexible):

function example(a, b) {
    // JSHint allows omitting "use strict"
    return a + b;
}

JSLint enforces stricter coding standards, such as requiring "use strict" in functions, while JSHint allows for more flexibility in coding style. JSHint's configuration options enable developers to customize the linting rules to match their project's specific needs, whereas JSLint follows a more opinionated approach with fewer customization options.

Both tools aim to improve code quality and catch potential errors, but they differ in their philosophy and implementation. JSLint focuses on enforcing a specific coding style, while JSHint provides more flexibility for developers to define their own standards.

standard

29,425

🌟 JavaScript Style Guide, with linter & automatic code fixer

Pros of Standard

More active development and community support
Supports modern JavaScript features and syntax
Includes automatic code formatting capabilities

Cons of Standard

Less configurable than JSLint
May be too opinionated for some developers
Larger package size and potentially slower performance

Code Comparison

JSLint:

/*jslint browser */
function example() {
    var x = 1;
    return x;
}

Standard:

function example () {
  const x = 1
  return x
}

Standard enforces a more modern JavaScript style, including:

No semicolons (optional)
const instead of var
Spaces after function names
No JSLint-style directives

Both tools aim to enforce consistent coding styles, but Standard takes a more opinionated approach with less configuration options. JSLint offers more granular control over rules but may be less suited for modern JavaScript development. Standard's popularity and active community make it a strong choice for many projects, while JSLint's simplicity and focus on strict code quality may appeal to developers seeking a more traditional linting experience.

prettier

52,385

Prettier is an opinionated code formatter.

Pros of Prettier

Supports a wider range of languages and file types
Highly configurable with extensive options
Integrates well with various editors and IDEs

Cons of Prettier

Can be opinionated, sometimes forcing unwanted formatting
May require more setup and configuration than JSLint
Slower performance on large codebases compared to JSLint

Code Comparison

JSLint:

function example(x) {
    if (x) {
        return true;
    } else {
        return false;
    }
}

Prettier:

function example(x) {
  if (x) {
    return true;
  } else {
    return false;
  }
}

Key Differences

JSLint focuses on JavaScript linting, while Prettier is a code formatter for multiple languages
JSLint enforces strict coding standards, whereas Prettier primarily focuses on consistent formatting
Prettier automatically reformats code, while JSLint provides warnings and errors without modifying the code

Use Cases

JSLint: Best for projects requiring strict JavaScript code quality checks
Prettier: Ideal for teams wanting consistent code formatting across various languages and file types

Community and Ecosystem

Prettier has a larger and more active community
JSLint has been around longer but has a smaller, more focused user base
Prettier offers more integrations with modern development tools and workflows

javascript

148,035

JavaScript Style Guide

Pros of JavaScript

More comprehensive and modern style guide, covering ES6+ features
Actively maintained with frequent updates and community contributions
Includes explanations and examples for each rule, enhancing understanding

Cons of JavaScript

More complex and potentially overwhelming for beginners
May require additional configuration and setup in projects
Some rules might be opinionated and not universally agreed upon

Code Comparison

JSLint:

/*jslint browser */
function example(x) {
    'use strict';
    return x + 1;
}

JavaScript:

// airbnb-style
const example = (x) => {
  return x + 1;
};

Key Differences

JSLint focuses on strict error checking and enforcing a specific coding style
JavaScript provides a more flexible and comprehensive set of guidelines
JSLint is more prescriptive, while JavaScript allows for some customization
JavaScript includes rules for modern JavaScript features and best practices
JSLint has a simpler setup, while JavaScript may require additional tools like ESLint

Use Cases

JSLint: Suitable for quick code quality checks and enforcing a strict coding style
JavaScript: Ideal for teams looking for a comprehensive, modern JavaScript style guide and linting rules

Community and Ecosystem

JSLint has a smaller, more focused community
JavaScript has a larger ecosystem with various tools and extensions built around it

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

JSLint, The JavaScript Code Quality and Coverage Tool

Douglas Crockford douglas@crockford.com

Status

Branch	master (v2026.9.29)	beta (Web Demo)	alpha (Development)
CI
Coverage
Demo
Artifacts

Web Demo

https://www.jslint.com

Web Demo Archived

Quickstart Install
Quickstart JSLint Report
- To create a JSLint report in shell:
- To create a JSLint report in javascript:
Quickstart V8 Coverage Report
- To create V8 coverage report from Node.js / Npm program in shell:
- To create V8 coverage report from Node.js / Npm program in javascript:
Quickstart JSLint in CodeMirror
Quickstart JSLint in Vim
Quickstart JSLint in VSCode
Documentation
Package Listing
Changelog
License
Devops Instruction

Quickstart Install

To install, just download and save https://www.jslint.com/jslint.mjs to file:

#!/bin/sh

curl -L https://www.jslint.com/jslint.mjs > jslint.mjs

shell output

screenshot

To run `jslint.mjs` in shell:

#!/bin/sh

printf "console.log('hello world');\n" > hello.js

node jslint.mjs hello.js

shell output

screenshot

To import `jslint.mjs` in ES Module environment:

#!/bin/sh

node --input-type=module --eval '

/*jslint devel*/

// Import JSLint in ES Module environment.

import jslint from "./jslint.mjs";

let globals = ["caches", "indexedDb"];
let options = {browser: true};
let result;
let source = "console.log(\u0027hello world\u0027);\n";

// JSLint <source> and print <formatted_message>.

result = jslint.jslint(source, options, globals);
result.warnings.forEach(function ({
    formatted_message
}) {
    console.error(formatted_message);
});

'

shell output

screenshot

To import `jslint.mjs` in CommonJS environment:

#!/bin/sh

node --eval '

/*jslint devel*/
(async function () {
    let globals = ["caches", "indexedDb"];
    let jslint;
    let options = {browser: true};
    let result;
    let source = "console.log(\u0027hello world\u0027);\n";

// Import JSLint in CommonJS environment.

    jslint = await import("./jslint.mjs");
    jslint = jslint.default;

// JSLint <source> and print <formatted_message>.

    result = jslint.jslint(source, options, globals);
    result.warnings.forEach(function ({
        formatted_message
    }) {
        console.error(formatted_message);
    });
}());

'

shell output

screenshot

To JSLint entire directory in shell:

#!/bin/sh

# JSLint directory '.'

node jslint.mjs .

shell output

screenshot

Quickstart JSLint Report

To create a JSLint report in shell:

#!/bin/sh

printf "function foo() {console.log('hello world');}\n" > hello.js

# Create JSLint report from file 'hello.js' in shell.

node jslint.mjs \
    jslint_report=.artifact/jslint_report_hello.html \
    hello.js

shell output

screenshot

screenshot file .artifact/jslint_report_hello.html

To create a JSLint report in javascript:

#!/bin/sh

node --input-type=module --eval '

/*jslint devel*/
import jslint from "./jslint.mjs";
import fs from "fs";
(async function () {
    let result;
    let source = "function foo() {console.log(\u0027hello world\u0027);}\n";

// Create JSLint report from <source> in javascript.

    result = jslint.jslint(source);
    result = jslint.jslint_report(result);
    result = `<body class="JSLINT_ JSLINT_REPORT_">\n${result}</body>\n`;

    await fs.promises.mkdir(".artifact/", {recursive: true});
    await fs.promises.writeFile(".artifact/jslint_report_hello.html", result);
    console.error("wrote file .artifact/jslint_report_hello.html");
}());

'

shell output

screenshot

screenshot file .artifact/jslint_report_hello.html

Quickstart V8 Coverage Report

To create V8 coverage report from Node.js / Npm program in shell:

#!/bin/sh

git clone https://github.com/tryghost/node-sqlite3 node-sqlite3-sh \
    --branch=v5.0.11 \
    --depth=1 \
    --single-branch

cd node-sqlite3-sh
npm install

# Create V8 coverage report from program `npm run test` in shell.

node ../jslint.mjs \
    v8_coverage_report=../.artifact/coverage_sqlite3_sh/ \
        --exclude=tes?/ \
        --exclude=tes[!0-9A-Z_a-z-]/ \
        --exclude=tes[0-9A-Z_a-z-]/ \
        --exclude=tes[^0-9A-Z_a-z-]/ \
        --exclude=test/**/*.js \
        --exclude=test/suppor*/*elper.js \
        --exclude=test/suppor?/?elper.js \
        --exclude=test/support/helper.js \
        --include=**/*.cjs \
        --include=**/*.js \
        --include=**/*.mjs \
        --include=li*/*.js \
        --include=li?/*.js \
        --include=lib/ \
        --include=lib/**/*.js \
        --include=lib/*.js \
        --include=lib/sqlite3.js \
    npm run test

shell output

screenshot

screenshot file .artifact/coverage_sqlite3_sh/index.html

screenshot file .artifact/coverage_sqlite3_sh/lib/sqlite3.js.html

To create V8 coverage report from Node.js / Npm program in javascript:

#!/bin/sh

git clone https://github.com/tryghost/node-sqlite3 node-sqlite3-js \
    --branch=v5.0.11 \
    --depth=1 \
    --single-branch

cd node-sqlite3-js
npm install

node --input-type=module --eval '

/*jslint node*/
import jslint from "../jslint.mjs";
(async function () {

// Create V8 coverage report from program `npm run test` in javascript.

    await jslint.v8CoverageReportCreate({
        coverageDir: "../.artifact/coverage_sqlite3_js/",
        processArgv: [
            "--exclude=tes?/",
            "--exclude=tes[!0-9A-Z_a-z-]/",
            "--exclude=tes[0-9A-Z_a-z-]/",
            "--exclude=tes[^0-9A-Z_a-z-]/",
            "--exclude=test/**/*.js",
            "--exclude=test/suppor*/*elper.js",
            "--exclude=test/suppor?/?elper.js",
            "--exclude=test/support/helper.js",
            "--include=**/*.cjs",
            "--include=**/*.js",
            "--include=**/*.mjs",
            "--include=li*/*.js",
            "--include=li?/*.js",
            "--include=lib/",
            "--include=lib/**/*.js",
            "--include=lib/*.js",
            "--include=lib/sqlite3.js",
            "npm", "run", "test"
        ]
    });
}());

'

shell output

screenshot

screenshot file .artifact/coverage_sqlite3_js/index.html

screenshot file .artifact/coverage_sqlite3_js/lib/sqlite3.js.html

Quickstart JSLint in CodeMirror

Download and save jslint.mjs, jslint_wrapper_codemirror.js to file.
Edit, save, and serve example html-file below:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>CodeMirror: JSLint Demo</title>

<!-- Assets from codemirror. -->

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.21/codemirror.css">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.21/addon/lint/lint.css">
    <script defer src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.21/codemirror.js"></script>
    <script defer src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.21/mode/javascript/javascript.js"></script>
    <script defer src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.21/addon/lint/lint.js"></script>

<!-- Assets from jslint. -->

    <script type="module" src="./jslint.mjs?window_jslint=1"></script>
    <script defer src="./jslint_wrapper_codemirror.js"></script>
<style>
body {
    background: #bbb;
    color: #333;
    font-family: sans-serif;
    margin: 20px;
}
.JSLINT_.JSLINT_REPORT_ {
    margin-top: 20px;
}
#editor1 {
    height: 300px;
    width: 100%;
}
</style>
</head>


<body>
    <h1>CodeMirror: JSLint Demo</h1>
    <h3>
This demo will auto-lint the code below, and auto-generate a report as you type.
    </h3>

<!-- Container for codemirror-editor. -->

    <textarea id="editor1">console.log('hello world');</textarea>

<!-- Container for jslint-report. -->

    <div class="JSLINT_ JSLINT_REPORT_"></div>


<script type=module>
window.addEventListener("load", function () {
    let editor = window.CodeMirror.fromTextArea(document.getElementById(
        "editor1"
    ), {
        gutters: [
            "CodeMirror-lint-markers"
        ],
        indentUnit: 4,
        lineNumbers: true,
        lint: {
            lintOnChange: true, // Enable auto-lint.
            options: {
                // browser: true,
                // node: true
                globals: [
                    // "caches",
                    // "indexedDb"
                ]
            }
        },
        mode: "javascript"
    });

// Initialize event-handling before linter is run.

    editor.on("lintJslintBefore", function (/* options */) {
        // options.browser = true;
        // options.node = true;
        // options.globals = [
        //     "caches",
        //     "indexedDb"
        // ];
        return;
    });

// Initialize event-handling after linter is run.

    editor.on("lintJslintAfter", function (options) {

// Generate jslint-report from options.result.

        document.querySelector(
            ".JSLINT_REPORT_"
        ).innerHTML = window.jslint.jslint_report(options.result);
    });

// Manually trigger linter.

    editor.performLint();
});
</script>
</body>
</html>

Live example at https://www.jslint.com/jslint_wrapper_codemirror.html

Quickstart JSLint in Vim

Download and save jslint.mjs, jslint_wrapper_vim.vim to directory ~/.vim/
Add vim-command :source ~/.vim/jslint_wrapper_vim.vim to file ~/.vimrc
- If above files were saved to custom-directory, then use that directory instead, e.g.:
  - save jslint.mjs, jslint_wrapper_vim.vim to directory ~/vimfiles/
  - vim-command :source ~/vimfiles/jslint_wrapper_vim.vim
Vim can now jslint files (via nodejs):
- with vim-command :SaveAndJslint
- with vim-key-combo <Ctrl-S> <Ctrl-J>

screenshot

Quickstart JSLint in VSCode

In VSCode, search and install extension vscode-jslint
In VSCode, while editing a javascript file:
- right-click context-menu and select [JSLint - Lint File]
- or use key-binding [Ctrl + Shift + J], [L]
- or use key-binding [ Cmd + Shift + J], [L] for Mac

screenshot

Documentation

jslint.mjs contains the jslint function. It parses and analyzes a source file, returning an object with information about the file. It can also take an object that sets options.
index.html runs the jslint.mjs function in a web page.

API Doc

https://www.jslint.com/apidoc.html

Directive

`/jslint beta/`

/*jslint beta*/
// Enable experimental warnings.
// Warn if global variables are redefined.
// Warn if const / let statements are not declared at top of function or
//    script, similar to var statements.
// Warn if const / let / var statements are not declared in ascii-order.
// Warn if named-functions are not declared in ascii-order.
// Warn if cases in switch-statements are not in ascii-order.

`/jslint bitwise/`

/*jslint bitwise*/
// Allow bitwise operator.

let foo = 0 | 1;

`/jslint browser/`

/*jslint browser*/
// Assume browser environment.

localStorage.getItem("foo");

`/jslint convert/`

/*jslint convert*/
// Allow conversion operator.

let foo = new Date() + "";
let bar = !!0;

`/jslint couch/`

/*jslint couch*/
// Assume CouchDb environment.

registerType("text-json", "text/json");

`/jslint devel/`

/*jslint devel*/
// Allow console.log() and friends.

console.log("hello");

`/jslint eval/`

/*jslint eval*/
// Allow eval().

eval("1");

`/jslint fart/`

/*jslint fart*/
// Allow complex fat-arrow.

let foo = async ({bar, baz}) => {
    return await bar(baz);
};

`/jslint getset/`

/*jslint getset, this, devel*/
// Allow get() and set().

let foo = {
    bar: 0,
    get getBar() {
        return this.bar;
    },
    set setBar(value) {
        this.bar = value;
    }
};
console.log(foo.getBar); // 0
foo.setBar = 1;
console.log(foo.getBar); // 1

`/jslint indent2/`

/*jslint indent2*/
// Use 2-space indent.

function foo() {
  return;
}

`/jslint long/`

/*jslint long*/
// Allow long lines.

let foo = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

`/jslint node/`

/*jslint node*/
// Assume Node.js environment.

require("fs");

`/jslint nomen/`

/*jslint nomen*/
// Allow weird property name.

let foo = {};
foo._bar = 1;

`/jslint single/`

/*jslint single*/
// Allow single-quote strings.

let foo = '';

`/jslint subscript/`

/*jslint subscript*/
// Allow identifiers in subscript-notation.

let foo = {};
foo["bar"] = 1;

`/jslint this/`

/*jslint this*/
// Allow 'this'.

function foo() {
    return this;
}

`/jslint trace/`

/*jslint trace*/
// Include jslint stack-trace in warnings.

console.log('hello world');
/*
1. Undeclared 'console'.
console.log('hello world');
Error
    at warn_at (...)
    at warn (...)
    at lookup (...)
    at pre_v (...)
    at jslint.mjs
2. Use double quotes, not single quotes.
console.log(...);
Error
    at warn_at (...)
    at lex_string (...)
    at lex_token (...)
    at jslint_phase2_lex (...)
    at Function.jslint (...)
    at jslint.mjs
*/

`/jslint unordered/`

/*jslint unordered*/
// Allow unordered cases, params, properties, variables, and exports.

let foo = {bb: 1, aa: 0};

function bar({
    bb = 1,
    aa = 0
}) {
    return aa + bb;
}

export {
    foo,
    bar
};

`/jslint white/`

/*jslint white*/
// Allow messy whitespace.

let foo = 1; let bar = 2;

`/global/`

/*global foo, bar*/
// Declare global variables foo, bar.

foo();
bar();

`/property/`

/*property foo, bar*/
// Restrict property-access to only .foo, .bar.

let aa = {bar: 1, foo: 2};

`/jslint-disable/.../jslint-enable/`

/*jslint-disable*/

JSLint will ignore and treat this region as blank-lines.
Syntax error.

/*jslint-enable*/

`//jslint-ignore-line`

// JSLint will ignore non-fatal warnings at given line.

eval("1"); //jslint-ignore-line

`/coverage-disable/.../coverage-enable/`

/*coverage-disable*/

// JSLint will ignore code-coverage in this region.

if (false) {
    console.log("hello world");
}

/*coverage-enable*/

`//coverage-ignore-line`

// JSLint will ignore code-coverage at given line.

if (false) {
    console.log("hello world"); //coverage-ignore-line
}

ECMAScript Feature Support

#.	JSLint Support	ES Version	ES Feature
99.	â	ES2027	`Explicit Resource Management`
98.	â	ES2027	`Atomics.pause`
97.	â	ES2027	`Joint Iteration`
96.	â	ES2027	`Temporal`
95.	â	ES2026	`Upsert`
94.	â	ES2026	`JSON.parse source text access`
93.	â	ES2026	`Iterator Sequencing`
92.	â	ES2026	`Uint8Array to/from Base64`
91.	â	ES2026	`Math.sumPrecise`
90.	â	ES2026	`Error.isError`
89.	â	ES2026	`Array.fromAsync`
88.	â	ES2025	`RegExp.escape`
87.	â	ES2025	`Redeclarable global eval-introduced vars`
86.	â	ES2025	`Float16 on TypedArrays, DataView, Math.f16round`
85.	â	ES2025	`Promise.try`
84.	â	ES2025	`Sync Iterator helpers`
83.	â	ES2025	`JSON Modules`
82.	â	ES2025	`Import Attributes`
81.	â	ES2025	`RegExp Modifiers`
80.	â	ES2025	`New Set methods`
79.	â	ES2025	`Duplicate named capture groups`
78.	â	ES2024	`ArrayBuffer transfer`
77.	â	ES2024	`Promise.withResolvers`
76.	â	ES2024	`Array Grouping`
75.	â	ES2024	`Resizable and growable ArrayBuffers`
74.	â ï¸	ES2024	`RegExp v flag with set notation + properties of strings`
73.	â	ES2024	`Atomics.waitAsync`
72.	â	ES2024	`Well-Formed Unicode Strings`
71.	â	ES2023	`Change Array by Copy`
70.	â	ES2023	`Symbols as WeakMap keys`
69.	â	ES2023	`Hashbang Grammar`
68.	â	ES2023	`Array find from last`
67.	â	ES2022	`Error Cause`
66.	â	ES2022	`Class Static Block`
65.	â	ES2022	`Accessible Object.prototype.hasOwnProperty`
64.	â	ES2022	`.at()`
63.	â	ES2022	`Ergonomic brand checks for Private Fields`
62.	â	ES2022	`Top-level await`
61.	â	ES2022	`RegExp Match Indices`
60.	â	ES2022	`Class Public Instance Fields & Private Instance Fields`
59.	â	ES2021	`Numeric separators`
58.	â	ES2021	`Logical Assignment Operators`
57.	â	ES2021	`WeakRefs`
56.	â	ES2021	`Promise.any`
55.	â	ES2021	`String.prototype.replaceAll`
54.	â	ES2020	`import.meta`
53.	â	ES2020	`Nullish coalescing Operator`
52.	â	ES2020	`Optional Chaining`
51.	â	ES2020	`for-in mechanics`
50.	â	ES2020	`globalThis`
49.	â	ES2020	`Promise.allSettled`
48.	â	ES2020	`BigInt`
47.	â	ES2020	`import()`
46.	â	ES2020	`String.prototype.matchAll`
45.	â	ES2019	`Array.prototype.{flat,flatMap}`
44.	â	ES2019	`String.prototype.{trimStart,trimEnd}`
43.	â	ES2019	`Well-formed JSON.stringify`
42.	â	ES2019	`Object.fromEntries`
41.	â	ES2019	`Function.prototype.toString revision`
40.	â	ES2019	`Symbol.prototype.description`
39.	â	ES2019	`JSON superset`
38.	â	ES2019	`Optional catch binding`
37.	â ï¸	ES2018	`Asynchronous Iteration`
36.	â	ES2018	`Promise.prototype.finally`
35.	â	ES2018	`RegExp Unicode Property Escapes`
34.	â	ES2018	`RegExp Lookbehind Assertions`
33.	â	ES2018	`Rest/Spread Properties`
32.	â	ES2018	`RegExp named capture groups`
31.	â	ES2018	`s (dotAll) flag for regular expressions`
30.	â	ES2018	`Lifting template literal restriction`
29.	â	ES2017	`Shared memory and atomics`
28.	â	ES2017	`Async functions`
27.	â ï¸	ES2017	`Trailing commas in function parameter lists and calls`
26.	â	ES2017	`Object.getOwnPropertyDescriptors`
25.	â	ES2017	`String padding`
24.	â	ES2017	`Object.values/Object.entries`
23.	â	ES2016	`Exponentiation operator`
22.	â	ES2016	`Array.prototype.includes`
21.	â	ES2015	`arrows`
20.	â	ES2015	`classes`
19.	â	ES2015	`enhanced object literals`
18.	â	ES2015	`template strings`
17.	â	ES2015	`destructuring`
16.	â	ES2015	`default + rest + spread`
15.	â	ES2015	`let + const`
14.	â ï¸	ES2015	`iterators + for..of`
13.	â	ES2015	`generators`
12.	â	ES2015	`unicode`
11.	â ï¸	ES2015	`modules`
10.	â	ES2015	`module loaders`
9.	â	ES2015	`map + set + weakmap + weakset`
8.	â	ES2015	`proxies`
7.	â	ES2015	`symbols`
6.	â	ES2015	`subclassable built-ins`
5.	â	ES2015	`promises`
4.	â	ES2015	`math + number + string + array + object APIs`
3.	â	ES2015	`binary and octal literals`
2.	â	ES2015	`reflect api`
1.	â	ES2015	`tail calls`

Package Listing

Changelog

Full CHANGELOG.md

License

JSLint is under Unlicense License.
CodeMirror editor is under MIT License.
Function v8CoverageListMerge is derived from MIT Licensed v8-coverage.

Devops Instruction

pull-request merge

update .github/workflows/ci.yml .github/workflows/publish.yml to:
- latest nodejs-lts version @ https://nodejs.org/en/about/previous-releases
update CHANGELOG.md
- verify <CHANGELOG.md entry #1> is most-relevant to pull-request.
- run
```
# re-run until version propagates
npm run test2

# re-run until version propagates
sh jslint_ci.sh shGithubPrCreate alpha beta # v20yy.mm.dd __pr_beta_pre

git push upstream alpha -f
```
  - verify ci-success @ https://github.com/kaizhu256/jslint/actions
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
goto https://github.com/jslint-org/jslint/compare/beta...kaizhu256:jslint:branch-p20yy.mm.dd
- click Create pull request
- input Add a title * with: <CHANGELOG.md entry #1>
- input Add a description with:
```
Fixes #xxx.

This PR will:
<CHANGELOG.md entry #1>

This PR will additionally:
<CHANGELOG.md entry extra>

<screenshot>
```
- click Preview and review
- verify:
  - base respository: jslint-org/jslint
  - base: beta
- click Create pull request
  - verify ci-success @ https://github.com/jslint-org/jslint/actions/workflows/on_pull_request.yml
wait awhile before continuing ...
- click Squash and merge
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
- run
```
sh jslint_ci.sh shGithubPrCleanup

git push upstream alpha -f
```
  - verify ci-success @ https://github.com/kaizhu256/jslint/actions
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
- click Delete branch

branch-master commit

update .github/workflows/ci.yml .github/workflows/publish.yml to:
- latest nodejs-lts version @ https://nodejs.org/en/about/previous-releases
update CHANGELOG.md
- verify <CHANGELOG.md entry #1> is most-relevant to pull-request.
- run
```
# re-run until version propagates
npm run test2

# re-run until version propagates
sh jslint_ci.sh shGithubPrCreate alpha master # v20yy.mm.dd __pr_master_pre

git push upstream alpha -f
```
  - verify ci-success @ https://github.com/kaizhu256/jslint/actions
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
goto https://github.com/jslint-org/jslint/compare/beta...kaizhu256:jslint:branch-v20yy.mm.dd
- click Create pull request
- input Add a title * with: # v20yy.mm.dd
- input Add a description with:
```
<CHANGELOG.md entry #1>
<CHANGELOG.md entry extra>
```
- click Preview and review
- verify:
  - base respository: jslint-org/jslint
  - base: beta
- click Create pull request
  - verify ci-success @ https://github.com/jslint-org/jslint/actions/workflows/on_pull_request.yml
wait awhile before continuing ...
- click Squash and merge
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
- run
```
sh jslint_ci.sh shGithubPrCleanup

git push upstream alpha -f
```
  - verify ci-success @ https://github.com/kaizhu256/jslint/actions
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
- click Delete branch
- run
```
git push origin beta:master

git push upstream beta:master
```
  - verify ci-success @ https://github.com/kaizhu256/jslint/actions
  - verify ci-success @ https://github.com/jslint-org/jslint/actions

branch-master publish

goto https://www.npmjs.com/package/@jslint-org/jslint/access
- click Github Actions
- input Organization or user* with: jslint-org
- input Repository* with: jslint
- input Workflow filename* with: publish.yml
- click Set up connection or Update Package Settings
- run
```
git push upstream beta:master
```
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
goto https://github.com/jslint-org/jslint/releases/new
- input Tag: Select tag with: v20yy.mm.dd
  - click Create new tag and click Create
  - verify correct-year v20yy.mm.dd
  - select Target: master
- input Release title with: v20yy.mm.dd - <CHANGELOG.md entry #1>
  - select Previous tag: Auto
  - click Generate release notes
- input Write with:
```
<CHANGELOG.md entry #1>
<CHANGELOG.md entry extra>

**Full Changelog**: ...
```
- click Preview and review
- click Latest
- click Publish release
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
  - verify email-notification Successfully published @jslint-org/jslint@20yy.mm.dd

vscode-jslint publish

goto https://github.com/jslint-org/jslint/tree/gh-pages/branch-beta/.artifact/jslint_wrapper_vscode
- click vscode-jslint-20yy.mm.dd.vsix
- click Raw to download
goto https://marketplace.visualstudio.com/manage/publishers/jslint
- move mouse to version-number, right-click, and select Update
- upload downloaded file vscode-jslint-20yy.mm.dd.vsix
- click 'Upload'
  - verify email-notification [Succeeded] Extension publish on Visual Studio Marketplace - vscode-jslint

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

Top Related Projects

Quick Overview

Pros

Cons

Code Examples

Getting Started

Competitor Comparisons

Pros of jslint

Cons of jslint

Code Comparison

Pros of ESLint

Cons of ESLint

Code Comparison

Key Differences

Community and Ecosystem

Performance

Pros of JSHint

Cons of JSHint

Code Comparison

Pros of Standard

Cons of Standard

Code Comparison

Pros of Prettier

Cons of Prettier

Code Comparison

Key Differences

Use Cases

Community and Ecosystem

Pros of JavaScript

Cons of JavaScript

Code Comparison

Key Differences

Use Cases

Community and Ecosystem

Convert designs to code with AI

README

JSLint, The JavaScript Code Quality and Coverage Tool

Status

Web Demo

Web Demo Archived

Table of Contents

Quickstart Install

To install, just download and save https://www.jslint.com/jslint.mjs to file:

To run jslint.mjs in shell:

To import jslint.mjs in ES Module environment:

To import jslint.mjs in CommonJS environment:

To JSLint entire directory in shell:

Quickstart JSLint Report

To create a JSLint report in shell:

To create a JSLint report in javascript:

Quickstart V8 Coverage Report

To create V8 coverage report from Node.js / Npm program in shell:

To create V8 coverage report from Node.js / Npm program in javascript:

Quickstart JSLint in CodeMirror

Quickstart JSLint in Vim

Quickstart JSLint in VSCode

Documentation

API Doc

Directive

/*jslint beta*/

/*jslint bitwise*/

/*jslint browser*/

/*jslint convert*/

/*jslint couch*/

/*jslint devel*/

/*jslint eval*/

/*jslint fart*/

/*jslint getset*/

/*jslint indent2*/

/*jslint long*/

/*jslint node*/

/*jslint nomen*/

/*jslint single*/

/*jslint subscript*/

/*jslint this*/

/*jslint trace*/

/*jslint unordered*/

/*jslint white*/

/*global*/

/*property*/

To run `jslint.mjs` in shell:

To import `jslint.mjs` in ES Module environment:

To import `jslint.mjs` in CommonJS environment:

`/jslint beta/`

`/jslint bitwise/`

`/jslint browser/`

`/jslint convert/`

`/jslint couch/`

`/jslint devel/`

`/jslint eval/`

`/jslint fart/`

`/jslint getset/`

`/jslint indent2/`

`/jslint long/`

`/jslint node/`

`/jslint nomen/`

`/jslint single/`

`/jslint subscript/`

`/jslint this/`

`/jslint trace/`

`/jslint unordered/`

`/jslint white/`

`/global/`

`/property/`

`/jslint-disable/.../jslint-enable/`

`//jslint-ignore-line`

`/coverage-disable/.../coverage-enable/`

`//coverage-ignore-line`