JavaScript 面向对象 (prototype 原型模式)

一、 JavaScript 设计思想

  1994年,网景公司(Netscape)发布了Navigator浏览器0.9版。这是历史上第一个比较成熟的网络浏览器,轰动一时。但是,这个版本的浏览器只能用来浏览,不具备与访问者互动的能力。比如,如果网页上有一栏"用户名"要求填写,浏览器就无法判断访问者是否真的填写了,只有让服务器端判断。如果没有填写,服务器端就返回错误,要求用户重新填写,这太浪费时间和服务器资源了。

  因此,网景公司急需一种网页脚本语言,使得浏览器可以与网页互动。工程师_Brendan Eich_负责开发这种新语言。他觉得,没必要设计得很复杂,这种语言只要能够完成一些简单操作就够了,比如判断用户有没有填写表单。

  1994年正是面向对象编程(object-oriented programming)最兴盛的时期,C++是当时最流行的语言,而Java语言的1.0版即将于第二年推出,Sun公司正在大肆造势。

  Brendan Eich无疑受到了影响,Javascript里面所有的数据类型都是对象(object),这一点与Java非常相似。但是,他随即就遇到了一个难题,到底要不要设计"继承"机制呢?

  如果真的是一种简易的脚本语言,其实不需要有"继承"机制。但是,Javascript里面都是对象,必须有一种机制,将所有对象联系起来。所以,Brendan Eich最后还是设计了"继承"。

  但是,他不打算引入"类"(class)的概念,因为一旦有了"类",Javascript就是一种完整的面向对象编程语言了,这好像有点太正式了,而且增加了初学者的入门难度。

  他考虑到,C++Java语言都使用new命令,生成实例。

    C++的写法是:
        ClassName *object = new ClassName(param);

    Java的写法是:
        Foo foo = new Foo();

  

    因此,他就把new命令引入了Javascript,用来从原型对象生成一个实例对象。但是,Javascript没有"类",怎么来表示原型对象呢?
  这时,他想到C++和Java使用new命令时,都会调用"类"的构造函数(constructor)。他就做了一个简化的设计,在Javascript语言中,new命令后面跟的不是类,而是构造函数。

  例: 

现在有一个叫做DOG的构造函数,表示狗对象的原型。

      function DOG(name){
          this.name = name;
      }

  

    对这个构造函数使用new,就会生成一个狗对象的实例。

      var dogA = new DOG(‘大毛‘);
      alert(dogA.name); // 大毛

  

    注意构造函数中的this关键字,它就代表了新创建的实例对象。

  new运算符的缺点

     用构造函数生成实例对象,有一个缺点,那就是无法共享属性和方法。

    比如:

      在DOG对象的构造函数中,设置一个实例对象的共有属性species

        function DOG(name){
            this.name = name;
            this.species = ‘犬科‘;
        }

  

      然后,生成两个实例对象:

        var dogA = new DOG(‘大毛‘);
        var dogB = new DOG(‘二毛‘);

  这两个对象的species属性是独立的,修改其中一个,不会影响到另一个。

        dogA.species = ‘猫科‘;
        alert(dogB.species); // 弹出的值为"犬科",它不受 dogA 的影响

  

      每一个实例对象,都有自己的属性和方法的副本。这不仅无法做到数据共享,也是极大的资源浪费。

