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的簡(jiǎn)單類型有數(shù)字、字符串、布爾型蔬捷、null和undefined君编，其他的值都是對(duì)象悦污。數(shù)字猴蹂、字符串燕雁、布爾型跟對(duì)象的相似之處是他們都有方法，但是數(shù)字眉菱、字符串迹栓、布爾型是不可變的，而對(duì)象是可變的帶key的集合俭缓。數(shù)組是對(duì)象克伊，函數(shù)是對(duì)象，正則表達(dá)式是對(duì)象华坦。

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.
對(duì)象是若干屬性的集合愿吹，屬性由屬性名和屬性值組成。屬性名可以是任何字符串季春，甚至空字符串洗搂。屬性值可以是任何除了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.
對(duì)象可以包含其他對(duì)象载弄，所以對(duì)象可以容易地表示樹(shù)或者圖結(jié)果。

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包含一個(gè)原型鏈接的特性撵颊，該特性允許一個(gè)對(duì)象繼承另一對(duì)象的屬性宇攻。如果利用好這一特性，可以減少對(duì)象的初始化時(shí)間和內(nèi)存占用倡勇。

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方式創(chuàng)建的對(duì)象跟Object.prototype對(duì)象是關(guān)聯(lián)的逞刷。
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#