JSLint - Expected to see a statement but instead saw a block

Question

I have just turned on 'JSLint' validation in Aptana Studio 3. In my web app, I have the following code:

Sessions.getVars = function()
{
    return $http.get(baseURL)
                .then(function(response) { return response.data; },
                      function(response) { /* TODO Error handling */ });    
};

This is throwing the following error Expected to see a statement but instead saw a block.

I have looked in this question, but that really only answers the question in relation to switch/case statements. Anyone able to help me understand why this error exists?

Answer 1

This is likely because jslint enforces a convention of putting the opening curly brace of a function body on the same line as the function keyword, i.e.

function myFunc () { // Put it here
  // body...
}

It could also be a bug in that the parser fails to recognise the function's body starting on a new line.

PS. If JSLint suits your needs, then keep using it, but I feel obliged to introduce you to some alternatives:

jshint and eslint. jshint provides configurable rules for known pitfalls and enforces good coding habits, whereas eslint (in addition) provides rules to enforce a particular coding style (at the expense of seemingly overwhelming amount of configuration options).

Answer 2

It's a much easier a problem than squiggly bracket placement. You have a particular type of block -- an empty block -- and JSLint doesn't like empty blocks. It wants statements.

Note that a function without a return value returns undefined anyway, so you can kludge this without changing function like this:

/*jslint sloppy:true, white:true */
/*global Sessions, $http, baseURL */
Sessions.getVars = function()
{
    return $http.get(baseURL)
                .then(function(response) { return response.data; },
                      function(response) { return undefined; });    
};

I think that's all you're seeing.

Note that JSLint is not necessarily quite as bad about where you put the squigglies as these other answers would have you believe! ;^) It's not a dealbreaker, anyhow, if you use JSLint directives.

I'm using two directives:

• sloppy -- allows you to skip using "use strict";
• white -- allows for any whitespace you want. Without this, you'd see the error I think other answers here are anticipating, but that error would be Expected exactly one space between ')' and '{'.

I'd say you can just run the snippet on JSLint.com to check, but it looks like Crockford is in the middle of his warned move to a new JSLint that's much more draconian than the old one. For now, I'd suggest testing snippets at old.jslint.com.

If you do, you'll see that, to make JSLint "fully happy", you'll need to remove response from that second function as well: function() { return "Something"; });. It doesn't like unused parameters either.

If you want to keep the TODO comment, you'll need to add the todo directive too.

Adding both of those changes gives us:

/*jslint sloppy:true, white:true, todo:true */
/*global Sessions, $http, baseURL */
Sessions.getVars = function()
{
    return $http.get(baseURL)
        .then(function(response) { return response.data; },
            function() {
                /* TODO Error handling; add `err` to parameters */ 
                return undefined; 
        });    
};

Answer 3

Use the recommended JavaScript formatting style here other styles are mostly variations on this one. Most editors automatically format your JS code into this style or something that is really close.

The { (left curly brace) should be at the end of the line that begins the compound statement.

There are tons of nasty JavaScript bugs you can avoid by following the recommended formatting rules (example). It will also help other people to read this code.

JSLint is all about enforcing such guidelines. So bypassing them is often, but not always counterproductive this is why JSHint was invented.