对象

1.对象字面量
用来创建新对象值，位置不限，包含多个“名值”对

var empty_object = {};
var stooge = {
    "first-name" : "zhang",
    "last-name" : "fei"
}

属性名称如果是一个合法的JS标识符且不是保留字
我们可以不用引号将属性包起来
但是像first-name这种就必须用引号了

var flight = {
    airline : "BeiJing",
    number : 212,
    departure : {
        IATA : "GZ",
        time : "2000-12-12 10:00",
        city : "GuangZhou"
    },
    arrival : {
        IATA : "SH",
        time : "2000-12-12 22:40",
        city : "ShangHai"
    }
}

2.检索
使用[]的访问被“”包含的字符串属性

alert(stooge['first-name']);    // zhang
alert(flight['number']);        // 212

使用.访问合法的JS表示符表示的属性，优先使用

alert(flight.number);       // 212
alert(stooge.first-name);       //NaN

如果访问一个不存在的属性，那么返回undefined

alert(flight.price);        // undefined

可以用||填充默认值

var price = flight.price || "$100";
alert(price);       // $100

访问undefined的属性会抛出TypeError异常，可以使用&&屏蔽错误

alert(alert(flight.price));     // undefined
alert(flight.price.cheap);  // 抛出异常
alert(flight.price && flight.price.cheap);      // undefined

3.更新
对于对象中存在的属性，可以直接通过赋值修改

stooge["first-name"] = "li";
alert(stooge["first-name"]);    // li

对于对象中不存在的属性，直接扩充到对象中

stooge["middle-name"] = "xiao";
alert(stooge["middle-name"]);   // xiao

4.引用
对象通过引用来传递，从来不会被拷贝

var zhang = stooge;
zhang.nickname = "tom";
alert(stooge.nickname);     // tom
// zhang和stooge引用同一个对象，只是两个不同的指针
var a = {}, b = {}, c = {};
// 引用三个不同的对象
a = b = c = {};
// 引用一个对象

5.原型
每个对象都连接一个原型，可以继承原型中的属性
所有的通过对象字面量创建的对象都连接到Object.prototype这个标准的JS原型
当你创建对象时，可以选择某个对象作为它自己的原型

if (! typeof Object.beget != "function") {
    Object.beget = function (o) {
        var F = function () {};
        F.prototype = o;
        return new F();
    }
}
var another_stooge = Object.beget(stooge);
alert(another_stooge['first-name']);    // zhang
alert(another_stooge['last-name']);     // fei

委派的过程：查找对象的属性 –> 查找原型对象的属性 –> 查找原型的属性 …–> Object.prototype中去
例如查找another_stooge的’first-name’的属性值，首先从该对象开始，然后去原型对象stooge中，找到了
如果没有找到，继续到原型中找，一直找到Object.prototype中，如果没有，则返回undefined
6.反射
检测对象有什么类型的属性很容易，用typeof

alert(typeof stooge['first-name']);     // string
alert(typeof flight.number);            // number

原型链中的任意一个属性都会返回一个值

alert(typeof flight.constructor);       // function 
alert(typeof flight.toString);          // function 
alert(typeof Object.beget);                 // function 
function Person () {
    this.name = "zhang";
}
Person.prototype.getName = function () {
    return this.name;
}
var p = new Person();
alert(typeof p.name);       // string
alert(typeof p.getName);    // function

处理不需要的属性，用hasOwnProperty,如果实例对象有属性返回true，否则返回false。它不会检查原型链属性

var p = new Person();
p.name = "li";
alert(p.hasOwnProperty("name"));    // true

7.枚举
for in语句遍历对象的所有属性，包含函数或者原型中的你可能不关心的属性

for(var s in flight) {
    if(typeof flight[s] !== "function") {
        // airline = BeiJing number = 212 departure = [object Object] arrival = [object Object] 
        document.writeln(s + " = " + flight[s]);
    }
}

按照特定的顺序返回，那么可以将数组和for循环结合起来实现

var index = ["arrival", "airline", "departure", "number"],
    i, len;
for(i = 0, len = index.length; i < len; i++) {
    // arrival = [object Object] airline = BeiJing departure = [object Object] number = 212 
    document.writeln(index[i] + " = " + flight[index[i]]);
}

8.删除
delete可以删除对象中的属性，但是它不会触发原型链中的任何对象
delete删除对象中的属性，可以把原型中的值显示出来

another_stooge['first-name'] = "li";
alert(another_stooge['first-name']);    // li
delete another_stooge['first-name'];
alert(another_stooge['first-name']);    // zhang

9.减少全局污染
将你的应用程序全部打包到一个唯一的全局变量中

var MYAPP = {};
MYAPP.stooge = {
    "first-name" : "zhang",
    "last-name" : "fei"
}
MYAPP.flight = {
    airline : "BeiJing",
    number : 212,
    departure : {
        IATA : "GZ",
        time : "2000-12-12 10:00",
        city : "GuangZhou"
    },
    arrival : {
        IATA : "SH",
        time : "2000-12-12 22:40",
        city : "ShangHai"
    }
};
alert(MYAPP.stooge['first-name']);// zhang
alert(MYAPP.flight.number);     // 212