二、prototype属性的引入

  Brendan Eich 为构造函数设置一个prototype属性。

  这个属性包含一个对象(以下简称"prototype对象"),所有实例对象需要共享的属性和方法,都放在这个对象里面;那些不需要共享的属性和方法,就放在构造函数里面。

  实例对象一旦创建,将自动引用prototype对象的属性和方法。也就是说,实例对象的属性和方法,分成两种,一种是本地的,另一种是引用的。

  例:

    function DOG(name){
        this.name = name;
    }
    DOG.prototype = { species : ‘犬科‘ };

    var dogA = new DOG(‘大毛‘);
    var dogB = new DOG(‘二毛‘);

    alert(dogA.species); // 犬科
    alert(dogB.species); // 犬科

  

  现在,species属性放在prototype对象里,是两个实例对象共享的。只要修改了prototype对象,就会同时影响到两个实例对象。

    DOG.prototype.species = ‘猫科‘;
    alert(dogA.species); // 猫科
    alert(dogB.species); // 猫科

  

 三、Prototype原型模式

  原型对象实际上就是构造函数的一个实例对象,和普通的实例对象没有本质上的区别。可以包含特定类型的所有实例的共享属性或者方法。 这个prototype的属性值是一个对象(属性的集合),默认的只有一个叫做constructor的属性,指向这个函数本身。

  比如我们简单定义一个SuperType名字的函数

    function SuperType(){

    }

   里面什么属性也没有在函数内部是这个样子的 

  从上图我们看到,函数里面虽然什么都没有,但是有一个默认的prototype属性,它是一个对象,它指向的是自己的地址,而prototype这个对象本身里面又有一个属性constructor,而这个属性,又指向了函数本身

    alert(SuperType.prototype) //object
    alert(SuperType.prototype.constructor) //弹出函数本身function SuperType(){}

  

  1、基本原型

    function Person(){ }
    Person.prototype.name = "Nicholas";
    Person.prototype.age = 29;
    Person.prototype.job = "Software Engineer";
    Person.prototype.sayName = function(){
        alert(this.name);
    };

  

    这种方式只是说明原型的道理,实际使用中很少把属性写在原型中

  2 更简单的方式

    function Person(){ } 

    Person.prototype = {
        name : "Nicholas",
        age : 29,
        job: "Software Engineer",
        sayName : function () {
            alert(this.name);
        }
    };

  

    这种方式只是上面方式的简单写法,通过对象字面量直接写完所有属性。效果和上面的写法是一样的,只是写法不一样。

    但是直接全部把属性和方法全部写在原型中,这并不现实,看下面的列子:

     function Person(){ }

      Person.prototype = {
          constructor: Person,
          name : "Nicholas",
          age : 29,
          job : "Software Engineer",
          friends : ["Shelby", "Court"],
          sayName : function () {
              alert(this.name);
          }
      }; 

      var person1 = new Person();
      var person2 = new Person();
      person1.friends.push("Van");
      alert(person1.friends);    //"Shelby,Court,Van"
      alert(person2.friends);    //"Shelby,Court,Van"
      alert(person1.friends === person2.friends);  //true

  

    上面的列子很容易看出,将属性写在原型中的问题,列子中的friends是个数组,引用数据类型在person1中修改了friends,添加了一个条数据之后,可以看到person1和person2对象的friends都发生了改变,这其实很好理解,因为prototype对象本身就是共享的,数组又是属于引用类型,改变了一个,其他的都会发生改变。

    所以,在实际中使用的更多的方法是构造函数与原型结合的方式

  3 构造函数与原型结合的方式

   function Person(name, age, job){
        this.name = name;
        this.age = age;
        this.job = job;
        this.friends = ["Shelby", "Court"];
    }
    Person.prototype = {
        constructor : Person,   //记得写这句代码,作用是防止内存泄露
        sayName : function(){
            alert(this.name);
        }
    } 

    var person1 = new Person("Nicholas", 29, "Software Engineer");
    var person2 = new Person("Greg", 27, "Doctor");
    person1.friends.push("Van");
    alert(person1.friends);    //"Shelby,Count,Van"
    alert(person2.friends);    //"Shelby,Count"
    alert(person1.friends === person2.friends);    //false
    alert(person1.sayName === person2.sayName);    //true

  

    这里就可以看到,friends的属性在两个对象中就算改变了其中一个,并不会对另外一个产生影响。这种构造函数加原型的混成模式,是目前使用率,认可率最高的一种自定义类型的方式,所以,一般情况下,我们定义自定义类型默认都使用这种模式

  4 动态原型模式

    这种模式只是上面模式的变种,对于一些习惯书写面向对象语言的程序员来说,一个类要分开两个部分来写,是非常不习惯的,所以,就有了动态原型模式,其实无非就是,把之前分开两部分写的内容,全部提到函数中,加上判断就行了

    function Person(name, age, job){
        //属性
        this.name = name;
        this.age = age;
        this.job = job;
        //方法
        if (typeof this.sayName != "function"){
            Person.prototype.sayName = function(){
                alert(this.name);
            };
        }
    }  

    var friend = new Person("Nicholas", 29, "Software Engineer");
    friend.sayName();

  

      注意上面的判断,这种方式只有在sayName函数不存在的情况下,才会将它添加到原型中,如果sayName函数已经存在,那么这段代码就不会再运行,而且就算有很多方法的话,if语句也不用全部判断,只是需要判断一个就行了。

      这样的写法,对于java或者C#程序员相对来说感官上比较容易接受,而且写法也没有任何缺陷。但是,有一点不算是缺陷的缺点,javascript是一门动态语言,也就是说,属性和方法是随时可以添加的,如果全部写在构造函数里面去,反而看起来不是那么的灵活。所以,一般情况下,还是该使用构造函数与原型的混合模式

