对象---声明对象的方式

Posted 2020-11-14 xu991377264

对象可以分为：1、内建对象：由ES标准中定义的对象，在任何的ES实现中都可以使用，比如：Math String Number Boolen Function等等

　　　　　　　2、宿主对象：有JS的运行环境提供的对象，目前来讲主要指浏览器提供的对象，如：BOM DOM

　　　　　　　3、自定义对象：由开发人员自己创建的对象

下面将对自定义对象进行讲解

声明对象的方式有：

　　　　　　　   1、字面式声明对象
                           2、new操作符后跟Object构造函数声明对象
                           3、构造函数声明对象
                           4、工厂方式声明对象
                           5、原型模式声明对象
                           6、混合模式声明对象（构造+原型）

1、js字面式声明对象　　　

var person1={
           name:"js",
           age:26,
           sex:"男",
           show:function(pl){
               console.log("js正在"+pl);
           }//注意最后一个不需要加逗号
          }
       console.log(person1.name);
       console.log(person1.age);
       person1.show("表演");

2、new操作符后跟Object构造函数声明对象

var person2 = new Object();
      person2.name="java";
      person2.age=20;
      person2.play=function(st){
          console.log(this.age+"岁的"+this.name+"正在"+st);
      };
      console.log(person2.name);
      person2.play("打飞机");

3、构造函数声明对象

function Obj(name,age,done){
          this.name=name;
          this.age=age;
          this.done=done;
          this.watch=function(){
              console.log(this.age+"的"+this.name+"正在看"+this.done);
          }
      }
      var obj1=new Obj("php",10,"美女");
      obj1.watch();
      var obj2=new Obj("小米",12,"野怪");
      obj2.watch();

构造函数声明对象特点：

　　　  1、没有显示的创建对象
             2、直接将属性和方法赋给了this对象；this指向当前对象
             3、没有return语句
       但是它存在的主要问题（缺点）:每个方法都要在每个实例上重新创建一遍，这是完全没必要的，如着里的wath()方法，每个实例都会重新创建一次

 解决方法1（不可取）：  当然我们可以将watch()函数的定义放在构造函数外部，
         　　　　　　　　 但这又会带来新的问题：污染了全局作用域的命名空间，而且定义在全局作用域也很不安全，方法1的代码如下：

      function Objo(name,age,done){
          this.name=name;
          this.age=age;
          this.done=done;
          this.watch2=watch2;
      }
       function watch2(){
              console.log(this.age+"的"+this.name+"正在看"+this.done);
          }
      var obj3=new Objo("php",10,"美女");
       obj3.watch2();

解决方法2：我们可以采用原型模式的方法来解决以上问题；代码如下：

  function Objo(name,age,done){
          this.name=name;
          this.age=age;
          this.done=done;
      }
      Objo.prototype.watch=function(){
          console.log(this.age+"的"+this.name+"正在看"+this.done);
      }
      var obj4=new Objo("php",10,"美女");
       obj4.watch();

4、工厂方式声明对象

         function createObject(name,age){
             // 在方法内创建对象
             var bj= new Object();
             bj.name=name;
             bj.age=age;
             bj.run=function(){
                 return this.name+this.age;
             }
             return bj;       
         }
         var bj1=createObject("张三",15);
         var bj2=createObject("李斯",18);
         console.log(bj1.name);
         bj1.run();

工厂模式
            作用：按照这种模式可以不断的创建对象
                 任何模式下创造出来的对象都是独立存在的
            构造函数声明对象方式与工厂模式的区别：
                1、构造方式不会显示创建对象，将属性值赋值给this，不需要return对象
                2、工厂方式 在方法内创建Object对象,返回Object对象，属性和方法都是赋给Object对象

5、原型模式声明对象

　　第一种声明方式：

function proto(){
        };
        proto.prototype.color = "red";
        proto.prototype.height = "2.7";
        proto.prototype.width = "20";
        proto.prototype.say=function(){
            console.log(this.color+"----"+this.height+"----"+this.width); 
        }
        var pro1 = new proto();
        pro1.say();

　　 第二种声明方式：json数据定义属性和方法

         function proto2(){
         };
         proto2.prototype={
             color: "red",
             height: "20",
             width: "50",
             sayby:function(){
                 console.log(this.color+"----"+this.height+"----"+this.width); 
             }
         }
         var pro2 = new proto2();
         pro2.sayby();

 

6、混合模式声明对象（构造+原型）

function blog(name,age,friend){
             this.name=name;
             this.age=age;
             this.friend=friend;
         }
         blog.prototype={
             gets:function(){
                 console.log(this.name+"----"+this.age+"----"+this.friend);
             }
         }
         var blog1 = new blog("张三",24,"李斯");
         console.log(blog1.name);
         blog1.gets();

 在实际应用中我们使用混合模式声明对象的方式居多