JavaScript中是如何批量创建对象的

目录

目前创建对象的不足：

1.JavaScript工厂模式：

2.自定义构造函数模式：

3.使用原型对象模式批量创建

 4.使用自定义构造方法与原型模式结合  (重点)

构造函数中的constructor属性：

---

目前创建对象的不足：

        虽然使用 Object 构造函数或对象字面量可以方便地创建对象，但这些方式也有明显不足：创建具有同样接口的多个对象需要重复编写很多代码。

1.JavaScript工厂模式：

        概念：  工厂模式是一种众所周知的设计模式，广泛应用于软件工程领域，用于抽象创建特定对象的过程。工厂模式是一种创建型模式，简单来说，工厂模式就是创建对象的一种方式。
        作用：  创建对象；降低代码冗余度。
        应用场景：  当你想要批量生产同种类的对象的时候；比如，你想生成一个班级的40个学生，每个学生都有姓名、年龄等特征。这时候你创建一个“工厂”，把信息丢到工厂里，工厂就给你造一个人出来，非常方便。
        优点：  只要我们往工厂函数里面塞参数，工厂函数就会像生产产品一样造个对象出来。
        缺点：  这种方式本质上是将创建对象的过程进行了封装，本质并没有改变，我们创建一个student时无法知道其具体的数据类型，只知道这是一个对象，往往实际开发中我们需要确定这个对象到底是个Person的实例还是Dog的实例。

代码模块展示：

       function person(name, gender, age) {
            let p = new Object({
                name: name,
                gender: gender,
                age: age,
                sayName() {
                    console.log(name)
                }
            })

            return p
        }
    

        let p1 = person('zhangsan', 'male', 18)
        let p2 = person('lisi', 'male', 19)
        console.log(p1)
        p1.sayName()
        console.log(p2)
        p2.sayName()
        console.log(p1.sayName === p2.sayName) // false
        // 两个一样的方法却不全等，导致多占用了内存空间，影响性能，倒是内存冗余

2.自定义构造函数模式：

        优点：可以区分种类， 可以批量创建对象，对象不再是统一的object类型
        缺点：  内存中方法冗余 
        当使用 new 关键字时 js 做的一些事情
            1.创建一个实例对象
            2.将构造函数中的this 指向实例对象 this -----> p1
            3.执行函数体
            4.返回实例对象

此方法解决了分类问题却依然没有解决方法冗余问题

代码模块展示：

// 创建一个人的构造函数：
        function Person(name, gender, age) {
            this.name = name
            this.gender = gender
            this.age = age
            this.sayName = function() {
                console.log(this.name)
            }
        }

        let p1 = new Person('zhangsan', 'male', 19)
        let p2 = new Person('lihua', 'famale', 18)
        console.log(p1)  // Person {name: 'zhangsan', gender: 'male', age: 19, sayName: ƒ}
        console.log(p2)  // Person {name: 'lihua', gender: 'famale', age: 18, sayName: ƒ}

        // 创建一个狗的构造函数
        function Dog(name, gender, age) {
            this.name = name
            this.gender = gender
            this.age = age
            this.sayName = function() {
                console.log(this.name)
            }
        }

        let d1 = new Dog('doudou', 'male', 1)  
        let d2 = new Dog('aihuang', 'male', 2)
        console.log(d1) // Dog {name: 'doudou', gender: 'male', age: 1, sayName: ƒ}
        console.log(d2) // Dog {name: 'aihuang', gender: 'male', age: 2, sayName: ƒ}
        console.log(p1)  // Person {name: 'zhangsan', gender: 'male', age: 19, sayName: ƒ}
        console.log(p2)  // Person {name: 'lihua', gender: 'famale', age: 18, sayName: ƒ}

        // 由此可以看出,不同的构造函数创建的对象是不同的类别,可以区分类别

3.使用原型对象模式批量创建

        1.原型模式(不单独使用)
        2.将实例所有属性和方法全部放在原型对象中  构造函数内部不放任何属性和方法
        3.优点：解决了方法冗余  批量创建对象
        4.缺点：所有实例属性和方法全部是一样,没有私有的实例方法

 function Person() { }
        // 在原型对象中添加属性
        Person.prototype.name = 'lisi';
        Person.prototype.age = 12;
        Person.prototype.gender = 'male';
        Person.prototype.sayName = function () {
            console.log(this.name)
        }

        let p1 = new Person
        let p2 = new Person
        console.log(p1.name, p1.age)
        console.log(p1.name, p1.age)

 4.使用自定义构造方法与原型模式结合  (重点)

        1.组合模式: 原型模式 + 构造函数模式
        2.将实例私有属性和方法全部放在构造函数中
        3.将实例公共属性和方法全部放在原型对象中
        4.优点: 批量创建对象 区分种类 解决方法冗余
        5.缺点: 没有缺点,目前最好用的能够批量创建对象的方法

        这个方法结合和自定义构造函数的优点和原型对象方法的优点，即解决了方法冗余问题，又给创造的实例分了类

代码模块展示：

       function Person(name, gender, age) {
            this.name = name
            this.gender = gender
            this.age = age
        }
        // 将这个类的公共方法添加到这个类的原型上(添加一个方法时)
        Person.prototype.sayName = function() {
            // 原型对象中的this也指向实例对象
            console.log(this.name)
        }

        // 创建实例
        let p1 = new Person('zhangsan', 'mele', 18)
        let p2 = new Person('lisi', 'famele', 19)
        console.log(p1)  // Person {name: 'zhangsan', gender: 'mele', age: 18}
        p1.sayName() // zhangsan
        console.log(p2)  // Person {name: 'lisi', gender: 'famele', age: 19}
        p2.sayName()  // lisi

构造函数中的constructor属性：

        1.prototype对象有一个constructor属性，默认指向prototype对象所在的构造函数。
        2.应用场景：如果有多个对象的方法，我们可以给原型对象采用对象形式赋值，如果这样就会覆盖掉构造函数原型对象原来的内容，这样修改后的原型对象constructor 就不再指向当前构造函数了此时，我们可以在修改后的原型对象中，添加一个constructor 指回原来的构造函数

代码模块展示：

        // 创建一个狗的构造函数
        function Dog(name, gender, age) {
            this.name = name
            this.gender = gender
            this.age = age
        }
        // 将这个累的公共方法添加到这个类的原型上(添加多个方法时)
        // 这里直接将一个对象赋值给了Dog构造函数的原型,导致原型不再指向Dog构造函数
        Dog.prototype = {
            // 将原型指回原来的构造函数
            construct: Dog,
            sayName() {
                console.log(this.name)
            },
            eat() {
                console.log('狗狗在吃骨头')
            }
        }

        // 创建实例
        let d1 = new Dog('doudou', 'male', 18)
        let d2 = new Dog('dahuang', 'famale', 18)
        console.log(d1) // Dog {name: 'doudou', gender: 'male', age: 18}
        console.log(d2) // Dog {name: 'dahuang', gender: 'famale', age: 18}
        d1.sayName() // doudou
        d2.eat() // 狗狗在吃骨头