四、 Prototype模式的验证方法

  为了配合prototype属性,Javascript定义了一些辅助方法

  1、 isPrototypeOf() : 这个方法用来判断,某个proptotype对象和某个实例之间的关系。 

    function Cat(name,color){
          this.name = name;
          this.color = color;
      }
      Cat.prototype.type = "猫科动物";
      Cat.prototype.eat = function(){alert("吃老鼠")};
      var cat1 = new Cat("大毛","黄色");
      var cat2 = new Cat("二毛","黑色");

    alert(Cat.prototype.isPrototypeOf(cat1)); //true    判断 cat1 对象是否是 prototype原型
    alert(Cat.prototype.isPrototypeOf(cat2)); //true    判断 cat2 对象是否是 prototype 原型

  2、 hasOwnProperty() :用来判断某一个属性到底是本地属性,还是继承自prototype对象的属性。

      function Cat(name,color){
          this.name = name;
          this.color = color;
      }
      Cat.prototype.type = "猫科动物";

    alert(cat1.hasOwnProperty("name")); // true    name属性是本地属性
      alert(cat1.hasOwnProperty("type")); // false   type 属性是继承prototype对象的属性

  

  3 in运算符

      in运算符可以用来判断,某个实例是否含有某个属性,不管是不是本地属性。

        alert("name" in cat1); // true
        alert("type" in cat1); // true

  in运算符还可以用来遍历某个对象的所有属性。

        for(var prop in cat1) {
            alert("cat1["+prop+"]="+cat1[prop]);
        }

  五、 JavaScript高级程序设计书中对与原型的描述和说明  

    function Person(){ }  //创建Person构造函数
    Person.prototype.name = "Nicholas";  //创建共享属性name
    Person.prototype.age = 29;  //创建共享属性age
    Person.prototype.job = "Software Engineer";   //创建共享属性job
    Person.prototype.sayName = function(){     //创建共享函数sayName
       alert(this.name);
  }

    //分别创建了person1和person2,里面都有sayName函数,并且弹出的值都是一样
    var person1 = new Person();
    person1.sayName();   //"Nicholas"
    var person2 = new Person();
    person2.sayName();   //"Nicholas"
    alert(person1.sayName == person2.sayName);  //true

  

    通过上面的图,可以看到,person1和person2,他们内部都有一个指向Person.prototype的指针,可以通过原型的isPrototype方法测试

      alert(Person.prototype.isPrototypeOf(person1));  //true
      alert(Person.prototype.isPrototypeOf(person2));  //true
      function User(){};
      var person3 = new User();
      alert(Person.prototype.isPrototypeOf(person3));  //false  不是prototype原型对象
      alert(User.prototype.isPrototypeOf(person3));  //true     是prototype原型对象

  

     数组操作的很多方法(比如concat、join、push)应该也是在prototype属性中定义的。 
    实际上,JavaScript所有的固有数据类型都具有只读的prototype属性(这是可以理解的:因为如果修改了这些类型的prototype属性,则哪些预定义的方法就消失了), 但是我们可以向其中添加自己的扩展方法。

     // 向JavaScript固有类型Array扩展一个获取最小值的方法
        Array.prototype.min = function() {
            var min = this[0];
            for (var i = 1; i < this.length; i++) {
                if (this[i] < min) {
                    min = this[i];
                }
            }
            return min;
        };

        // 在任意Array的实例上调用min方法
        console.log([1, 56, 34, 12].min());  // 1

  

  注意:这里有一个陷阱,向Array的原型中添加扩展方法后,当使用for-in循环数组时,这个扩展方法也会被循环出来。

    下面的代码说明这一点(假设已经向Array的原型中扩展了min方法):

      var arr = [1, 56, 34, 12];
        var total = 0;
        for (var i in arr) {
            total += parseInt(arr[i], 10);
        }
        console.log(total);   // NaN

  

    解决方法也很简单:

      var arr = [1, 56, 34, 12];
        var total = 0;
        for (var i in arr) {
            if (arr.hasOwnProperty(i)) {
                total += parseInt(arr[i], 10);
            }
        }
        console.log(total);   // 103

  

