Awful Parts(Appendix A. of JavaScript: The Good Parts)

　　1. Global Variables

　　There are three ways to define global variables. The first is to place a var statement outside of any function:

　　var foo = value;

　　The second is to add a property directly to the global object. The global object is the container of all global variables. In web browsers, the global object goes by the name window:

　　window.foo = value;

　　The third is to use a variable without declaring it. This is called implied global:

　　foo = value; 

　　2. Scope

　　JavaScript's syntax comes from C. In all other C-like languages, a block (a set of statements wrapped in curly braces) creates a scope. Variables declared in a block are not visible outside of the block. JavaScript uses the block syntax, but does not provide block scope: a variable declared in a block is visible everywhere in the function containing the block. 

　　3. Semicolon Insertion

　　JavaScript has a mechanism that tries to correct faulty programs by automatically inserting semicolons. Do not depend on this. It can mask more serious errors.It sometimes inserts semicolons in places where they are not welcome. Consider the consequences of semicolon insertion on the return statement. If a return statement returns a value, that value expression must begin on the same line as the return:

　　return
　　{
    　　status: true
　　};

　　This appears to return an object containing a status member. Unfortunately, semicolon insertion turns it into a statement that returns undefined. There is no warning that semicolon insertion caused the misinterpretation of the program. The problem can be avoided if the { is placed at the end of the previous line and not at the beginning of the next line:

　　return {
    　　status: true 

　　}; 

　　4. Reserved Words

　　5. Unicode

　　JavaScript was designed at a time 
when Unicode was expected to have at most 65,536 characters. It has since grown 
to have a capacity of more than 1 million characters.
　　JavaScript's characters are 16 bits. That 
is enough to cover the original 65,536 (which is now known as the Basic 
Multilingual Plane). Each of the remaining million characters can be represented 
as a pair of characters. Unicode considers the pair to be a single character. 
JavaScript thinks the pair is two distinct characters.
　　6. typeof
　　typeof null returns 'object' instead of 'null'. 
　　7. parseInt
　　parseInt is a function that 
converts a string into an integer. It stops when it sees a nondigit, so 
parseInt("16") and parseInt("16 tons") produce the same result. It would be nice if the 
function somehow informed us about the extra text, but it doesn't.
　　If the first character of the string 
is 0, then the string is evaluated in base 8 instead of base 10. In base 8, 8 
and 9 are not digits, so parseInt("08") and parseInt("09") produce 0 as their result. This error causes problems 
in programs that parse dates and times. Fortunately, parseInt can take a radix parameter, so that 
parseInt("08", 10) produces 8. I recommend that you always provide the 
radix parameter.
　　8. +
　　The + operator can add or concatenate. Which one 
it does depends on the types of the parameters. If either operand is an empty 
string, it produces the other operand converted to a string. If both operands 
are numbers, it produces the sum. Otherwise, it converts both operands to 
strings and concatenates them. This complicated behavior is a common source of 
bugs. If you intend + to add, make sure that 
both operands are numbers.
　　9. Floating Point
　　Binary floating-point numbers are 
inept at handling decimal fractions, so 0.1 + 0.2 is not equal to 0.3. This is 
the most frequently reported bug in JavaScript, and it is an intentional 
consequence of having adopted the IEEE Standard for Binary Floating-Point 
Arithmetic (IEEE 754). This standard is well-suited for many applications, but 
it violates most of the things you learned about numbers in middle school. 
Fortunately, integer arithmetic in floating point is exact, so decimal 
representation errors can be avoided by scaling.
　　For example, dollar values can be 
converted to whole cents values by multiplying them by 100. The cents then can 
be accurately added. The sum can be divided by 100 to convert back into dollars. 
People have a reasonable expectation when they count money that the results will 
be exact.
　　10. NaN
　　11. Phony Arrays
　　JavaScript does not have real 
arrays. That isn't all bad. JavaScript's arrays are really easy to use. There is 
no need to give them a dimension, and they never generate out-of-bounds errors. 
But their performance can be considerably worse than real arrays.
　　The typeof operator does 
not distinguish between arrays and objects. To determine that a value is an 
array, you also need to consult its constructor property:
　　if (my_value && typeof my_value === 'object' &&
        my_value.constructor === Array) {
    　　// my_value is an array!
　　}
　　That test will give a false 
negative if an array was created in a different frame or window. This test is 
more reliable when the value might have been created in another frame:
　　if (my_value && typeof my_value === 'object' &&
        typeof my_value.length === 'number' &&
        !(my_value.propertyIsEnumerable('length')) {
    　　// my_value is truly an array!
　　}
　　12. Falsy Values
　　13. hasOwnProperty