##bitwise This option prohibits the use of bitwise operators such as ^ (XOR), | (OR) and others. Bitwise operators are very rare in JavaScript programs and quite often & is simply a mistyped &&.
##camelcase This option allows you to force all variable names to use either camelCase style or UPPER_CASE with underscores.
##curly This option requires you to always put curly braces around blocks in loops and conditionals. JavaScript allows you to omit curly braces when the block consists of only one statement, for example:
while (day)
shuffle();
However, in some circumstances, it can lead to bugs (you'd think that sleep() is a part of the loop while in reality it is not):
while (day)
shuffle();
sleep();
##eqeqeq This options prohibits the use of == and != in favor of === and !==. The former try to coerce values before comparing them which can lead to some unexpected results. The latter don't do any coercion so they are generally safer. If you would like to learn more about type coercion in JavaScript, we recommend Truth, Equality and JavaScript by Angus Croll.
##forin This option requires all for in loops to filter object's items. The for in statement allows for looping through the names of all of the properties of an object including those inherited throught the prototype chain. This behavior can lead to unexpected items in your object so it is generally safer to always filter inherited properties out as shown in the example:
for (key in obj) {
if (obj.hasOwnProperty(key)) {
// We are sure that obj[key] belongs to the object and was not inherited.
}
}
##freeze This options prohibits overwriting prototypes of native objects such as Array, Date and so on.
/* jshint freeze:true */
Array.prototype.count = function (value) { return 4; };
// -> Warning: Extending prototype of native object: 'Array'.
##immed This option prohibits the use of immediate function invocations without wrapping them in parentheses. Wrapping parentheses assists readers of your code in understanding that the expression is the result of a function, and not the function itself.
##indent This option enforces specific tab width for your code. For example, the following code will trigger a warning on line 4:
/*jshint indent:4 */
if (cond) {
doSomething(); // We used only two spaces for indentation here
}
##latedef This option prohibits the use of a variable before it was defined. JavaScript has function scope only and, in addition to that, all variables are always moved—or hoisted— to the top of the function. This behavior can lead to some very nasty bugs and that's why it is safer to always use variable only after they have been explicitly defined.
Setting this option to "nofunc" will allow function declarations to be ignored.
##newcap This option requires you to capitalize names of constructor functions. Capitalizing functions that are intended to be used with new operator is just a convention that helps programmers to visually distinguish constructor functions from other types of functions to help spot mistakes when using this.
Not doing so won't break your code in any browsers or environments but it will be a bit harder to figure out—by reading the code—if the function was supposed to be used with or without new. And this is important because when the function that was intended to be used with new is used without it, this will point to the global object instead of a new object.
##noarg This option prohibits the use of arguments.caller and arguments.callee. Both .caller and .callee make quite a few optimizations impossible so they were deprecated in future versions of JavaScript. In fact, ECMAScript 5 forbids the use of arguments.callee in strict mode.
##noempty This option warns when you have an empty block in your code. JSLint was originally warning for all empty blocks and we simply made it optional. There were no studies reporting that empty blocks in JavaScript break your code in any way.
##nonbsp This option warns about "non-breaking whitespace" characters. These characters can be entered with option-space on Mac computers and have a potential of breaking non-UTF8 web pages.
##nonew This option prohibits the use of constructor functions for side-effects. Some people like to call constructor functions without assigning its result to any variable:
new MyConstructor();
There is no advantage in this approach over simply calling MyConstructor since the object that the operator new creates isn't used anywhere so you should generally avoid constructors like this one.
##plusplus This option prohibits the use of unary increment and decrement operators. Some people think that ++ and -- reduces the quality of their coding styles and there are programming languages—such as Python—that go completely without these operators.
##quotmark This option enforces the consistency of quotation marks used throughout your code. It accepts three values: true if you don't want to enforce one particular style but want some consistency, "single" if you want to allow only single quotes and "double" if you want to allow only double quotes.
##undef This option prohibits the use of explicitly undeclared variables. This option is very useful for spotting leaking and mistyped variables.
/*jshint undef:true */
function test() {
var myVar = 'Hello, World';
console.log(myvar); // Oops, typoed here. JSHint with undef will complain
}
If your variable is defined in another file, you can use /*global ... */ directive to tell JSHint about it.
unused
This option warns when you define and never use your variables. It is very useful for general code cleanup, especially when used in addition to undef.
/*jshint unused:true */
function test(a, b) {
var c, d = 2;
return a + d;
}
test(1, 2);
// Line 3: 'b' was defined but never used.
// Line 4: 'c' was defined but never used.
In addition to that, this option will warn you about unused global variables declared via /*global ... */ directive.
This can be set to vars to only check for variables, not function parameters, or strict to check all variables and parameters. The default (true) behavior is to allow unused parameters that are followed by a used parameter.
##strict This option requires all functions to run in ECMAScript 5's strict mode. Strict mode is a way to opt in to a restricted variant of JavaScript. Strict mode eliminates some JavaScript pitfalls that didn't cause errors by changing them to produce errors. It also fixes mistakes that made it difficult for the JavaScript engines to perform certain optimizations.
Note: This option enables strict mode for function scope only. It prohibits the global scoped strict mode because it might break third-party widgets on your page. If you really want to use global strict mode, see the globalstrict option.
##trailing This option makes it an error to leave a trailing whitespace in your code. Trailing whitespaces can be source of nasty bugs with multi-line strings in JavaScript:
// This otherwise perfectly valid string will error if
// there is a whitespace after \
var str = "Hello \
World";
##maxparams This option lets you set the max number of formal parameters allowed per function:
/*jshint maxparams:3 */
function login(request, onSuccess) {
// ...
}
// JSHint: Too many parameters per function (4).
function logout(request, isManual, whereAmI, onSuccess) {
// ...
}
##maxdepth This option lets you control how nested do you want your blocks to be:
/*jshint maxdepth:2 */
function main(meaning) {
var day = true;
if (meaning === 42) {
while (day) {
shuffle();
if (tired) { // JSHint: Blocks are nested too deeply (3).
sleep();
}
}
}
}
##maxstatements This option lets you set the max number of statements allowed per function:
/*jshint maxstatements:4 */
function main() {
var i = 0;
var j = 0;
// Function declarations count as one statement. Their bodies
// don't get taken into account for the outer function.
function inner() {
var i2 = 1;
var j2 = 1;
return i2 + j2;
}
j = i + j;
return j; // JSHint: Too many statements per function. (5)
}
##maxcomplexity This option lets you control cyclomatic complexity throughout your code. Cyclomatic complexity measures the number of linearly independent paths through a program's source code. Read more about cyclomatic complexity on Wikipedia.
##maxlen This option lets you set the maximum length of a line.
I vote against bitwise, forin, freeze, indent, noempty, nonew, plusplus, quotmark, maxparams, maxdepth, maxstatement, maxcomplexity and maxlen