jshint / fixmyjs

Automatically fix silly lint errors.

JSHint, A Static Code Analysis Tool for JavaScript

[ Use it online • Docs • FAQ • Install • Contribute • Blog • Twitter ]

JSHint is a community-driven tool that detects errors and potential problems in JavaScript code. Since JSHint is so flexible, you can easily adjust it in the environment you expect your code to execute. JSHint is publicly available and will always stay this way.

Our goal

The project aims to help JavaScript developers write complex programs without worrying about typos and language gotchas.

Any code base eventually becomes huge at some point, so simple mistakes — that would not show themselves when written — can become show stoppers and add extra hours of debugging. So, static code analysis tools come into play and help developers spot such problems. JSHint scans a program written in JavaScript and reports about commonly made mistakes and potential bugs. The potential problem could be a syntax error, a bug due to an implicit type conversion, a leaking variable, or something else entirely.

Only 15% of all programs linted on jshint.com pass the JSHint checks. In all other cases, JSHint finds some red flags that could've been bugs or potential problems.

Please note, that while static code analysis tools can spot many different kind of mistakes, it can't detect if your program is correct, fast or has memory leaks. You should always combine tools like JSHint with unit and functional tests as well as with code reviews.

Reporting a bug

To report a bug simply create a new GitHub Issue and describe your problem or suggestion. We welcome all kinds of feedback regarding JSHint including but not limited to:

• When JSHint doesn't work as expected
• When JSHint complains about valid JavaScript code that works in all browsers
• When you simply want a new option or feature

Before reporting a bug, please look around to see if there are any open or closed tickets that discuss your issue, and remember the wisdom: pull request > bug report > tweet.

Who uses JSHint?

Engineers from these companies and projects use JSHint:

• Mozilla
• Wikipedia
• Facebook
• Twitter
• Disqus
• Medium
• Yahoo!
• SmugMug
• jQuery UI (Source)
• jQuery Mobile (Source)
• Coursera
• RedHat
• SoundCloud
• Nodejitsu
• Yelp
• Find My Electric
• Voxer
• EnyoJS
• QuickenLoans
• Cloud9
• CodeClimate
• Zendesk
• Google
• Codacy ref
• Spotify

And many more!

License

JSHint is licensed under the MIT Expat license.

Prior to version 2.12.0 (release in August 2020), JSHint was partially licensed under the non-free JSON license. The 2020 Relicensing document details the process maintainers followed to change the license.

The JSHint Team

JSHint is currently maintained by Rick Waldron, Caitlin Potter, Mike Pennisi, and Luke Page. You can reach them via [email protected].

Previous Maintainers

Originating from the JSLint project in 2010, JSHint has been maintained by a number of dedicated individuals. In chronological order, they are: Douglas Crockford, Anton Kovalyov, and Mike Sherov. We appreciate their long-term commitment!

Thank you!

We really appreciate all kinds of feedback and contributions. Thanks for using and supporting JSHint!

fixmyjs's Issues

instead of filtering errors, mark them as unfixable

Instead of filtering unsupported errors can we mark them as unfixable so that we can still see what they are?

Can't use the web interface

Hi, I can't seem to use the web interface for fixmyjs at the moment.

There are no fields to fill. I only see a few buttons at the top of the page, and clicking on them give me a 404 error, when accessing https://github.com/goatslacker/jshint-autofix.

Thanks.

Adding a 0 before a floating point sometimes broken

Input: Foo.bar = .25

Output: Foo0.bar = .25

Expected: Foo.bar = 0.25

Wrap the /regexp/ literal in parens to disambiguate the slash operator

return

Enable api to fix one error at a time

Blindly auto-fixing an entire file can cause problems.
I've integrated autofix into ShiftEdit and set it so that that you can fix one error at a time.
In order to get this to work I had to heavily bastardise the script. Would be cool if the API supported a way to check if a single error is fixable and then return the fixed line.

remove jshint as a gitsubmodule and use as a devDependency

null

Semicolon sometimes inserted before delete keyword

Input (note the first line is missing a semicolon):

cell.f = "foo"
delete cell.value;

Output:

cell.f = "foo"
delete; cell.value;

Expected:

cell.f = "foo";
delete cell.value;

enforce camelCase convention

JSHINT now supports it so we should autofix it.

