What are the top JavaScript pitfalls? [closed]

Answer 1

The whole concept of prototyping takes some time to fully understand but here are some common pitfalls:

Forgetting to reset the constructor property after assigning a prototype object:

var Foo() = function ()
{
    this.batz = '...';
};
Foo.prototype = new Bar();
Foo.prototype.constructor = Foo;

If you forget the least line, new Foo() will actually execute Bar().

Another pitfall with prototyping is iterating over objects/arrays without filtering out the members of the prototype:

for (var i in obj) {
    if (obj.hasOwnProperty(i)) {
        //stuff...
    }
}

The extra condition will skip any members that are inherited from the prototype of obj.

Answer 2

Boolean type conversion.

''        ==   '0'           //false
0         ==   ''            //true
0         ==   '0'           //true
false     ==   'false'       //false
false     ==   '0'           //true
false     ==   undefined     //false
false     ==   null          //false
null      ==   undefined     //true
" \t\r\n" ==   0             //true

As well as the difference between null and undefined. As listed in the table above, comparing null & undefined with == returns true, but with === it returns false. This behavior makes sense once you understand that undefined is very different from a variable having a null value, and something holding the value undefined is different from something being undefined.

Answer 3

Not a real coding pitfall, but more one of general thought:
Don't trust the things your JavaScript is doing, it might have been turned off or even monkey patched. That means never rely on client-side validation. NEVER.

Answer 4

• Closures - otherwise known as lambda functions - watch out for memory leaks.
• Browser differences, testing in both Internet Explorer and at least one other browser is a must. Functions that only work in some browsers, or work differently in different browsers should generally be avoided. If this is not possible browser specific branching is better done detecting browser features instead of browser versions. This increases the chance of the code working in future browsers and browsers that have not been tested.
• Getting too caught up in jQuery or Ajax framework abstraction, and not knowing the underlining JavaScript well enough to know how to fix framework issues.
• Not knowing that JavaScript can be used to some degree to write OOP code. In fact it can give you a very basic OOP framework with objects.
• Case sensitivity (if you're a VB.NET developer)
• IP protection - knowing that you can obfuscate JavaScript, but the source code you put out there will be very easy to steal and reverse engineer. This might not even be an issue depending on the complexity of the client-side application you're writing.

I can't think of any more, but I hope this helps.

Answer 5

• Creating sites that don't work without JavaScript
• Using JavaScript for things that should be done server-side
• Using frameworks for simple tasks that don't require them

Answer 6

+ to concatenate strings:

var a = '2';
var b = 3;

a * b #  6
a - b # -1
a + b #  23