对象枚举

枚举，也称遍历。

1. for in

var obj = {
    name : '12',
    age : 123,
    sex : 'male',
    height : 456,
    weight : 123
}
for(var prop in obj){
    console.log(prop + '' + typeof(prop));   //name string
                                             //age string
                                             //sex string
                                             //height string
                                             //weight string
    console.log(obj.prop + "" + obj[prop]);  //undefined 12
                                             //undefined 123
                                             //undefined male
                                             //undefined 456
                                             //undefined 123
}

var obj1 = {
    a : 123,
    b : 456,
    c : 789
}
var key;
for(key in obj1){
    obj1[key] ++;
}

上例中，不管是prop还是key，都是字符串，若写成obj.prop，系统会自动转化成obj["prop"],这样系统会去寻找obj的prop属性，结果返回undefined。

所以在遍历属性值时应该写成obj[prop]和obj1[key]。

1.1 hasOwnProperty

hasOwnProperty() 方法是 Object 的原型方法（也称实例方法），它定义在 Object.prototype 对象之上，所有 Object 的实例对象都会继承 hasOwnProperty() 方法。

hasOwnProperty(propertyName)方法是用来检测属性是否为对象的自有属性，如果是，返回true，否则false; 参数propertyName指要检测的属性名；

hasOwnProperty() 只会检查对象的自有属性，对象原型上的属性其不会检测。

var obj = {
    name : '12',
    age : 123,
    sex : 'male',
    height : 456,
    weight : 123,
    __proto__ : {
        lastName : "deng"
    }
}
for(var prop in obj){
    if(obj.hasOwnProperty(prop)) {
    console.log(obj[prop]);   //12
                              //123
                              //male
                              //456
                              //123
    }
    console.log(obj[prop]);   //12
                              //123
                              //male
                              //456
                              //123
                              //deng
}

1.2 in

如果指定的属性在指定的对象或其原型链中，则in运算符返回true。

例如上例中

'lastName' in obj;  //true
'sex' in obj;  //true
'prop' in obj; //false

1.3 instanceof

A instanceof B：判断A对象是不是B构造函数构造出来的。

看A对象的原型链上有没有B的原型。

function Person() {}
var person = new Person();

person instanceof Person;  //true 
person instanceof Object;  //true

2. 机器识别[]和{}

2.1 constructor

[].constructor; //function Array() { [native code] }
var obj = {};
obj.constructor;  //function Object() { [native code] }

2.2 instanceof

[] instanceof Array;  //true
var obj = {};
obj instanceof Array;  //false

优点：instanceof可以弥补Object.prototype.toString.call()不能判断自定义实例化对象的缺点。

缺点：instanceof 只能用来判断对象类型，原始类型不可以。并且所有对象类型instanceof Object都是true，且不同于其他两种方法的是它不能检测出iframes。

2.3 call toString

Object.prototype.toString.call([]);  //"[object Array]"
Object.prototype.toString.call({});  //"[object Object]"

每一个继承Object的对象都有toString方法，如果toString方法没有重写的话，会返回[object type]，其中 type 为对象的类型。

优点：这种方法对于所有基本的数据类型都能进行判断，即使是null、undefined或者是包装类。且和Array.isArray方法一样都检测出iframes。

缺点：不能精准判断自定义对象，对于自定义对象只会返回[object Object]。

2.4 Array.isArray()

ECMAScript提供了Array.isArray()方法，能够确定括号内的值是否为数组。