Increase max_err to 500

Add Aptana support

Aptana's pretty awesome, and this would make it awesomer! :)

fix tests with koala

rewrite tests as different files in folders

Do not use {a} as a constructor

Number, Boolean, JSON, Math, String

package / examples / license

Be great if there was a packaged js file for this and some demos that could be viewed.
Also what license is this under?

Very interesting project, look forward to your reply.

Add fix method which returns details of fix

DSL for errors

better api.

parseInt sometimes broken

a.foo(parseInt(bar));

is incorrectly fixed as:

a.foo(parseInt(bar), 10);

Create website which lets you copy&paste your code

Variables should not be deleted

add textmate support

Trailing whitespace

Do not use new for side effects

Unnecessary semicolon doesn't work with tabs

Unnecessary semicolon doesn't work with tabs. Works fine without them or with spaces.

        var foo='bar';;

Missing radix parameter

!==|=== NaN doesn't always work

{ foo: bar } === NaN won't convert into isNan({ foo: bar });
"hello world" !== NaN won't convert as well...

jsdiff breaks with words like 'constructor'

duplicates vars in one line

The following line:

  var aw, ah, i, j, c, a, cw, ch, x, w, h, a, col, colWidth, offset, availablePercentWith = viewSize.width,

was transformed to:

  aw, ah, i, j, c, a, cw, ch, x, w, h, a, col, colWidth, offset, availablePercentWith = viewSize.width,

causing all variables to become global. Because "a" is declared twice, it doesn't work well in the context of multiple variables under a single var.

Can you look into this issue?

Bugs with "['{a}'] is better written in dot notation." fix

JSHint will report two ['foo'] is better written in dot notation. warnings for this line:

window['foo'] = window['foo'] || function () {};

fixMyJS will fix both of them but in the wrong order, throwing off character offsets

"['foo'] is better written in dot notation." (at 1:24)
fix: "window.foo = window['foo'] || function () {};"

"['foo'] is better written in dot notation." (at 1:8)
fix: "window.foo = window.foo || function () {};"

Additionally fixMyJS won't fix the dot notation error for this because of the whitespace:

window[ 'foo' ] = function () {};

With the white option on, the dot notation error has a character offset greater than the unexpected space after [ error. I think the offset for the dot notation is incorrect so I have filed a JSHint bug: jshint/jshint#601

You might be able to just eat the whitespace between the brackets but with the white flag on, you may have to account for some unexpected space errors that will be irrelevant at that point.

add extraneous stuff to npmignore

Extra Comma support

leading dot

I got the following line:

              var ratio = parseFloat(a.replace('%', ''))*.01;

converted to:

              var ratio = parseFloat(a0.replace('%', ''))*.01;

It seems like it used the first (.) instead of the second one. I'd recommend using a stronger regex pattern for the replacement.

csslint autofix

Have u thought about adding autofix for csslint?

TME may be encountered and errors aren't supported by fixmyjs

incorrectly fixes unexpected spaces

function foo ( ) {} becomes function foo( {}

Code for programmatic access is too complicated

Needs refactoring. Lose the lib/code file as well.

Eliminate all additions/removals based on character position.

If absolutely necessary, execute those adds/removes at the end. And sort them.

pure functions

Shadow option issues

function foo() {
  var foo = true;
}

will be incorrectly fixed

Incorrect space insertion

I found a strange issue where if I have a line like the below with mixed spaces and tabs at the beginning of the line, it adds a space between the 'r' and 'e' in redis, adds a semicolon at the end of the line, adds an extra space before 'response', and doesn't remove the tab:

                    redis_client.set(key, JSON.stringify(doc), function(redis_err, response) {

... is changed to:

                    redis_client.set(key, JSON.stringify(doc), function(r edis_err,  response) {;

Great tool so far though, it's coming in handy.

add newline fixes

function bind(fn, ctx) {
  return function() {
    fn.apply(ctx, arguments); };
}

The body of a for in should be wrapped in an if statement to filter unwanted properties from the prototype

Can't rely on column count for users that use tabs

Move the invocation into the parens that contain the function only works with fn invocations with no parameters

:(

add missing docs

on "Too many errors" throw an exception

Output diff files when using new option --diff

Docs

enforce quote consistency

change all double quotes to single...etc