经典继承封装函数
o1.__proto__===O.prototype===o2
构造函数的实例的__proto__和构造函数的prototype是全等于的
function craeate(obj){
function F(){};
F.prototype=obj;
return new F();
}

ES5(IE9+)支持Object.create()固定方法
var o1={name:"男"};
var o2=Object.create?Object.create(o1):create(o1);能力检测

原型链：任何对象都是继承自原型对象，原型对象也有它自己的原型对象,总是有一个对象，是没有
__proto__属性的，这个对象，就是原型链的顶端
var o={};
console.log(o.__proto__);
var arr=[];
console.log(arr.__proto__.__proto__);
var f1=function(){};
console.log(f1.__proto__.__proto__);
var reg=/[0-3]/;
console.log(reg.__proto__.__proto__);

任何一个对象的prototype都定义了一个toString()
obj.toString()---->"[object Object]"
arr.toString()---->"1,2,3"
reg.toString()---->"/hello/"正则表达式的字符串类型
判断内置对象的时候,可以使用Object.prototype.toString.call(对象)
得到"[object 对象的数据类型]"
Object.prototype.toString.call(arr)
Object.prototype.toString.call(reg)
Object.prototype.toString.call(new Date())得到一个[object,数据类型]

判断一个对象是否拥有自己的属性hasOwnProperty,返回布尔类型
o.hasOwnProperty("属性")

判断当前对象是否是参数对象的原型对象isPrototypeOf
ar o1={};
Object.prototype.isPrototypeOf(o1)返回布尔值

判断当前对象的某个属性是否是可枚举的propertyIsEnumerable,所谓不可枚举的属性就是不能被
for(key in o)遍历
Object.defineProperty(obj,"gender",{value:"男"})给obj增加不可以枚举属性"gender"
value属性给gender设置了值,还有别的属性enumerable:false默认为false,为true时表示是可枚举
属性,
writable:true可写的对象,为true时才能被赋值运算,writable:false时不能赋值运算,默认为false
get:function(){return "男"}return的值就是属性设置的值,外面就不用写value了
set接受唯一参数,并将该参数的新值分配给属性gender
var _number;
var o2={};
Object.defineProperty(o2,"number",{
get:function(){//获取number属性值的时候就会执行这个函数
return _number || 0;
},
set:function(v){
if(v>50){
_number=v;
}
}
});
o2.number=35;//把35赋值给v

a instanceof b 检测a是否是b的实例,任何对象都是Object的实例
var apple=new Computer();
console.log(apple instanceof Computer);
console.log(apple instanceof Object);

var arr=[];
console.log(arr instanceof Array);//true
console.log(arr instanceof Object);//true

var reg=/word/;
console.log(reg instanceof RegExp);//true
console.log(reg instanceof Object);//true

所以检测一个数据的对象类型这里有两种方法,比如检测对象是不是数组
[] instanceof Array Object.prototype.toString.call([])==="[object Array]"