• JavaScript继承的一些工具函数


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

    其一是讲解DouglasCrockford的js

    代码如下:

    //简单的辅助函数,让你可以将新函数绑定到对象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

    /*
    	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/

  • 相关阅读:
    mybatis使用说明
    maven相关说明,以及使用Testng相关
    java注解相关
    maven安装,使用说明,及maven Repository如何使用.
    css相关知识
    Spring Ioc 基于Java的容器配置
    Spring DI的配置使用
    Spring —IoC的配置使用
    Spring IoC 之IoC容器的基本原理
    Spring IOC之IOC基础
  • 原文地址:https://www.cnblogs.com/majiang/p/2564036.html
Copyright © 2020-2023  润新知