六、 constructor

  constructor始终指向创建当前对象的构造函数。

  例: 

    // 等价于 var foo = new Array(1, 56, 34, 12);
        var arr = [1, 56, 34, 12];
        console.log(arr.constructor === Array); // true
        // 等价于 var foo = new Function();
        var Foo = function() { };
        console.log(Foo.constructor === Function); // true
        // 由构造函数实例化一个obj对象
        var obj = new Foo();
        console.log(obj.constructor === Foo); // true
        // 将上面两段代码合起来,就得到下面的结论
        console.log(obj.constructor.constructor === Function); // true

  

   当constructor遇到prototype时,每个函数都有一个默认的属性prototype,而这个prototype的constructor默认指向这个函数。

  例:

     function Person(name) {
            this.name = name;
        };
        Person.prototype.getName = function() {
            return this.name;
        };
        var p = new Person("天天");

        console.log(p.constructor === Person);  // true
        console.log(Person.prototype.constructor === Person); // true
        // 将上两行代码合并就得到如下结果
        console.log(p.constructor.prototype.constructor === Person); // true

  

   当我们重新定义函数的prototype时  (注意:和上例的区别,这里不是修改而是覆盖) ,constructor 的行为就有点奇怪了,

例:

      function Person(name) {
            this.name = name;
        };
        Person.prototype = {
            getName: function() {
                return this.name;
            }
        };
        var p = new Person("ZhangSan");
        console.log(p.constructor === Person);  // false
        console.log(Person.prototype.constructor === Person); // false
        console.log(p.constructor.prototype.constructor === Person); // false

  

  出现上面代码结果的原因是因为覆盖Person.prototype时,等价于进行如下代码操作:

      Person.prototype = new Object({
            getName: function() {
                return this.name;
            }
        });

  

  而constructor始终指向创建自身的构造函数,所以此时Person.prototype.constructor === Object,即是:

      function Person(name) {
            this.name = name;
        };
        Person.prototype = {
            getName: function() {
                return this.name;
            }
        };
        var p = new Person("天天");
        console.log(p.constructor === Object);  // true
        console.log(Person.prototype.constructor === Object); // true
        console.log(p.constructor.prototype.constructor === Object); // true

  

  下面是修改这种问题的方法,很简单,就是重新覆盖Person.prototype.constructor :

     function Person(name) {
            this.name = name;
        };
        Person.prototype = new Object({
            getName: function() {
                return this.name;
            }
        });
        Person.prototype.constructor = Person;  //让它重新在指向自身的构造函数
        var p = new Person("ZhangSan");
        console.log(p.constructor === Person);  // true
        console.log(Person.prototype.constructor === Person); // true
        console.log(p.constructor.prototype.constructor === Person); // true

  

七、 对象的 __proto__ 隐式原型

   上面我们创建了两个对象,person1和person2,这两个对象,也都指向了Person构造函数的原型,这是因为每个对象都有一个隐藏的属性“__proto__”,这个属性引用了创建这个对象的函数的prototype。   即:person1.__proto__ === Person.prototype  
   这个__proto__是一个隐藏的属性,javascript不希望开发者用到这个属性值,有的低版本浏览器甚至不支持这个属性值。

  用它的代码如下:

    console.log(Object.prototype);
    var obj = new Object();
    console.log(obj.__proto__);

  你会发现打印了相同的内容:

    obj这个对象本质上是被Object函数创建的,因此obj.__proto__=== Object.prototype。可以用一个图来表示。

时间: 2024-10-12 16:33:14

JavaScript 面向对象 (prototype 原型模式)的相关文章

第一百零九节,JavaScript面向对象与原型

JavaScript面向对象与原型 学习要点: 1.学习条件 2.创建对象 3.原型 4.继承 ECMAScript有两种开发模式:1.函数式(过程化),2.面向对象(OOP).面向对象的语言有一个标志,那就是类的概念,而通过类可以创建任意多个具有相同属性和方法的对象.但是,ECMAScript没有类的概念,因此它的对象也与基于类的语言中的对象有所不同.   一.学习条件 在JavaScript视频课程第一节课,就已经声明过,JavaScript课程需要大量的基础.这里,我们再详细探讨一下: 1

浅谈JavaScript中的原型模式

