2018-12-21

---

对象的创建模式

Object构造函数来创建

用Object给构造函数创建的对象缺点：
1.组织形式不好(定义的对象结构中可以加入其它的语句，如：for循环，if语句等)
2.没有类型(全部都得用Object来定义)
3.内存开销大
4.代码冗余

 <script>
        /*
        使用Object给构造函数创建的对象的缺点：
        1.组织形式不好(定义的对象结构中可以加入其它的语句，如：for循环，if语句等)
        2.没有类型(全部都得用Object来定义)
        3.内存开销大
        4.代码冗余
        */
        var obj = new Object();
        obj.name = "siri";
        obj.age = 20;
        obj.eat = function(){
            console.log("葡萄");
        }

        var obj2 = new Object();
        obj.name = "tom";
        obj.age = 24;
        obj.eat = function(){
            console.log("牛排");
        }

--

字面量的形式创建对象

用字面量的形式来创建对象的缺点：
1.没有类型
2.内存开销大
3.代码冗余
优点：
组织形式比较友好

 <script>
       /*
       用字面量的形式来创建对象的缺点：
       1.没有类型
       2.内存开销大
       3.代码冗余

        优点：
        组织形式比较友好
        */
       var obj = {
           name:"siri",
           age:20,
           say:function(){
               console.log("小红帽");
           }
       }

       var obj = {
           name:"tom",
           age:23,
           say:function(){
               console.log("大灰狼");
           }
       }
   </script> 

--

工厂模式来创建对象

使用工厂模式创建对象的缺点：
1.内存开销大
2.没有类型
优点：
1.组织形式友好
2.代码不冗余

 <script>
        /*
        使用工厂模式创建对象的缺点：
        1.内存开销大
        2.没有类型

        优点：
        1.组织形式友好
        2.代码不冗余
        */
        function creatObj(name, age, food) {
            return {
                name: "siri",
                age: 29,
                eat: function (food) {
                    console.log(food);
                }

            }
        }

        var obj1 = creatObj("siri", 20, "葡萄")
        var obj2 = creatObj("tom", 22, "土豆")
        console.log(obj1, obj2);

--

自定义构造函数来创建对象

使用自定义构造函数来创建对象的缺点：
内存开销大
优点：
1.组织形式比较友好
2.代码不冗余
3.拥有类型

 <script>
            /*
          使用自定义构造函数来创建对象
            3. 内存开销大        

             1. 组织形式比较友好
             2. 代码不冗余
             3. 拥有类型
            */
        function Person(name, age) {
            this.name = name;
            this.age = age;
            this.eat = function (food) {
                console.log(food);
            }
        }

        var zs = new Person("张三", 20);  //this指向zs
        zs.eat("葡萄")
        var ls = new Person("李四", 19) //this指向ls
        ls.eat("米饭")
        console.log(zs instanceof Person, ls);
    </script>

--

自定义构造函数+原型链的形式创建对象

使用自定义构造函数+原型链的形式创建对象的优点：
1.组织形式比较友好
2.代码不冗余
3.拥有类型
4.内存开销相对较小

 <script>
        /*使用自定义构造函数来创建对象     
         1. 组织形式比较友好
         2. 代码不冗余
         3. 拥有类型
         4.内存开销相对较小
        */

        Person.prototype.eat = function (food) {
            console.log(this.name+"吃"+food);
        }

        function Person(name, age) {
            this.name = name;
            this.age = age;
        }

        var zs = new Person("张三", 20);  //this指向zs
        zs.eat("葡萄")
        var ls = new Person("李四", 19) //this指向ls
        ls.eat("米饭")
    </script>

使用create()函数来创建对象

<script>
        /*
        使用create函数来创建对象
        */
        var obj = {}
        console.log(obj);
        //obj2 = Object.create(obj)会创建出一个对象，只是这个对象的隐式原型会被显示的指定，指定为obj
        var obj2 = Object.create({a:"a"})
        console.log(obj2);
    </script>