javascript之累

首要是参考了《JavaScript高级程序设计(第三版本)》这按照开,根据自己之理解,做了底的记录

 

延续是面向对象(OO)语言里的定义,有俩种植持续方式:接口继承与促成持续。接口继承只持续方法签名,而落实持续则继续实际的方。由于函数没有签定,在javascript里面无法落实接口继承,只支持落实连续。

原型链继承

 
 构造函数、原型和实例的涉:每个构造函数都出一个原型对象,原型对象都蕴含一个对准构造函数的指针,而实例都饱含一个针对性原型对象的其中指针。

  ECMAScript 1

   所有函数的默认原型都是Object的实例

 
 那要被原型对象等另一个色的实例会怎么样也?显然,此时的原型对象将包含一个针对任何一个原型的指针,相应地,另一个原型为蕴藏在对任何一个构造函数的指针。

   具体代码: 

 1    function SuperType() {
 2       this.proterty = true
 3     }
 4     SuperType.prototype.getSuperValue = function () {
 5       return this.proterty
 6     }
 7     function SubType() {
 8       this.subproperty = false
 9     }
10     //继承了SuperType
11     SubType.prototype = new SuperType()
12     SuperType.prototype.getSubValue = function () {
13       return this.subproperty
14     }
15     var instance = new SubType()
16     instance.getSuperValue()  //true

判定原型和实例的涉

使用instance或者isPrototypeOf

1     alert(instance instanceof SubType)  //  true
2     alert(SubType.prototype.isPrototypeOf(instance))  // true

 

缺点:

 (一)、只要有实例、构造函数、原型对象修改了性能或措施,会对原型链上的其他对象实例造成影响

 (二)、在创造了品种的实例时,没有办法于不影响谁起目标实例的景象下,给超类型的构造函数传递参数

 

借构造函数

    

 1     function SuberType() {
 2       this.colors = ["red","blur"]
 3     }
 4     function SubType() {
 5       //继承了SuberType 
 6       //使用了call改变了this的作用域,用apply也可以
 7       SuberType.call(this)
 8     }
 9     var instance = new  SubType()
10     instance.colors.push("black")
11     alert(instance.colors) //red,blur,black

13 var instalce2 = new SuberType() 14 alert(instalce2.colors) // red,blur

可取:可以当子类型构造函数中于超类型构造函数传递参数

 1      function SuberType(name) {
 2         this.name = name
 3       }
 4       function SubType() {
 5         //继承了SuberType,还传递了参数
 6         SuberType.call(this,"zhao")
 7         this.age = "27"
 8       }
 9       var instance = new SubType()
10       alert(instance.name) //zhao
11       alert(instance.age) //27

缺点:

办法还在构造函数中定义,函数无法复用。而且于超类型的原型中定义的办法,子类型是不可见的

 

组成继承

   
 原型链和构造函数的技术构成及齐。思路是行使原型链实现对原型属性与办法的接轨,而透过借用构造函数来落实对实例属性之存续

     

 1    function SuberType(name) {
 2       this.name = name
 3       this.colors = ["red","blue"]
 4     }
 5     SuberType.prototype.sayName = function () {
 6       alert(this.name)
 7     }
 8     function SubType(name,age) {
 9       //继承属性
10       SuberType.call(this, name)  // 第一次调用SuberType()
11       this.age = age
12     }
13     //继承方法
14     SubType.prototype = new SuberType()  //第二次调用SuberType()
15     SubType.prototype.sayAge = function () {
16       alert(this.age)
17     }
18     var instance1 = new SubType("zhao", 27)
19     instance1.colors.push("black")
20     alert(instance1.colors) // red,blue,black
21     instance1.sayName() // zhao
22     instance1.sayAge()  //27
23 
24     var instance2 = new SubType("w", 28)
25     alert(instance2.colors) // red,blue
26     instance2.sayName() // w
27     instance2.sayAge() // 28

优点:实例有独家的性,和同等之艺术

缺点:会俩软调整用超类型的构造函数

 

原型式继承

    借助原型可以根据已部分对象创建新对象,不必因此从定义类型

    

1    function object(o) {
2       function F() {}
3         F.prototype = o
4         return new F()6     }