在JavaScript中创建对象由很多种方式,如工厂模式.构造函数模式.原型模式等: <pre name="code" class="html">//工厂模式 function createPerson(name,age,job) { var o = new Object; o.name = name; o.age = age; o.job = job; o.sayName = function() { alert(this.name); } retur

设计模式(五):PROTOTYPE原型模式 -- 创建型模式

1.定义 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象. 2.适用场景 原型模式的主要思想是基于现有的对象克隆一个新的对象出来,一般是有对象的内部提供克隆的方法,通过该方法返回一个对象的副本,这种创建对象的方式,相比我们之前说的几类创建型模式还是有区别的,之前的讲述的工厂模式与抽象工厂都是通过工厂封装具体的new操作的过程,返回一个新的对象,有的时候我们通过这样的创建工厂创建对象不值得,特别是以下的几个场景的时候,可能使用原型模式更简单也效率更高. • 1)当一个系统应该独立于

深入浅出设计模式 ------ Prototype(原型模式)之深度克隆

继上篇深入浅出设计模式 ------ Prototype(原型模式)的浅克隆实现, 本文进入Prototype(原型模式)的进阶篇----深度克隆. 深度克隆 ---- 序列化方式实现 把对象写到流里的过程是序列化(Serilization)过程,而把对象从流中读出来的过程则叫做反序列化(Deserialization).写在流里的是对象的一个克隆(新的, 独立的), 而原对象仍存在于JVM内存模型里.因此, 以下代码采用序列化方式实现深度克隆. 第一步: 将上篇的代码做些许改动, 加入对象引用

设计模式05: Prototype 原型模式(创建型模式)

Prototype 原型模式(创建型模式) 依赖关系的倒置抽象不应该依赖于实现细节,细节应该依赖于抽象.对所有的设计模式都是这样的. -抽象A直接依赖于实现细节b -抽象A依赖于抽象B,实现细节b依赖于抽象B 动机(Motivation) 在软件工程中,经常面临着“某些结构复杂的对象”的创建工作:由于需求变化,这些对象经常面临着剧烈的变化,但是它们却拥有比较稳定一致的接口. 如何应对这种变化?如何向“客户程序(使用这些对象的程序)”隔离出这些“易变对象”,从而使得“依赖这些易变对象的客户程序”不

一天一个设计模式——Prototype 原型模式

一.模式说明 看了比较多的资料,对原型模式写的比较复杂,个人的理解就是模型复制,根据现有的类来直接创建新的类,而不是调用类的构造函数. 二.原型模式的类图 三.原型模式中的角色 原型(Protype)角色:负责定义复制现有实例生成新实例的方法 具体原型(ConcretePrototype)角色:负责实现复制现有实例生成新实例的方法 使用者(Client)角色:负责使用复制实例的方法生成新实例 四.代码示例 1.Product类: package com.designpattern.cn.prot

有关javaScript面向对象和原型笔记

javaScript是一种比較特殊的语言,ECMAScript中没有类的概念.跟其它面向对象的语言有一定的差别.它的对象也与基于类的语言中的对象有所不同,严格来说,javascript对象是一组没有特定顺序的值,对象的每一个属性或方法都有一个名字.而每一个名字都映射到一个值.每一个对象都是基于一个引用类型的创建的. 创建自己定义对象的最简单的方式就是创建一个Object的实例.然后再为其加入属性和方法,如: var box = new Object(); //创建对象 box.name1 = '

理解javascript中的原型模式

一.为什么要用原型模式. 早期采用工厂模式或构造函数模式的缺点:  1.工厂模式:函数creatPerson根据接受的参数来构建一个包含所有必要信息的person对象,这个函数可以被无数次的调用,工厂模式尽管解决了创建多个相似对象的问题,却没有解决对象识别的问题(返回的是自定义的一个对象o,不明确对象o的类型).  2. 构造函数模式:构造函数的调用和其他oo语言一样,用new操作符来构建一个Person的实例:javascript中的构造函数也是函数(所以也可以直接像普通函数那样直接调用方法名

javascript面向对象和原型

/* //工厂模式 function createObject(name,age){ var obj = new Object();//新建一个对象 obj.name=name;//新建对象的属性 obj.age=age; obj.run=function(){//新建对象的方法 return this.name+","+this.age+"...running."; } return obj;//返回新建的对象引用 } var box1 = createObjec