The simple types of JavaScript are numbers, strings, booleans(true and false), null, and undefined. All other values are objects. Numbers, strings, and booleans are object-like in that they have methods, but they are immutable. Objects in JavaScript are mutable keyed collections. In JavaScript, arrays are objects, functions are objects, regular expressions are objects, and, of course, objects are objects.
JS的简单类型有数字、字符串、布尔型、null和undefined，其他的值都是对象。数字、字符串、布尔型跟对象的相似之处是他们都有方法，但是数字、字符串、布尔型是不可变的，而对象是可变的带key的集合。数组是对象，函数是对象，正则表达式是对象。

An object is a container of properties, where a property has a name and a value. A property name can be any string, including the empty string. A property value can be any JavaScript value except for undefined.
对象是若干属性的集合，属性由属性名和属性值组成。属性名可以是任何字符串，甚至空字符串。属性值可以是任何除了undefined的JS值。

Objects in JavaScript are class-free. There is no constraint on the names of new properties or on the values of properties. Objects are useful for collecting and organizing data. Objects can contain other objects, so they can easily represent tree or graph structures.
对象可以包含其他对象，所以对象可以容易地表示树或者图结果。

JavaScript includes a prototype linkage feature that allows one object to inherit the properties of another. When used well, this can reduce object initialization time and memory consumption.
JS包含一个原型链接的特性，该特性允许一个对象继承另一对象的属性。如果利用好这一特性，可以减少对象的初始化时间和内存占用。

Object Literals#

var empty_object = {};

var stooge = { 
  "first-name": "Jerome", 
  "last-name": "Howard"
};

var flight = { 
  airline: "Oceanic", 
  number: 815, 
  departure: {
    IATA: "SYD", 
    time: "2004-09-22 14:55", 
    city: "Sydney"
  },
  arrival: {
    IATA: "LAX", 
    time: "2004-09-23 10:42", 
    city: "Los Angeles"
  }
};

Retrieval#

stooge["first-name"] // "Jerome" 
flight.departure.IATA // "SYD"

stooge["middle-name"] // undefined
flight.status // undefined
stooge["FIRST-NAME"] // undefined

var middle = stooge["middle-name"] || "(none)";
var status = flight.status || "unknown";

flight.equipment // undefined
flight.equipment.model // throw "TypeError"
flight.equipment && flight.equipment.model // undefined

Update#

stooge['first-name'] = 'Jerome';

stooge['middle-name'] = 'Lester'; 
stooge.nickname = 'Curly'; 
flight.equipment = {
  model: 'Boeing 777' 
};
flight.status = 'overdue';

Reference#

Objects are passed around by reference. They are never copied:

var x = stooge; 
x.nickname = 'Curly'; 
var nick = stooge.nickname; // nick is 'Curly' because x and stooge are references to the same object

 var a = {}, b = {}, c = {}; // a, b, and c each refer to a different empty object
 a = b = c = {}; // a, b, and c all refer to the same empty object

Prototype#

Every object is linked to a prototype object from which it can inherit properties. All objects created from object literals are linked to Object.prototype, an object that comes standard with JavaScript.
所有用object literal方式创建的对象跟Object.prototype对象是关联的。
When you make a new object, you can select the object that should be its prototype. The mechanism that JavaScript provides to do this is messy and complex, but it can be significantly simplified. We will add a create method to the Object function. The create method creates a new object that uses an old object as its prototype.

if (typeof Object.create !== 'function') { 
  Object.create = function (o) {
    var F = function () {}; 
    F.prototype = o; 
    return new F();
  };
} 

var another_stooge = Object.create(stooge);

The prototype link has no effect on updating. When we make changes to an object, the object’s prototype is not touched:

another_stooge['first-name'] = 'Harry'; 
another_stooge['middle-name'] = 'Moses'; 
another_stooge.nickname = 'Moe';

The prototype link is used only in retrieval. If we try to retrieve a property value froman object, and if the object lacks the property name, then JavaScript attempts toretrieve the property value from the prototype object. And if that object is lacking theproperty, then it goes to its prototype, and so on until the process finally bottoms out with Object.prototype. If the desired property exists nowhere in the prototype chain, then the result is the undefined value. This is called delegation.
The prototype relationship is a dynamic relationship. If we add a new property to a prototype, that property will immediately be visible in all of the objects that are based on that prototype:

stooge.profession = 'actor'; 
another_stooge.profession // 'actor'

Reflection#

typeof flight.number // 'number'
typeof flight.status // 'string'
typeof flight.arrival // 'object'
typeof flight.manifest // 'undefined'

typeof flight.toString // 'function' 
typeof flight.constructor // 'function'

flight.hasOwnProperty('number') // true 
flight.hasOwnProperty('constructor') // false

Enumeration#

var name; 
for (name in another_stooge) {
  if (typeof another_stooge[name] !== 'function') { 
    document.writeln(name + ': ' + another_stooge[name]);
  }
}

var i; 
var properties = ['first-name', 'middle-name', 'last-name', 'profession']; 
for (i = 0; i < properties.length; i += 1) {
  document.writeln(properties[i] + ': ' + another_stooge[properties[i]]);
}

Delete#

another_stooge.nickname // 'Moe'
  // Remove nickname from another_stooge, revealing the nickname of the prototype.

delete another_stooge.nickname; 
another_stooge.nickname // 'Curly'

Global Abatement#