Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
An annotated .jshintrc file, based on the docs at http://jshint.com/docs/options.
{
/**
* Tell JSHint about global variables.
*/
"predef": [
// https://github.com/pivotal/jasmine
"after",
"afterEach",
"before",
"beforeEach",
"console",
"define",
"describe",
"expect",
"exports",
"it",
"jasmine",
"runs",
"spyOn",
"waitsFor",
"xdescribe",
"xit",
// https://github.com/angular/angular.js
"angular",
"inject",
"module",
// https://github.com/angular/protractor
"browser",
"protractor"
],
// Enforcing options
// ---------------------------------------------------------------------------
// When set to true, these options will make JSHint produce more warnings
// about your code.
// ---------------------------------------------------------------------------
/**
* 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 &&.
*/
"bitwise": true,
/**
* This option allows you to force all variable names to use either camelCase
* style or UPPER_CASE with underscores.
*/
"camelcase": true,
/**
* 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();
*/
"curly": true,
/**
* 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.
*/
"eqeqeq": true,
/**
* This option tells JSHint that your code needs to adhere to ECMAScript 3
* specification. Use this option if you need your program to be executable
* in older browsers—such as Internet Explorer 6/7/8/9—and other legacy
* JavaScript environments.
*/
"es3": true,
/**
* 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.
* }
* }
*
* For more in-depth understanding of for in loops in JavaScript, read
* Exploring JavaScript for-in loops by Angus Croll.
*/
"forin": true,
/**
* 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'.
*/
"freeze": true,
/**
* 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.
*/
"immed": true,
/**
* 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
* }
*/
"indent": 2,
/**
* 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.
*
* For more in-depth understanding of scoping and hoisting in JavaScript,
* read JavaScript Scoping and Hoisting by Ben Cherry.
*/
"latedef": false,
/**
* 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.
*/
"newcap": true,
/**
* 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.
*/
"noarg": true,
/**
* 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.
*/
"noempty": true,
/**
* 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.
*/
"nonbsp": true,
/**
* 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.
*/
"nonew": true,
/**
* 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.
*/
"plusplus": false,
/**
* 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.
*/
"quotmark": "single",
/**
* 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, JSHint with undef will complain
* }
*
* If your variable is defined in another file, you can use /*global ... *\/
* directive to tell JSHint about it.
*/
"undef": true,
/**
* 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.
*/
"unused": true,
/**
* 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.
*/
"strict": true,
/**
* 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";
*/
"trailing": true,
/**
* 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) {
* // ...
* }
*/
"maxparams": false,
/**
* 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();
* }
* }
* }
* }
*/
"maxdepth": false,
/**
* 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)
* }
*/
"maxstatements": false,
/**
* 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.
*/
"maxcomplexity": false,
/**
* This option lets you set the maximum length of a line.
*/
"maxlen": false,
// Relaxing options
// ---------------------------------------------------------------------------
// When set to true, these options will make JSHint produce less warnings
// about your code.
// ---------------------------------------------------------------------------
/**
* This option suppresses warnings about missing semicolons. There is a lot
* of FUD about semicolon spread by quite a few people in the community. The
* common myths are that semicolons are required all the time (they are not)
* and that they are unreliable. JavaScript has rules about semicolons which
* are followed by all browsers so it is up to you to decide whether you
* should or should not use semicolons in your code.
*
* For more information about semicolons in JavaScript read An Open Letter
* to JavaScript Leaders Regarding Semicolons by Isaac Schlueter and
* JavaScript Semicolon Insertion.
*/
"asi": false,
/**
* This option suppresses warnings about the use of assignments in cases
* where comparisons are expected. More often than not, code like if (a =
* 10) {} is a typo. However, it can be useful in cases like this one:
*
* for (var i = 0, person; person = people[i]; i++) {}
*
* You can silence this error on a per-use basis by surrounding the assignment
* with parenthesis, such
* as:
*
* for (var i = 0, person; (person = people[i]); i++) {}
*
*/
"boss": false,
/**
* This option suppresses warnings about the debugger statements in your code.
*/
"debug": false,
/**
* This option suppresses warnings about == null comparisons. Such
* comparisons are often useful when you want to check if a variable is null
* or undefined.
*/
"eqnull": false,
/**
* This option tells JSHint that your code uses ECMAScript 6 specific
* syntax. Note that these features are not finalized yet and not all
* browsers implement them.
*/
"esnext": false,
/**
* This option suppresses warnings about the use of eval. The use of eval is
* discouraged because it can make your code vulnerable to various injection
* attacks and it makes it hard for JavaScript interpreter to do certain
* optimizations.
*/
"evil": true,
/**
* This option suppresses warnings about the use of expressions where
* normally you would expect to see assignments or function calls. Most of
* the time, such code is a typo. However, it is not forbidden by the spec
* and that's why this warning is optional.
*/
"expr": true,
/**
* This option suppresses warnings about declaring variables inside of
* control structures while accessing them later from the outside. Even
* though JavaScript has only two real scopes—global and function—such
* practice leads to confusion among people new to the language and
* hard-to-debug bugs. This is why, by default, JSHint warns about variables
* that are used outside of their intended scope.
*
* function test() {
* if (true) {
* var x = 0;
* }
*
* x += 1; // Default: 'x' used out of scope.
* // No warning when funcscope:true
* }
*/
"funcscope": false,
/**
* This option makes JSHint compatible with Google Closure Compiler.
*/
"gcl": false,
/**
* This option suppresses warnings about the use of global strict mode.
* Global strict mode can break third-party widgets so it is not
* recommended.
*
* For more info about strict mode see the strict option.
*/
"globalstrict": false,
/**
* This option suppresses warnings about the __iterator__ property. This
* property is not supported by all browsers so use it carefully.
*/
"iterator": false,
/**
* This option suppresses warnings about missing semicolons, but only when the
* semicolon is omitted for the last statement in a one-line block:
*
* var name = (function() { return 'Anton' }());
*
* This is a very niche use case that is useful only when you use automatic
* JavaScript code generators.
*/
"lastsemic": false,
/**
* This option suppresses most of the warnings about possibly unsafe line
* breakings in your code. It doesn't suppress warnings about comma-first
* coding style. To suppress those you have to use laxcomma (see below).
*/
"laxbreak": false,
/**
* This option suppresses warnings about comma-first coding style:
*
* var obj = {
* name: 'Anton'
* , handle: 'valueof'
* , role: 'SW Engineer'
* };
*/
"laxcomma": false,
/**
* This option suppresses warnings about functions inside of loops. Defining
* functions inside of loops can lead to bugs such as this one:
*
* var nums = [];
*
* for (var i = 0; i < 10; i++) {
* nums[i] = function (j) {
* return i + j;
* };
* }
*
* nums[0](2); // Prints 12 instead of 2
*
* To fix the code above you need to copy the value of i:
*
* var nums = [];
*
* for (var i = 0; i < 10; i++) {
* (function (i) {
* nums[i] = function (j) {
* return i + j;
* };
* }(i));
* }
*/
"loopfunc": false,
/**
* This options allows you to set the maximum amount of warnings JSHint will
* produce before giving up. Default is 50.
*/
"maxerr": false,
/**
* This options tells JSHint that your code uses Mozilla JavaScript
* extensions. Unless you develop specifically for the Firefox web browser
* you don't need this option.
*/
"moz": false,
/**
* This option suppresses warnings about multi-line strings. Multi-line
* strings can be dangerous in JavaScript because all hell breaks loose if
* you accidentally put a whitespace in between the escape character (\) and
* a new line.
*
* Note that even though this option allows correct multi-line strings, it
* still warns about multi-line strings without escape characters or with
* anything in between the escape character and a whitespace.
*
* /*jshint multistr:true*\/
*
* var text = "Hello\
* World"; // All good.
*
* text = "Hello
* World"; // Warning, no escape character.
*
* text = "Hello\
* World"; // Warning, there is a space after \
*/
"multistr": false,
/**
* This option suppresses warnings about invalid typeof operator values. This
* operator has only a limited set of possible return values. By default,
* JSHint warns when you compare its result with an invalid value which often
* can be a typo.
*
* // 'fuction' instead of 'function'
* if (typeof a == "fuction") { // Invalid typeof value 'fuction'
* // ...
* }
*
* Do not use this option unless you're absolutely sure you don't want these
* checks.
*/
"notypeof": false,
/**
* This option suppresses warnings about the __proto__ property.
*/
"proto": false,
/**
* This option suppresses warnings about the use of script-targeted
* URLs—such as javascript:....
*/
"scripturl": false,
/**
* This option suppresses warnings about mixed tabs and spaces when the
* latter are used for alignmnent only. The technique is called SmartTabs.
*/
"smarttabs": false,
/**
* This option suppresses warnings about variable shadowing i.e. declaring a
* variable that had been already declared somewhere in the outer scope.
*/
"shadow": false,
/**
* This option suppresses warnings about using [] notation when it can be
* expressed in dot notation:
*
* person['name'] vs. person.name.
*/
"sub": true,
/**
* This option suppresses warnings about "weird" constructions like
* `new function () { ... }` and `new Object;`. Such constructions are
* sometimes used to produce singletons in JavaScript:
*
* var singleton = new function() {
* var privateVar;
*
* this.publicMethod = function () {}
* this.publicMethod2 = function () {}
* };
*/
"supernew": false,
/**
* This option suppresses warnings about possible strict violations when the
* code is running in strict mode and you use this in a non-constructor
* function. You should use this option—in a function scope only—when you
* are positive that your use of this is valid in the strict mode (for
* example, if you call your function using Function.call).
*
* Note: This option can be used only inside of a function scope. JSHint
* will fail with an error if you will try to set this option globally.
*/
"validthis": true,
/**
* This option suppresses warnings about generator functions with no yield
* statement in them.
*/
"noyield": false,
// Environments
// ---------------------------------------------------------------------------
// These options let JSHint know about some pre-defined global variables.
// ---------------------------------------------------------------------------
/**
* This option defines globals exposed by modern browsers: all the way from
* good old document and navigator to the HTML5 FileReader and other new
* developments in the browser world.
*
* Note: This option doesn't expose variables like alert or console. See
* option devel for more information.
*/
"browser": true,
/**
* This option defines globals exposed by CouchDB. CouchDB is a
* document-oriented database that can be queried and indexed in a MapReduce
* fashion using JavaScript.
*/
"couch": false,
/**
* This option defines globals that are usually used for logging poor-man's
* debugging: console, alert, etc. It is usually a good idea to not ship
* them in production because, for example, console.log breaks in legacy
* versions of Internet Explorer.
*/
"devel": false,
/**
* This option defines globals exposed by the Dojo Toolkit.
*/
"dojo": false,
/**
* This option defines globals exposed by the jQuery JavaScript library.
*/
"jquery": false,
/**
* This option defines globals exposed by the MooTools JavaScript framework.
*/
"mootools": false,
/**
* This option defines globals available when your code is running inside of
* the Node runtime environment. Node.js is a server-side JavaScript
* environment that uses an asynchronous event-driven model. This option
* also skips some warnings that make sense in the browser environments but
* don't make sense in Node such as file-level use strict pragmas and
* console.log statements.
*/
"node": true,
/**
* This option defines non-standard but widely adopted globals such as
* escape and unescape.
*/
"nonstandard": false,
/**
* This option defines globals available when your core is running inside of
* the PhantomJS runtime environment. PhantomJS is a headless WebKit
* scriptable with a JavaScript API. It has fast and native support for
* various web standards: DOM handling, CSS selector, JSON, Canvas, and SVG.
*/
"phantom": false,
/**
* This option defines globals exposed by the Prototype JavaScript framework.
*/
"prototypejs": false,
/**
* This option defines globals available when your code is running inside of
* the Rhino runtime environment. Rhino is an open-source implementation of
* JavaScript written entirely in Java.
*/
"rhino": false,
/**
* This option defines globals available when your code is running inside of
* a Web Worker. Web Workers provide a simple means for web content to run
* scripts in background threads.
*/
"worker": false,
/**
* This option defines globals available when your code is running as a
* script for the Windows Script Host.
*/
"wsh": false,
/**
* This option defines globals exposed by the YUI JavaScript framework.
*/
"yui": false,
// Legacy
// ---------------------------------------------------------------------------
// These options are deprecated and will be removed soon. DO NOT use them.
// ---------------------------------------------------------------------------
/**
* This option disallows the use of dangling _ in variables. We don't know why
* would you need it.
*/
"nomen": false,
/**
* This option allows only one var statement per function. Some people think
* that having a single var in a function, at the top of the function, helps
* readability. Example (taken from JSLint/JSHint source code):
*
* x.nud = function () {
* var b, f, i, j, p, seen = {}, t;
*
* b = token.line !== nexttoken.line;
* if (b) {
* indent += option.indent;
* if (nexttoken.from === indent + option.indent) {
* indent += option.indent;
* }
* }
*
* // [...]
* };
*/
"onevar": false,
/**
* This option makes JSHint stop on the first error or warning.
*/
"passfail": false,
/**
* This option make JSHint check your source code against Douglas
* Crockford's JavaScript coding style. Unfortunately, his “The Good Parts”
* book aside, the actual rules are not very well documented.
*/
"white": false
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.