The "unexpected ++" error in jslint

What is the best practice for that then?

Jslint explains that it “adds confusion”. I don’t see it really…

EDIT: The code, as requested:

  var all,l,elements,e;
  all = inElement.getElementsByTagName('*');
  l = all.length;
  elements = [];
  for (e = 0; e < l; (e++))
  {
    if (findIn)
    {
        if (all[e].className.indexOf(className) > 0)
        {
            elements[elements.length] = all[e];
        }
    } else {
        if (all[e].className === className)
        {
            elements[elements.length] = all[e];
        }
    }
  }

31 thoughts on “The "unexpected ++" error in jslint”

  1. Personally, I prefer to put statements such as i++ on a line by themselves. Including them as part of a larger statement can cause confusion for those who aren’t sure what the line’s supposed to be doing.

    For example, instead of:

    value = func(i++ * 3);
    

    I would do this:

    value = func(i * 3);
    i++;
    

    It also means people don’t have to remember how i++ and ++i work, and removes the need to apply quite so many preference rules.

    Reply
  2. The longstanding best practice:
    Use i += 1 instead, following jslint’s advice.

    As for why it is a better practice than ++, according to Crockford:

    The increment ++ and decrement -- operators make it possible to write in an extremely terse style. In languages such as C, they made it possible to write one-liners that: for (p = src, q = dest; !*p; p++, q++) *q = *p; Most of the buffer overrun bugs that created terrible security vulnerabilities were due to code like this. In my own practice, I observed that when I used ++ and --, my code tended to be too tight, too tricky, too cryptic. So, as a matter of discipline, I don’t use them any more.

    Edit: Included comment from Nope as this answer continues to get views. Please continue to upvote his comment as well 🙂

    Reply
  3. To avoid confusion, and possible problems when using minifiers, always wrap parens around the operator and its operand when used together with the same (+ or -).

    var i = 0, j = 0;
    alert(i++ +j);
    

    This adds i and j (and increments i as a side effect) resulting in 0 being alerted.

    But what is someone comes along and moves the space?

    var i = 0, j = 0;
    alert(i+ ++j);
    

    Now this first increments j, and then adds i to the new value of j, resulting in 1 being alerted.

    This could easily be solved by doing

    var i = 0, j = 0;
    alert((i++) +j); 
    

    Now this cannot be mistaken.

    Reply
  4. Please note that the ++ operator depends on position with respect to the prior/next variable and the newline / semicolon to determine order of operations.

    var a = 1;
    var b = a++;
    console.log(b); // b = 1
    console.log(a); // a = 2
    
    var a = 1;
    var b = ++a;
    console.log(b); // b = 2
    console.log(a); // a = 2
    
    Reply
  5. There is something called a pre-increment: ++i and a post-increment i++
    and there is a difference:

    var i = 9;
    alert(++i); //-> alerts 10
    
    var j = 9;
    alert(j++); //-> alerts 9
    alert(j);   //-> alerts 10 now, as expected
    
    var k = 9;
    alert((k++)); //-> still alerts 9 even with extra parentheses
    
    Reply
  6. The real problem of the ++ operator is that it is an operator with side effects and thus it is totally opposed to the principle of functional programming.

    The “functional” way to implement i++ would be i = i + 1 where you explicitly reassign the variable with no side effects and then use it.

    The possibility of confusion is that ++ does two things by adding a value AND reassigning it to the variable.

    Reply

Leave a Comment