JSHint is a static code analysis tool used in software development for checking if JavaScript source code complies with coding rules. It helps developers identify potential errors and enforce coding standards.
Basic Linting
This feature allows you to perform basic linting on a piece of JavaScript code. The code sample demonstrates how to use JSHint to check a simple JavaScript snippet for errors.
const jshint = require('jshint').JSHINT;
const code = 'var a = 1;';
const options = { esversion: 6 };
jshint(code, options);
console.log(jshint.errors);Custom Configuration
JSHint allows you to customize the linting process with various options. This example shows how to enable the 'undef' option to check for the use of undefined variables.
const jshint = require('jshint').JSHINT;
const code = 'var a = 1;';
const options = { esversion: 6, undef: true };
jshint(code, options);
console.log(jshint.errors);Using JSHint with Configuration File
You can use a configuration file (e.g., .jshintrc) to define your linting rules. This example demonstrates how to read a JavaScript file and a JSHint configuration file, then lint the code using the specified rules.
const fs = require('fs');
const jshint = require('jshint').JSHINT;
const code = fs.readFileSync('path/to/your/file.js', 'utf8');
const config = JSON.parse(fs.readFileSync('.jshintrc', 'utf8'));
jshint(code, config);
console.log(jshint.errors);ESLint is another popular JavaScript linting tool that is highly configurable and supports custom rules. It provides more flexibility and a larger ecosystem of plugins compared to JSHint.
JSCS (JavaScript Code Style) is a code style linter for JavaScript. It focuses more on enforcing coding style conventions rather than finding potential errors. It has been merged with ESLint, but older versions are still in use.
TSLint is a linter for TypeScript, which is a superset of JavaScript. It provides similar functionality to JSHint but is specifically designed for TypeScript code. TSLint is now deprecated in favor of ESLint with TypeScript support.
JSHint is a community-driven tool to detect errors and potential problems in JavaScript code and to enforce your team's coding conventions. We made JSHint very flexible so you can easily adjust it to your particular coding guidelines and the environment you expect your code to execute in.
Our goal is to help JavaScript developers write complex programs without worrying about typos and language gotchas.
We believe that static code analysis programs—as well as other code quality tools—are important and beneficial to the JavaScript community and, thus, should not alienate their users.
For general usage information, visit our website: http://jshint.com/.
We're running a fundraiser for JSHint! If JSHint helps you in your day-to-day development, please consider donating. All money raised on this page will be used as monetary rewards for fixing JSHint bugs and implementing new features. Our hope is to introduce more developers to JSHint hacking and boost its development.
Rules:
Thanks!
To report a bug simply create a new GitHub Issue and describe your problem or suggestion. We welcome all kind of feedback regarding JSHint including but not limited to:
Before reporting a bug look around to see if there are any open or closed tickets that cover your issue. And remember the wisdom: pull request > bug report > tweet.
You can install JSHint via NPM:
npm install jshint -g
We also provide platform wrappers for Rhino, JavaScriptCore and Windows Script Host. To use them, clone this repo and run our build command:
node make.js
jshint -h
You can also require JSHint itself as a module.
var jshint = require('jshint');
Note: If you are using npm v1.x be sure to install jshint locally (without the -g flag) or link it globally.
Specify a custom reporter module (see example/reporter.js).
--reporter path/to/reporter.js
Use a jslint compatible xml reporter.
--jslint-reporter
Show additional non-error data generated by jshint (unused globals etc).
--show-non-errors
Note: This behavior described below is very different from versions
prior to 0.6.
The CLI uses the default options that come with JSHint. Only one extra
option is unique to the CLI version of JSHint: globals allows you to
define an object of globals that get ignored for every file.
To have your own configuration apply, there are several methods you can use:
Setting the --config=/path/to/your/config command line option to specify
your own configuration file outside of the directory tree for your project.
When the CLI is called, and a configuration file isn't specified already,
node-jshint will attempt to locate one for you starting in pwd. (or
"present working directory") If this does not yield a .jshintrc file,
it will move one level up (..) the directory tree all the way up to
the filesystem root. If a file is found, it stops immediately and uses
that set of configuration.
This setup allows you to set up one configuration file for your entire
project. (place it in the root folder) As long as you run jshint from
anywhere within your project directory tree, the same configuration file
will be used.
If all the methods above do not yield a .jshintrc to use, the last place
that will be checked is your user's $HOME directory.
Default extension for files is ".js". If you want to use JSHint with other file extensions (.json), you need to pass this extra extension as an option:
--extra-ext .json
If there is a .jshintignore file in your project's directory tree, (also
provided you run jshint from within your project's directory) then any
directories or files specified will be skipped over. (behaves just like
a .gitignore file)
Note: Pattern matching uses minimatch, with the nocase option. When there is no match, it performs a left side match (when no forward slashes present and path is a directory).
It is easy to use JSHint as a JavaScript library. Just install the package
with NPM and, in your code, import a global JSHINT function:
var JSHINT = require("jshint").JSHINT;
This function takes two parameters. The first parameter is either a string or an array of strings. If it is a string, it will be split on '\n' or '\r'. If it is an array of strings, it is assumed that each string represents one line. The source can be a JavaScript text or a JSON text.
The second parameter is an optional object of options which control the operation of JSHINT. Most of the options are booleans: they are all optional and have a default value of false.
The third parameter is an object of global variables, with keys as names and a boolean value to determine if they are assignable.
If it checks out, JSHINT returns true. Otherwise, it returns false.
If false, you can inspect JSHINT.errors to find out the problems. JSHINT.errors is an array of objects containing these members:
{
line : The line (relative to 1) at which the lint was found
character : The character (relative to 1) at which the lint was found
reason : The problem
evidence : The text line in which the problem occured
scope : The scope of the problem.
raw : The raw message before the details were inserted
a : The first detail
b : The second detail
c : The third detail
d : The fourth detail
}
If a fatal error was found, a null will be the last element of the JSHINT.errors array.
You can request a data structure which contains JSHint's results.
var myData = JSHINT.data();
It returns a structure with this form:
{
errors: [
{
line : NUMBER,
character : NUMBER,
reason : STRING,
evidence : STRING
}
],
functions: [
name : STRING,
line : NUMBER,
character : NUMBER,
last : NUMBER,
lastcharacter: NUMBER,
param : [ STRING ],
closure : [ STRING ],
var : [ STRING ],
exception : [ STRING ],
outer : [ STRING ],
unused : [ STRING ],
global : [ STRING ],
label : [ STRING ]
],
globals: [
STRING
],
member: {
STRING: NUMBER
},
unused: [
{
name : STRING,
line : NUMBER
}
],
implieds: [
{
name: STRING,
line: NUMBER
}
],
urls: [
STRING
],
json: BOOLEAN
}
Empty array will not be included.
If you're using so-called smart tabs
then we have an option smarttabs for you. Otherwise, your solution is to
run JSHint with a custom reporter that discards any warnings you don't like.
For example, this example reporter
discards all warnings about mixed tabs and spaces.
Look for a file named CONTRIBUTING.md in this repository. It contains our
contributing guidelines. We also have
a mailing list.
JSHint is distributed under the MIT License. One file and one file only (src/stable/jshint.js) is distributed under the slightly modified MIT License.
Core Team members:
Maintainer: Anton Kovalyov
We really appreciate all kind of feedback and contributions. Thanks for using and supporting JSHint!
1.0.0 (2013-01-30)
<a name="1.0.0-rc4"></a>
FAQs
Static analysis tool for JavaScript
The npm package jshint receives a total of 657,966 weekly downloads. As such, jshint popularity was classified as popular.
We found that jshint demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 3 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
Socket researchers have discovered malicious npm packages targeting crypto developers, stealing credentials and wallet data using spyware delivered through typosquats of popular cryptographic libraries.
Security News
Socket's package search now displays weekly downloads for npm packages, helping developers quickly assess popularity and make more informed decisions.
Security News
A Stanford study reveals 9.5% of engineers contribute almost nothing, costing tech $90B annually, with remote work fueling the rise of "ghost engineers."