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#