Objects: 

Prototype lookup affects only property retrieval. it does not affect updates.
so if y's prototype is x, and x.a = 1, then y.a equals 1, but setting y.a = 2
creates a new property a in y with value 2, and x.a remains 1.  (this can be
useful as a form of copy on write.) Use o.hasOwnProperty('p') to check if p is
directly in o, without looking up o's prototype chain.  Properties can be
deleted with: delete o.p;

A property name can be any name including the empty string, reserved word,
or a name that would be illegal as an identifier (e.g. 'some-name')
In object literals of the form: {p1: v1, p2: v2}), quotes around the 
p's are not required unless the name of the property is not a legal identifier, 
e.g. {'break': 1}

Functions:

new is called on an arbitrary *function*. new F() creates a new object with
its prototype link set to *F's prototype*, and runs F with 'this' set to the
new object. F implicitly returns "this", though funnily, it can return
anything, not only the object just created (in a sense, F behaves like a
factory method, with the implicit behaviour that a new object is created 
when F is entered due to a "new F" statement).  Further, calling F() instead of new
F() is legal, and can cause strange behavior because 'this' is bound to the
global object instead of the newly created object. Hence it is strongly
recommended that functions intended to be used as constructors be capitalized.
F's prototype acts like a "class" and can hold variables and methods
common to all instances of that class.

Functions are objects and themselves can have methods. A useful method is
f.apply(o, args), which is like o.f(args), with the advantage that f 
doesn't have to be a member of o and can be chosen at run time.

Functions can have inner functions, but strangely, 'this' is bound to the
global object instead of the 'this' of the outer function. A common workaround
is to assign var that = this in the outer function and use 'that' in the
inner.

Private members: See http://crockford.com/javascript/private.html

Gotchas:
be careful with /* comments. The string */ can easily occur inside regular expressions.

Semicolons can be inserted automatically, so be careful with line breaks.
The expression for a return value must begin on the same line as the return. so:
return 
1;
actually returns undefined, not 1.

There is no block scope, only function scope.
so the 2 a's here refer to the same variable.
{ a = 1; { var a; } }
Hence the common idiom of defining a function
with no name and no args and calling it immediately:
(function() { var x; ...})();
This avoids interference with the outer scope.

All numbers are 64bit floats. there are no "integers".
Therefore int1/int2 always returns a float, and needs an parseInt(int1/int2) cast to perform integer division.

An if condition is true iff it's not one of the following six: 
0, null, Nan, undefined, false, '' (empty string)

Good references for JS:
http://developer.mozilla.org/en/A_re-introduction_to_JavaScript
http://blog.firetree.net/2005/06/16/object-orientated-javascript/
Douglas Crockford's Javascript: the good parts.