js面向对象的程序设计 --- 中篇(创建对象) 之 工厂模式和 构造函数模式

创建对象
    虽然Object构造函数或对象字面量都可以用来创建单个对象，但这些方式有个明显的缺点：使用同一个接口创建很多对象，会产生大量重复代码。

    ·工厂模式
        工厂模式是一种广为人知的设计模式，这种模式抽象了创建对象的具体过程。考虑到ECMAScript中无法创建类，开发人员就发明了一种函数，用函数来封装
            以特定接口创建对象的细节

        // code...

function createPerson(name ,age ,job){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function () {
        console.log(this.name);
    }
    return o;
}
var person = createPerson("tom",25,"coder");
console.log(person);  //{name: "tom", age: 25, job: "coder", sayName: ƒ}

        工厂模式虽然解决了创建多个相似对象的问题，但是没有解决对象识别的问题（即怎样知道一个对象的类型），随着js的发展，又一个新的模式出现了

    ·构造函数模式
        ECMAScript 中的构造函数可以用来创建特定类型的对象。像Object，Array这样的原生构造函数，在运行时会自动出现在执行环境中。此外也可以
            创建自定义的构造函数，从而创建自定义类型的属性和方法
        // code  ..

function Person(name , age , job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function () {
        console.log(this.name);
    }
}
var person_a = new Person('lee',33,'doctor');
console.log(person_a);  //Person {name: "lee", age: 33, job: "doctor", sayName: ƒ}
var person_b = new Person('wang',22,'model');
// 这两个对象都有一个 constructor (构造函数)属性，都指向Person
console.log(person_a.constructor == Person);  // true
// 对象的constructor属性最初是来标识对象类型的。但是提到检测对象类型，还是instanceof操作符更可靠一些
console.log(person_a instanceof  Person);  // true
console.log(person_a instanceof Object);  // true
// 可以得出，我们在这个例子中创建的所有对象既是Object的实例也是Person的实例
//  创建自定义的构造函数意味着将来可以将它的实例标识为一种特定的类型；这正是构造函数模式胜过工厂模式的地方。在
    //这个例子中，person_a和person_b之所以同时是Object的实例，是因为所有对象均继承自Object。

console.log(person_a.sayName == person_b.sayName);  // false

        这种方式调用构造函数实际上会经历4个步骤：
            1，创建一个新对象
            2，将构造函数的作用域给新对象（因此this就指向了这个对象）
            3，执行构造函数中的代码（为这个对象添加属性）
            4，返回新对象

        构造函数的缺点：
            每个方法都要在每个实例上重新创建一遍，在前面的例子中，person_a和person_b都有一个名为sayName()方法，但两个方法不是同一个Function实例
                。不要忘记---  ECMAScript中的函数是对象，因此每定义一个函数，也就是实例化了一个对象。
                显然：创建两个完成同样任务的Function实例的确没有必要；况且有this对象在，根本不用在执行代码前就把函数绑定到特定对象上面。
                因此，大可向下面这样，通过把函数定义到构造函数外部来解决这个问题
                // code..

function Cat(){
    this.cry = miao;
 }
 function miao(){
    console.log("miao~~");
 }
 var cat = new Cat();
cat.cry(); // miao~~

            由于this.cry指针指向了外部的miao()函数，那么，所有由Cat构造函数创建的对象就共享了在全局作用域中定义的同一个miao()函数。这样做确实解决了
                两个函数做同一件事的问题。可以新问题又来了：在全局作用域中定义的函数实际上只能被某个对象调用，这让全局作用域有点名不其实；
                更让人无法接受的是：如果对象需要定义很多方法，那么就要定义很多个全局函数，于是我们这个自定义的引用类型就丝毫没有封装性可言了。
                好在，这个问题可以通过原型模式解决