javascript对象

1.定义：
　　面向对象：在程序中都是用一个对象来描述现实中一个具体的东西
　　3大特点：封装 继承 多态
　　什么是对象：封装多个数据和方法的存储空间
2.创建自定义对象(4种)：
　　1.对象直接量　　　　

　　　　var obj={
　　　　　　"attbuteName":value,
　　　　　　...:...,
　　　　　　"mothodName":function(){...this.attbuteName...}

　　2.new Object();
　　　　var obj=new Object();//创建一个空对象
　　　　obj.attbuteName=value;
　　　　obj.mothodName=function(){...this.attbuteName...};
　　3.利用构造函数反复创建相同结构的对象(构造函数：描述一类对象结构的特殊函数)

//定义构造函数 Student
function Student(sname,age){
this.name=name;
this.age=age;
this.intrSelf=intrSelf=function(){alert("I'm "+this.sanme+",I'm "+this.age);}
}
//利用构造函数创建对象：
var liLei=new Student("Li Lei",12);
var hmm=new Student("Han Meimei",11);

　　4.Object.create(父对象,{扩展属性的列表对象})　

　　5.访问属性(2种方法): obj.属性名 obj["属性名"]

　　　　(访问数组中不存在的下标):不会报错，放回undefined
　　　　强行给不存在的属性赋值，不会报错，js会自动创建同名属性
　　6.判断某个对象是否包含制定成员(3种):
　　　　obj.hasOwnProperty("成员名")
　　　　"属性名" in 对象
　　　　直接使用 obj.对象名作为条件

/*
        String类型提供了trim方法，但IE8没有
        判断当前浏览器的String类型是否包含trim方法
        如果不包含，自定义公共trim方法
    */
    if(!String.prototype.trim)
    {
        String.prototype.trim=function(){
            return this.replace(/^s|s$/g,"");
        }
    }
    var str="   Hello World !    ";
    document.write(str.trim());

3.this
　　如何在方法中，访问当前对象自己(使用this)；
　　this关键字：运行时，指代正在调用方法的对象(.当前对象)
　　this本质是window下唯一一个指针，指向当前正在调用方法的对象
　　在方法内访问当前对象自己的属性，必须使用this.属性名
　　***this和定义在哪无关！仅和调用时使用的当前对象有关
　　***如果无主的调用或赋值，默认this都是window

/*this.*/a=100;
//window.a=100;
(function(){
    var a=99;
    console.log(this.a);  //window.a
})(); //100
//***如果无主的调用或赋值，默认this都是window

/*鄙视题*/
    //this-->window
    var a=2;
    //this-->window
    function fun(){
        console.log(this.a);
    }
    //this-->window
    var o={a:3,fun:fun};//this-->o
    var p={a:4};//this-->p
    o.fun(); //this-->o    3
     console.log(o.a) //3

    (p.fun=o.fun)(); //2 == fun()
        /*赋值表达式的结果相当于等号右侧表达式*的值**/   

4.继承
　　js中一切继承都是用原型对象实现的
　　原型对象：每个函数对象都有一个原型对象
　　构造函数的原型对象负责保存所有子对象共享的成员
　　建议：所有子对象共享的方法，都应该定义在构造函数的原型对象中。--避免重复定义方法对象，浪费内存
　　说明：所有内置对象类型的API都定义在类型[type].prototype中

//在构造函数原型对象中定义公共方法
Student.prototype.intrSelf=function(){
    alert("I'm "+this.sname+",I'm "+this.age);
}
var lilei=new Student("Li Lei",12);
var hmm=new Student("Han Meimei",11);
//在构造函数原型对象中定义公共属性
Student.prototype.money=100;
console.log(lilei.money);
     //先在当前对象本地找
     //找不到再去查找原型链
    //原型链也没有，才返回undefined 
console.log(hmm.money); 14 /* 定义在构造函数的原型对象中,避免了实例化重复定义方法，减少内存的占用 15 */

//使用Object.create创建对象继承

//父对象
var father={car:"BMW",balance:100000000};
//继承父对象
var hmm=Object.create(father,
    {sing:{value:sing},//扩展方法
    sname:{value:"Han Meimei"},//扩展属性
    age:{value:18,writable:false},//扩展属性 不可写
    intrSelf:{value:intrSelf}//扩展方法
    }
);
//扩展方法
function intrSelf(){
        alert("我是"+this.sname+",今年"+this.age);
    }
function toString(){
    return "{sname:"+this.sname+", age:"+this.age+"}";
    }    

js模拟Java中的继承(仅继承结构):

function 子类型构造函数(属性参数1,属性参数2,属性参数3){
　　父类型构造函数.call(this,属性参数1,属性参数2); //在子构造函数中强行调用父函数的构造函数，继承父构造函数中结构，但是无法继承父函数的原型结构(不再同一条原型链上)
　　this.属性3=属性参数3;
}

5.扩展对象属性(2种)：

　　1.扩展共有属性：通过构造函数.prototype添加属性
　　2.扩展自有属性：通过某一个具体子对象添加属性
　　判断自有属性或公共属性：
　　　　1.判断自有属性：obj.hasOwnProperty("属性名")
　　　　2.判断共有属性："属性名" in obj && !obj.hasOwnProperty("属性名") //在原型关系中包含且子对象自己没有
6.删除属性 delete 对象.属性名 //仅能删除当前对象自己的属性，无法删除共有属性

//全局变量3中
var n=1;
delete n;//不能删除  
window.n=1;
delete window.n;//不能删除
var window["n"]=1;
delete window.n;//可以删除

7.原型链：由各级对象的__proto__逐级继承形成的关系

//判断原型链
    var monkey={
        hair:true,
        feeds:"bananas"
    }
    function Human(name){
        this.name=name;
    }

    Human.prototype=monkey;
    var geoge=new Human("Geoge");
    console.log(monkey.isPrototypeOf(geoge));//true
    console.log(Object.prototype.isPrototypeOf(monkey));//true

 0 //判断array数组的类型
 1 document.write(typeof("Hello")+"<br>"); //string
document.write(typeof(123)+"<br>"); //number
document.write(typeof({a:1})+"<br>"); //object
document.write(typeof([])+"<br>"); //object
document.write(Array.isArray([])+"<br>"); //true
//如果当前浏览器的Array构造函数对象中不包含isArray
if(!Array.isArray){
//为Array构造函数添加isArray方法
    Array.isArray=function(obj){//4种
    //判断obj是不是数组类型
    //1. 如果Array.prototype在obj的原型链中
         return Array.prototype.isPrototypeOf(obj);
    //2. instanceof: 
        //语法：obj instanceof 构造函数名
        //判断obj对象是否被构造函数创建
        return obj instanceof Array;
        //实例：一个构造函数创建出的每个具体对象
    //3. 原型对象的constructor属性
        return obj.constructor==Array;
    //4. 利用Object原型的toString方法
        /*call,applycall,在调用方法的一瞬间更换调用方法的对象*/
        return Object.prototype.toString.call(obj)== "[object Array]";
    }
}
document.write(Array.isArray([])+"<br>");  //true
document.write(Array.isArray({})+"<br>"); //false