javascript面向对象（二）

/创建对象：
    //最基本的   Object构造以及字面量法
    //一、工程模式创建：使用参数传值在构造
    function createObject(name,age,job){
        var o = new Object();
        o.name = name;
        o.age = age;
        o.job = job;
        o.sayName = function(){
            alert(this.name);
        };
        return o;
    }
    var person = createObject('zhd',23,'Software Engineer');
    //该方式无法确定  该对象是一个什么样的类型(都是有Object创建的)

    //二、构造函数模式：改进工厂模式
    function Person(name,age,job){  //约定俗成 首字母大写
        var o = new Object();
        this.name = name;
        this.age = age;
        this.job = job;
        this.sayName = function(){
            alert(this.name);
        };
        //也可以像下面这种方式定义，这种方式定义会导致不同的作用域链和标识符解析，例：
        //alert(person1.sayName == person2.sayName) //false
        //但创建机制还是一样的
        //this.sayName = new Function("alert(this.name");  //没有大括号 
    }
    var person = new Person('zhd',23,'Software Engineer');  //构造方法
    //每个对象都有一个 constructor指向构造函数，因此   
    alert(person.constructor == Person); // true
    alert(person instanceof Person);    //true
    alert(person instanceof Object);    //true  所有的对象均继承自Object类

    //构造函数也是函数，所有用new出来的函数，都可以做构造函数来看待
    var person = new Person('zhd',23,'Software Engineer');
    person.sayName(); // zhd
    
    Person('qi',23,'Software Engineer'); //普通函数来看待
    window.sayName(); // qi 只能是Global(浏览器时window)调用

    var o = new Object();
    Person.call(o,'qi',23,'Software Engineer'); //普通函数来看待
    o.sayName(); // qi 在 对象o中调用

    //可以把sayName()对象转移到函数体外部，this指针的存在，可以保证在构造函数调用外面的sayName()时，
    //两个对象不会产生混乱
    function Person(name,age){
        this.name = name;
        this.age = age;
        this.sayName = sayName;
    }
    function sayName(){alert(this.name);}

    //三、原型方法 
    //对于构造函数模式来讲，可以把对象中若干个函数移出构造函数体外部，成为全局变量。
    //然而，这些函数并不是真正意义上的全局变量，大多数情况下仍然是声明出来的某个对象所调用
    //况且，方法过多让大量的方法在作为全局变量游离在构造方法之外，破坏了封装型
    //可以使用原型模式来解决

    //创建的每个函数都有一个 prototype属性，这是一个指针，指向一个对象，这个对象的用途就是
    //包含可以由特定类型的所有实例共享的属性和方法
    //通过调用构造函数而创建那个对象实例的原型对象
    //好处就是让所有对象实例共享它所包含的属性和方法
    //也就是说 不必在构造函数里定义对象的信息，可以将信息直接添加到原型对象中去
    function Person(){};
    Person.prototype.name = "zhd";
    Person.prototype.age = 23;
    Person.prototype.sayName = function(){
        alert(this.name);
    };

    var person1 = new Person();
    person1.sayName(); //zhd
    var person2 = new Person();
    person1.sayName(); //zhd    //所有实例共享属性和方法，与构造函数模式不同

    alert(person1.sayName == person2.sayName); //true 没有(),这里比较的是两个指针

    //理解原型对象  （这个对象可以理解为实实在在存在的一个对象，并且与这个函数息息相关）
    //只有创建一个函数，就会根据一组特定的规则为这个函数创建一个prototype属性指向函数的原型对象。
    //默认情况下，所有的原型对象都会自动获得一个constructor属性，这个属性包含一个指向prototype属性
    //所在函数的指针。例如：Person.prototype.constructor指向Person。
    //创建自定义构造函数后，其原型对象默认只会获取constructor属性。至于其他方法都是Object继承而来
    //每创建一个新实例，该实例都会包含一个指针指向构造函数的原型对象。
    //ECMA-262第五版称之为  [[prototype]]

    //它们之间的关系就是：
    //每个新实例会有一个指针指向构造函数的原型对象。
    //给构造函数的原型对象赋值。
    //也就是说每个新实例都会得到原型对象中属性的值。
    //因此 alert(person1.sayName == person2.sayName)返回true
    //所有的实例共享构造函数的原型对象中的属性和方法

    //可以通过 isPrototypeOf() 方法来确定是否有这么一层关系
    alert(person.prototype.isPrototypeOf(person1)); //true

    //ECMAScript 5中的 Object.getPrototypeOf() 可以很方便的获取一个实例的原型对象
    alert(Object.getPrototypeOf(person1) == Person.prototype); //true
    alert(Object.getPrototypeOf(person1).name); //zhd

    //程序在读取实例属性的时候，会先后搜索两次属性的名称  以 name为例
    //第一次在实例person1中查找name
    //如果未找到，就会在person1的原型对象中查找name
    //因此可以直接在实例中，定义一个与源性对象中属性相同的名字，程序就会屏蔽原型对象中的值
    //只是在这个实例中屏蔽，不会改变原型对象的值
    var person3 = new Person();
    person3.name = 'zhdqi';
    alert(person3.name);    //zhdqi
    alert(person1.name);    //zhd   不会改变

    //delete person3.name;
    //alert(person3.name);    //zhd  删掉实例同名的属性后，就会继续访问原型对象中的值

    //可以使用 hasOwnProperty(); 判断访问的对象属性来自实例还是来自原型对象
    alert(person1.hasOwnProperty("name")); //false 来自原型
    alert(person3.hasOwnProperty("name")); //true 来自实例对象  

    //in操作符：可以确定在实例中能否访问某个属性，无论属性是实例还是原型对象
    alert("name" in person1); //true name来自原型对象 只要能访问到 就是true
    alert("name" in person3); //true  name来自实例本身

    //同时使用hasOwnProperty和in能够确定访问的属性的值来自与原型对象还是实例本身
    function hasPrototypeProperty(object,name){
        return !hasOwnProperty(name)&&(name in object);
    } 
    alert(hasPrototypeProperty(person1,'name')); //true 能访问 且来自原型对象
    alert(hasPrototypeProperty(person3,'name')); //true 能访问 来自实例本身

    //for-in能够访问对象中可枚举的属性（不论属性来自实例还是原型对象）
    //如果原型对象某属性屏蔽了可枚举性，但实例中重新定义了该属性，那么for-in也是可以访问的
    //使用 Object.keys(),会返回一个对象中所有可枚举实例属性的字符串数组 注意：是实例属性
    alert(Object.keys(person.prototype)); //'name','age','job'
    alert(Object.keys(person3)); //'name' 实例对象的属性

    //Object.getOwnPropertyNames(Person.pertotype) 返回所有实例的属性
    alert(Object.getOwnPropertyNames(Person.pertotype)); //constructor,name,age,job,sayName

    //更简单的语法
    function Person(){}
    Person.prototype = {
        name:'zhd',
        age:23,
        job:'Software Engineer',
        sayName:function(){alert(this.name);}
    }

    //！！！这样相当于重写了 prototype对象，因此 constructor指向新的constructor对象（Object）    
    //原型对象是一个已经存在的对象，因此可以在上面随意的增加删除属性与方法
    //但是使用字面量法重新定义之后，就相当于重写该方法
    //使用instanceof操作符还会有正确的结果，但是constructor无法确定对象的类型了
    var friend = new Person();
    alert(friend instanceof Object); // true
    alert(friend instanceof Person); // true
    alert(friend.constuctor == Person); // false
    alert(friend.constuctor == Object); // true
    //假如constuctor值很重要
    Person.prototype = {
        //constuctor:Person,      //可以直接指定  但这样会变成可枚举类型，而默认是不可枚举的
        name:'zhd',
        age:23,
        job:'Software Engineer',
        sayName:function(){alert(this.name);}
    }
    Object.defineProperty(person.prototype,"constructor",{
        enumerable:false,   //重设constructor，使其变成不可枚举的值
        value:Person 
    });

    //实例与构造函数之间是一种松散关系，可以在原型对象上任意定义与删除方法都可以反映在实例上
    //pertotype作为实例与构造函数之间的桥梁
    //一旦重写了pertotype,就相当于切断了这层关系
    function Person(){}
    var friend = new Person();
    Person.prototype = {        //重写了方法  桥梁被切断
        constuctor:Person,
        name:'zhd',
        age:23,
        job:'Software Engineer',
        sayName:function(){alert(this.name);}
    }
    alert(friend.sayName); // undefined 他引用的依旧是最原始的原型对象

    //原生对象的原型：即 Object,Array,String等原生引用类型的方法也是可以在其原型对象上找到
    //例如 可以在 Array.prototype找到sort()方法，也可以在String.prototype中找到substring方法

    //通过原生对象的原型，可以在原生类型上随时添加新的方法
    //例  在String添加一个 startsWith()
    String.prototype.startsWith = function(text){
        return this.indexOf(text) == 0;
    }   
    var msg = "hello world";
    alert(msg.startsWith('hello')); //true

    //原型对象的局限性
    //这种创建对象的方式是基于共享的，在原型对象中，每一个实例都可以重新定义（修改）原型中已有的属性
    //且不会共享。但是，如果原型中带有引用类型的变量，例如，原型中有一个数组，那么在对数组进行操作而没有
    //重新定义的时候，那么这个被操作的数组就会被所有实例所共享
    function Person(){}
    Person.prototype = {        //重写了方法  桥梁被切断
        constuctor:Person,
        name:'zhd',
        age:23,
        likecolor:['red','green'],
        job:'Software Engineer',
        sayName:function(){alert(this.name);}
    }
    var person1 = new Person();
    var person2 = new Person();
    person1.likecolor.push('blue');   //这里会共享
    alert(person1.likecolor);   //red green blue
    alert(person2.likecolor);   //red green blue
    alert(person1.likecolor == person2.likecolor); //true

    //四、结合构造函数模式以及原型对象模式创建对象  最流行的一种方法
    //构造函数模式用于 定义实例属性
    //原型对象模式    定义实例方法以及共享的属性
    //每个实例都有自己的一份属性的副本，且共享着对方法的引用
    function Person(name,age,job){
        this.name = name,
        this.age = age,
        this.job = 'Software Engineer'
    }
    Person.pertotype = {
        constuctor:Person,
        sayName:function(){
            alert(this.name);
        }
    }
    //五、动态原型模式
    //所谓动态原型，就是追求一种封装的效果。将原型对象的方法放到了构造函数中，通过if判断的方式动态的加载原型对象的方法
    //判断只需要判断其中一个方法（如果有若干个方法的话），作用就是判断构造函数是否已经加载了原型对象中的方法
    //与原型模式一样，使用字面量法重写原型会切断实例与构造函数之间的桥梁
    function Person(name,age,job){
        this.name = name;
        this.age = age;
        this.job = job;

        //if(Person.pertotype.method == undefined)  /这样写也可以
        if(typeof this.sayName != "function"){
            //加载原型对象的函数到构造函数
            Person.pertotype.sayName = function(){
                alert(this.name);
            };
        }
    }
    //六、寄生构造函数模式  与工厂模式基本相同
    function Person(name,age){    //函数名称不再是  createObject
        var o = new object();
        o.name = name;
        o.age = age;
        o.sayName = function(){
            alert(this.name);
        };
        return o;
    }
    var person1 = new Person('zhd',23);
    person1.sayName(); // zhd

    //在特殊场合下使用这种方式，但无法通过 instanceof 确定对象的类型，与工厂模式类似
    //比如创造一个具有一个额外方法的特殊数组，由于不能修改Array函数，那么可以这么做：
    function SpecialArray(){
        var array = new Array();  //先创建一个数组
        array.push.apply(array,arguments);  //调用apply方法接受SpecialArray的参数给array的push赋值，进而给数组赋值
        array.toPipeString = function(){
            return this.join("|");
        };
        return array;   //返回数组
    }
    var colors = new SpecialArray("red","green","blue");  // red，green,blue
    colors.toPipeString(); //red|green|blue

    //七、稳妥构造函数模式 ：与寄生构造模式类型，但 1.新创建的实例方法不引用this 2.不能使用new调用构造函数
    //使用于较为安全的环境（禁止使用this于new）
    //由于没有this和new，构造函数中的数据成员无法被外部访问，只能被函数体内定义好的方法来访问
    //在外部添加方法时，不能使用this指针，也无法在方法体内引用函数的数据成员变量
    function Person(name,age){
        var o = new Object();
        //定义若干方法
        o.name = name;
        o.age = age;

        o.sayName = function () {
          alert(name);  
        };
        return o;
    }
    var friend = Person('zhd',23);
    friend.sayName(); //zhd
    //alert(friend.name);  //浏览器会忽略这条语句