JavaScript创建对象方式及性能问题

通过Object构造函数或者字面量创建对象

    var obj01 = new Object();
    var obj02 = {};

• 弊端：无论通过Object来创建对象, 还是通过字面量来创建对象都存在一个弊端,每次创建都需要重新编写一次, 如果创建的多个对象的属性和方法名称一样，浪费时间

通过工厂函数创建对象

//所以我们可以通过工厂函数来创建对象
     */
    // 工厂函数
    function createPerson(name, age) {
        // 1.通过Object创建一个空对象
        // var obj = new Object();
        var obj = {};
        // 2.动态的给空对象添加属性和方法
        obj.name = name;
        obj.age = age;
        obj.say = function () {
            console.log("hello");
        };
        // 3.将函数中创建的对象返回给调用者
        return obj;
    }
    var obj1 = createPerson("luodou", 13);
    var obj2 = createPerson("doudou", 18);
    console.log(obj1);
    console.log(obj2);

    console.log(typeof obj1); // object
    console.log(obj1.constructor); // ƒ Object() { [native code] }

• 工厂函数实质上是Object或字面量创建对象的封装，调用函数即可创建对象
• 弊端：通过Object对象, 或者通过字面量, 或者通过工厂函数创建的对象, 我们无法判断这个对象是谁创建出来的，代码最后一行constructor指向的是一个Object

通过构造函数创建对象

• 什么是构造函数?

  • 构造函数也是一个函数, 只不过是专门用于创建对象的函数而已

• 构造函数和普通函数的区别?

  • 构造函数的函数名称首字母必须大写
  • 构造函数必须使用new 来调用

• 构造函数本质上是对工厂函数的简化

  • 在构造函数中默认会创建一个空的对象, 会将创建的对象赋值给this,会将创建的对象返回给调用者

• 过去通过Object对象, 或者通过字面量, 或者通过工厂函数创建的对象, 我们无法判断这个对象是谁创建出来的,但是通过构造函数创建的对象, 我们可以判断这个对象是谁创建出来的(见代码里obj.constructor）

• 默认情况下每一个对象都有一个隐藏的属性, 叫做constructor, 这个属性指向了创建当前对象的构造函数

    // 1.自定义一个构造函数
    function Person(name, age) {
        // 1.var obj = new Object();
        // 2.this = obj;
        this.name = name; // obj.name = name;
        this.age = age;
        this.say = function () {
            console.log("hello");
        }
        // 3.return obj;
    }
    /*
    new Person("luodou", 13);做了什么事情?
    1.会在构造函数中创建一个空的对象
    2.将创建好的空对象赋值给this
    3.将创建好的对象返回给调用者
     */
    var obj = new Person("luodou", 13);
    console.log(obj);

    console.log(typeof obj); // object
    console.log(obj.constructor); // ƒ Person(name, age) {}

    // 判断obj对象是否是Person构造函数创建出来的
    // console.log(obj.constructor === Person); // 不推荐

    // 如果想判断某个对象时候是某个构造函数创建出来的
    // 可以使用 对象名称 instanceof 构造函数名称, 来判断
    console.log(obj instanceof Person); // true


    function Student(name, age, score) {
        this.name = name; // obj.name = name;
        this.age = age;
        this.score = score;
    }
    var obj2 = new Student("dou", 11, 99);
    console.log(obj2 instanceof Person);  //false
    console.log(obj2 instanceof Student); //true

• 弊端：默认情况下, 只要创建一个对象就会在对象中开辟一块存储空间，该存储空间中会存储对象的所有数据，浪费空间

    function Person(name, age) {
        this.name = name;
        this.age = age;
        this.say = function () {
            //           obj1.name, obj1.age
            //           obj2.name, obj2.age
            console.log(this.name, this.age);
        };
    }
    var obj1 = new Person("lnj", 13);
    obj1.say();

    var obj2 = new Person("zq", 18);
    obj2.say();

    // 这里的===是在判断两个函数的地址是否相同
    console.log(obj1.say === obj2.say);  //false

• 解决方案:
  • 将方法定义在外面, 将定义在外面函数的地址赋值给属性，每次创建对象, 对象中say保存的都是函数的地址, 就不会重复保存了

    /*
    注意点: 在JavaScript中, 函数也是一个对象
     */
    function say() {
        console.log(this.name, this.age);
    }
    // var say = function () {
    //     console.log(this.name, this.age);
    // };
    // var say = new Function("console.log(this.name, this.age);");

    // 定义了一个构造函数
    function Person(name, age) {
        this.name = name;
        this.age = age;
        this.say = say;
    }

    var obj1 = new Person("luodou", 13);
    obj1.say();

    var obj2 = new Person("dou", 18);
    obj2.say();

    // 这里的===是在判断两个函数的地址是否相同
    console.log(obj1.say === obj2.say); // true

• 弊端：因为将函数定义在了全局作用域中, 所以如果定义了多个函数, 会导致全局作用域的名称匮乏

• 解决方案2.0

  • 将所有函数都封装到另外一个对象中, 这样函数名称就不在全局作用域中了, 这就不会导致全局作用域命名匮乏问题了，然后将对象中方法的地址复制给使用者即可

    var fns = {
        say: function() {
            console.log(this.name, this.age);
        },
        eat: function () {
        console.log("eat");
        }
    };

    // 定义了一个构造函数
    function Person(name, age) {
        this.name = name;
        this.age = age;

        this.say = fns.say;
        this.eat = fns.eat;
    }

    var obj1 = new Person("luodou", 13);
    obj1.say();

    var obj2 = new Person("dou", 18);
    obj2.say();

    // 这里的===是在判断两个函数的地址是否相同
    console.log(obj1.say === obj2.say); // true

终极解决方案

前面的通通忘掉！

• 在JavaScript中,每一个构造函数都有一个默认的属性, 这个属性叫做prototype,prototype属性指向一个对象, 这个对象我们称之为构造函数的原型对象

• 既然构造函数的prototype就对应一个对象, 所以我们就可以将方法都放到这个对象中

• 注意点：所有通过同一个构造函数创建出来的对象, 都可以访问该构造函数的原型对象，并且所有通过同一个构造函数创建出来的对象, 访问的都是同一个原型对象

    // 定义了一个构造函数
    function Person(name, age) {
        this.name = name;
        this.age = age;
    }
    /*
    私有成员（一般就是非函数成员）放到构造函数中
    共享成员（一般就是函数）放到原型对象中
    如果重置了 prototype 记得修正 constructor 的指向
     */
    Person.prototype.say = function () {
        console.log(this.name, this.age);
    };

    // console.log(Person.prototype);

    var obj1 = new Person("luodou", 13);
    obj1.say();

    var obj2 = new Person("dou", 18);
    obj2.say();

    // 这里的===是在判断两个函数的地址是否相同
    console.log(obj1.say === obj2.say); // true