JavaScript继承的一些工具函数

在阅读精通JavaScript(图灵计算机科学丛书)里面有讲解javascript继承的一些东东。

其一是讲解DouglasCrockford的js

代码如下：

+ View Code?

//简单的辅助函数，让你可以将新函数绑定到对象prototype上

        Function.prototype.method = function (name, func) {

            this.prototype[name] = func;

            return this;

        }

        //一个相当复杂的函数，允许你方便地从其他对象继承函数，

        //同时仍然可以调用属于父对象的那些方法

        Function.method('inherits', function (parent) {

            var d = {}; //记录我们目前所在父层次的级数

            var p = (this.prototype = new parent()); //继承父对象的方法

            //创建一个新的名位uber的特权函数

            //调用它时会执行所有在继承时被重写的函数

            this.method("uber", function uber(name) {

                if (!(name in d)) {

                    d[name] = 0; //继承级数默认为0

                }

                var f, /*要执行的函数*/r, /*函数返回值*/t = d[name], v = parent.prototype; /*父对象的prototype*/

                if (t) {

                    //如果我们已经在某个uber函数内 上溯到必要的级数已找到原始的prototype

                    while (t) {

                        v = v.constructor.prototype;

                        t -= 1;

                    }

                    f = v[name]; //从prototype中获得函数

                }

                else {

                    //uber第一次调用 从prototype获得要执行的函数

                    f = p[name];

                    if (f == this[name]) {

                        //如果函数属于当前prototype 则改为调用父对象的prototype

                        f = v[name];

                    }

                }

                d[name] += 1; //记录我们在继承堆栈中所在位置

                //使用除第一个以外所有的arguments 调用函数 第一个参数是执行的匿名函数名

                r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));

                d[name] -= 1; //恢复继承堆栈

                return r;

            });

            return this;

        });

        //只继承父对象特定的函数。而非使用new parent（）的继承的所有函数

        Function.method("swiss", function (parent) {

            for (var i = 1; i < arguments.length; i++) {

                var name = arguments[i];

                this.prototype[name] = parent[name];

            }

            return this;

        });

        /* Function.prototype.method 它提供了一个简单的方法，把函数于构造函数原型关联起来。

        之所以有效，是因为所有的构造函数本身都是函数，所以能获得method这个新方法

        Function.prototype.inherits这一函数可以用于提供简单的对象继承，它的代码主要围绕任意对象方法中调用

        this.uber（methodname）为中心，并在让这个uber方法执行它要覆盖的父对象的方法。

        Function.prototype.swiss这是.method函数的增强版，可以用于单一父对象获取多个函数。如果有多个父对象上

        就能获得可用的多对象继承

        */

 

 调用代码：

?

function Person(name) {

         this.name = name;

     }

     Person.method("getName", function () { return this.name; });

     function User(name, password) {

         this.name = name;

         this.password = password;

     }

     User.inherits(Person);

     User.method("getPassword", function () { return this.password; });

     User.method("getName", function () { return "My name is :" + this.uber("getName"); });

 

     var p = new Person("123");

     alert(p.getName());

     var u = new User("abc", "456");

     alert(u.getPassword());

     alert(u.getName());

 第二个工具函数是base库

+ View Code?

/*

    Base.js, version 1.1a

    Copyright 2006-2010, Dean Edwards

    License: http://www.opensource.org/licenses/mit-license.php

*/

 

var Base = function() {

    // dummy

};

 

Base.extend = function(_instance, _static) { // subclass

    var extend = Base.prototype.extend;

     

    // build the prototype

    Base._prototyping = true;

    var proto = new this;

    extend.call(proto, _instance);

  proto.base = function() {

    // call this method from any other method to invoke that method's ancestor

  };

    delete Base._prototyping;

     

    // create the wrapper for the constructor function

    //var constructor = proto.constructor.valueOf(); //-dean

    var constructor = proto.constructor;

    var klass = proto.constructor = function() {

        if (!Base._prototyping) {

            if (this._constructing || this.constructor == klass) { // instantiation

                this._constructing = true;

                constructor.apply(this, arguments);

                delete this._constructing;

            } else if (arguments[0] != null) { // casting

                return (arguments[0].extend || extend).call(arguments[0], proto);

            }

        }

    };

     

    // build the class interface

    klass.ancestor = this;

    klass.extend = this.extend;

    klass.forEach = this.forEach;

    klass.implement = this.implement;

    klass.prototype = proto;

    klass.toString = this.toString;

    klass.valueOf = function(type) {

        //return (type == "object") ? klass : constructor; //-dean

        return (type == "object") ? klass : constructor.valueOf();

    };

    extend.call(klass, _static);

    // class initialisation

    if (typeof klass.init == "function") klass.init();

    return klass;

};

 

Base.prototype = { 

    extend: function(source, value) {

        if (arguments.length > 1) { // extending with a name/value pair

            var ancestor = this[source];

            if (ancestor && (typeof value == "function") && // overriding a method?

                // the valueOf() comparison is to avoid circular references

                (!ancestor.valueOf || ancestor.valueOf() != value.valueOf()) &&

                /\bbase\b/.test(value)) {

                // get the underlying method

                var method = value.valueOf();

                // override

                value = function() {

                    var previous = this.base || Base.prototype.base;

                    this.base = ancestor;

                    var returnValue = method.apply(this, arguments);

                    this.base = previous;

                    return returnValue;

                };

                // point to the underlying method

                value.valueOf = function(type) {

                    return (type == "object") ? value : method;

                };

                value.toString = Base.toString;

            }

            this[source] = value;

        } else if (source) { // extending with an object literal

            var extend = Base.prototype.extend;

            // if this object has a customised extend method then use it

            if (!Base._prototyping && typeof this != "function") {

                extend = this.extend || extend;

            }

            var proto = {toSource: null};

            // do the "toString" and other methods manually

            var hidden = ["constructor", "toString", "valueOf"];

            // if we are prototyping then include the constructor

            var i = Base._prototyping ? 0 : 1;

            while (key = hidden[i++]) {

                if (source[key] != proto[key]) {

                    extend.call(this, key, source[key]);

 

                }

            }

            // copy each of the source object's properties to this object

            for (var key in source) {

                if (!proto[key]) extend.call(this, key, source[key]);

            }

        }

        return this;

    }

};

 

// initialise

Base = Base.extend({

    constructor: function() {

        this.extend(arguments[0]);

    }

}, {

    ancestor: Object,

    version: "1.1",

     

    forEach: function(object, block, context) {

        for (var key in object) {

            if (this.prototype[key] === undefined) {

                block.call(context, object[key], key, object);

            }

        }

    },

         

    implement: function() {

        for (var i = 0; i < arguments.length; i++) {

            if (typeof arguments[i] == "function") {

                // if it's a function, call it

                arguments[i](this.prototype);

            } else {

                // add the interface using the extend method

                this.prototype.extend(arguments[i]);

            }

        }

        return this;

    },

     

    toString: function() {

        return String(this.valueOf());

    }

});

 

 调用代码：

?

var Person = Base.extend({

           constructor: function (name) { this.name = name; },

           getName: function () { return this.name; }

       });

 

       var User = Person.extend({

           constructor: function (name, password) {

               this.base(name);

               this.password = password;

           },

           getPassWord: function () { return this.password; }

       });

 

       var p = new Person("123");

       alert(p.getName());

       var u = new User("456", "abc");

       alert(u.getName());

       alert(u.getPassWord());

 有关base的详细介绍：http://dean.edwards.name/weblog/2006/03/base/