JavaScript to Avoid

• with is a JavaScript construct that is never needed and which can make your code far less efficient. What it does is to test if each field referenced within the block is a property or method of the object the statement references and if so the field is considered to reference that object. You can make the code more efficient without significantly affecting the amount of code by using a short object name within the block instead.

• eval is one of the most inefficient constructs that JavaScript has. Also in most of the instances where it is used there is a much shorter way of coding that provides a direct reference.
• continue jumps over the rest of the content of a loop and starts the next iteration. The same effect can be achieved in less code simply by including the rest of the code in a block and reversing the test.
• switch fallthrough can cause lots of problems. Any code within your switch statement should always have a break preceding the next case. The only time you should allow cases to fall through to the code following a subsequent case is where the cases are to run the exact same code. Unexpectedly falling through is the biggest cause of errors in case statements. If you are going to disregard this and allow fallthroughs anyway then at least comment those that are deliberate so as to make it easier to spot those that are accidental.
• bitwise operators are extremely inefficient in JavaScript compared to most other languages where they are actually one of the most efficient groups of operators. Only those coming from another language are likely to consider using bitwise operators and most of the time they will be choosing that way because they are looking for efficiency. The alternative that would be less efficient in the other language you are used to is probably going to be the more efficient way to do it in JavaScript.

• typed wrappers such as new Boolean(), new Number(), and new String() produce object equivalents to the equivalent primitive types built into JavaScript. Not only is it a slightly longer way of specifying something you'd expect to be the same thing but they are in fact not quite the same and the differences can cause problems.
• void in most languages means to not return a value at all. In JavaScript it returns 'undefined' which is the same as you'd get when you don't specify a return value for most function calls.

Problematic JavaScript

• == and != are loose comparisons meaning that the field on one side will be converted to the same type as the field on the other before they are compared. Some of these type conversions do not produce the result you may expect for example 3 != '3.0' in JavaScript because they are compared as strings (in PHP for example they'd be compared as numbers and therefore would be equal). There is also the possibility of your accidentally leaving out an equals ending up with a = b when you wanted a == b and since both statements are valid but do different things the error can be difficult to spot. Instead wherever possible you should use the === and !== comparisons which test for both value and type.
• new is used to create a new object that inherits from the one referenced. In most object oriented languages leaving out the keyword 'new' wouldn't cause unexpected run time errors because the reference would be to a class. JavaScript doesn't have classes though and so objects serve dual purposes. Most people adopt the convention of giving their objects that are to be used as classes names starting with an uppercase letter in order to make detecting errors when the keyword 'new' is omitted. Even JavaScript itself uses this convention (eg. the Date() object as compared to the date() function).
• ++ and -- are no problem when used as part of a separate statement but their use can become confused if you start combining statements together into one. For example a++ + ++b is the equivalent of three statements which add 1 to b, add b and a, and finally add 1 to a, and return the result of the second of these. Your code will be easier to read if you separate out the statements when you use ++ or --.
• functions can be defined in three different ways. The function functionname() {}; version is just a shortcut for the slightly longer but more accurate var functionname = function() {};. The third form using new Function(); work entirely differently and is extremely inefficient. It should be avoided (except where you need to use it to avoid using eval).
• document.write() was originally the only way to add content into your web page using JavaScript. Unfortunately to use it your script has to go in the body at the point where you want the output to appear and also if you write out script tags in the middle of the output that script will run at different times on different browsers. By replacing the document.write with an innerHTML call you can move all the code into a single script and make your JavaScript far less obtrusive.