JavaScript创建对象的五种方法及优缺点

        //一、普通方法
        var hero=new Object(); //创建了一个空的对象
        //属性
        hero.name='黄忠';
        hero.equipment=['头盔','盔甲'];
        hero.attack=function(){
            console.log(this.name+':射箭');
        }
        hero.attack();
        
        //二、工厂方法
        function createHero(name,weapon,equipment,blood){
            var hero=new Object();
            //属性
            hero.name=name;
            hero.weapon=weapon;
            hero.equipment=equipment;
            hero.blood=blood;
            hero.attack=function(){
                console.log(this.name+':攻击');
            }
            console.log(hero);
            return hero;
        }
        var hero1=createHero('黄忠','弓箭',['头盔','鞋子'],100);
        var hero2=createHero('刘备','弓箭',['头盔','鞋子'],100);
        console.log(hero1.name);
        hero2.attack();
        hero1.attack();
        //优点：简化了代码量
        //缺点：1.对象不可细分；2.浪费内存

        //三、自定义构造函数//单词的第一个字母大写
        new Object();
        //new Hero();
        function Hero1(name,weapon,equipment,blood){
            //this 指向当前对象，动态的给对象增加成员
            this.name=name;
            this.weapon=weapon;
            this.equipment=equipment;
            this.blood=blood;
            //缺点：多个对象会在内存创建多个attack方法
            this.attack=function(){
                console.log(this.name+':攻击');
            }
        }
        var hero3=new Hero1('li忠','弓箭',['头盔','鞋子'],100);
        var hero4=new Hero1('刘备','弓箭',['头盔','鞋子'],100);
        console.log(hero1.blood);
        hero3.attack();
        hero4.attack();

        //四、全局变量--解决attack存储多分的方法：将attack方法改为全局变量
        function Hero2(name,weapon,equipment,blood){
            //this 指向当前对象，动态的给对象增加成员
            this.name=name;
            this.weapon=weapon;
            this.equipment=equipment;
            this.blood=blood;
            //缺点：将来在全局变量创建的attack方法多了，方法容易重名，即未来用别的构造函数创建方法时，容易与这个同名
            this.attack=attack
        }
        
        function attack(){
                console.log(this.name+':攻击');
            }
        var hero1=new Hero2('li忠','弓箭',['头盔','鞋子'],100);
        var hero2=new Hero2('刘备','弓箭',['头盔','鞋子'],100);
        console.log(hero1.blood)
        hero1.attack();
        hero2.attack();

        //五、原型对象--解决“将来在全局变量创建的attack方法多了，方法容易重名，即未来用别的构造函数创建方法时，容易与这个同名”的方法：使用原型----每一个构造函数中都有一个属性：原型/原型对象
        function Hero(name,weapon,equipment,blood){
            this.name=name;
            this.weapon=weapon;
            this.equipment=equipment;
            this.blood=blood;
        }
        
        Hero.prototype.attack=function(){
                console.log(this.name+':攻击');
            }
        //通过Hero的构造函数创建的对象，可以访问Hero.prototype中的成员
        var hero1=new Hero('li忠','弓箭',['头盔','鞋子'],100);
        var hero2=new Hero('刘备','弓箭',['头盔','鞋子'],100);
        hero1.attack();
        hero2.attack();
        console.log(hero1.attack()===hero2.attack());  //判断hero1中的attack方法与hero2中的attack方法在内存中是否占得同一块空间
       
        console.dir(hero2); //查看对象的内容
        //由原型链可知，当调用对象的属性或方法的时候，先去找对象本身的属性或方法，如果对象没有该属性或者方法，此时去找该构造函数的原型中是否有此属性或方法，
        //如果没有该属性，则去找Object原型对象中是否存在，如果没有，则去null中去查找，如果还是没有，会报错
        //hero1.__proto__ ： 对象的__proto__等于构造函数Student.prototype
        //__proto__属性是非标准属性。作用：作为对象的属性去指向构造函数的prototype,以此来让对象可以访问原型中的成员或方法

        //在原型中有一个属性 constructor 构造函数
        //constructor 作用： 记录了创建该对象的构造函数
        console.log(hero2.constructor);

        var arr=[];  //数组本身也是一个对象，对象就有constructor属性
        console.log(arr.constructor); //可以看出数组的默认构造函数是Array