面这个函数的本来面目是:object()对传播的靶子实施了平不良浅复制

 1  var person = {
 2       name: 'zhao',
 3       friends: ['zhao1','zhao2','zhao3']
 4     }
 5     var anotherPerson = object(person)
 6     anotherPerson.name = 'ss'
 7     anotherPerson.friends.push('Bob')
 8 
 9     var yetAnotherPerson = object(person)
10     yetAnotherPerson.name = 'rr'
11     yetAnotherPerson.friends.push('Bar')
12     alert(person.friends) //zhao1,zhao2,zhao3,Bob,Bar

ECMAScript5经新增Object.create()方法规范了原型式继承,这个方法接收俩单参数,一个当新目标原型的靶子同(可选的)一个也新目标定义额外属性的对象

以流传一个参数的气象下,Object.create()和object()一样

 1     var person = {
 2       name: 'zhao',
 3       friends: ['zhao1','zhao2','zhao3']
 4     }
 5     var anotherPerson = Object.create(person)
 6     anotherPerson.name = 'ss'
 7     anotherPerson.friends.push('Bob')
 8 
 9     var yetAnotherPerson = Object.create(person)
10     yetAnotherPerson.name = 'rr'
11     yetAnotherPerson.friends.push('Bar')
12     alert(person.friends) //zhao1,zhao2,zhao3,Bob,Bar

Object.create()的老二个参数会挂原型对象上的同名属性

 1     var person = {
 2       name: 'zhao',
 3       friends: ['zhao1','zhao2','zhao3']
 4     }
 5     var anotherPerson = Object.create(person)
 6     anotherPerson.name = 'ss'
 7     anotherPerson.friends.push('Bob')
 8 
 9     var yetAnotherPerson = Object.create(person)
10     yetAnotherPerson.name = 'rr'
11     yetAnotherPerson.friends.push('Bar')
12     alert(person.friends) //zhao1,zhao2,zhao3,Bob,Bar

 

寄生式继承

 
 思路:创建一个但用和包装继承过程的函数,该函数在里面以某种方式来增长对象,最后还如真地是它举行了有工作一样返回对象

   

 1 <script>
 2      function object(o) {
 3        function F() {}
 4        F.prototype = o
 5        return new F()
 6      }
 7 
 8      function createAnother(original) {
 9        var clone = object(original)  // 通过调用函数创建一个新对象
10        clone.sayHi = function () {  // 以某种方式来增强这个对象
11          alert("hi")
12        }
13        return clone  //返回这个对象
14      }
15      var person = {
16        name: "zhaobao",
17        friends: ["zhaobao1","zhaobao2","zhaobao3"]
18      }
19      var anotherPerson = createAnother(person)
20      anotherPerson.sayHi() // hi
21    </script>

 

寄生组合式继承

    这个要是为着化解做继承的弱项

   思路:通过假构造函数来连续属性,通过原型链的混成形式来延续方法。

             
不必为负定子类型的原型而调用超类型的构造函数,我们得之光是超类型原型的一个副本。

             
 本质上,就是应用寄生式继承来继续超类型的原型,然后还将结果指定给子类型的原型。

       基本模式

           

1   function inheritPrototype(subType, superType) {
2        var prototype = object(superType) //创建对象
3        prototype.constructor = subType  // 增强对象
4        subType.prototype = prototype  //指定对象
5      }

例子

  

 1 function inheritPrototype(subType, superType) {
 2        var prototype = object(superType) //创建对象
 3        prototype.constructor = subType  // 增强对象
 4        subType.prototype = prototype  //指定对象
 5      }
 6      function SuperType(name) {
 7        this.name = name
 8        this.colors = ["red","blue"]
 9      }
10      SuperType.prototype.sayName = function () {
11        alert(this.name)
12      }
13      function SubType(name,age) {
14        SuperType.call(this,name)
15        this.age = age
16      }
17      inheritPrototype(SubType,SuperType)
18      SuperType.prototype.sayAge = function () {
19        alert(this.age)
20      }

ECMAScript 2

 

 这个事例的胜效率提现在她就调用了同糟糕SuperType构造函数,并且为此避免了当SubType.prototype上面创建不必要之、多余的性能。与此同时,原型链还能保持无转移,因此,还会正常使用instanceof和isPrototypeOf()

即时是不过了不起的接轨方式