我对 Javascript 原型的扩展函数

必须事先声明，本人不赞成入侵 js 对象原型的做法。但是之所以要这样，是出于使用频率上的考虑。若不是这几个方法调用的频繁，决不会贸然加入原型里面去。

String.prototype.format

var cls = 'my-class', text = 'Some text';
var s = String.format('<div class="{0}">{1}</div>', cls, text);
//s现在是字符串：s now contains the string: '<div class="my-class">Some text</div>'

/**
 * 格式化字符串。
 * @param  {String} string 带标记的字符串，或者可变长度的字符串参数。
 * @param  {String} value1 第一个值，替换{0}。The value to replace token {0}
 * @param  {String} value2 第二个值，替换{1}...等等（可以有任意多个）。Etc...
 * @return {String} 转化过的字符串。The formatted string
 */
String.prototype.format = function () {
    var regexp = /{(\d+)}/g, replace = String.prototype.replace;

    function replaceEl(m, i) {
        return this[i]; // this为arguments
    }
    /* At first run, with override it. */
    var fn = String.prototype.format = function () {
        replaceEl.scope = arguments; // 委托作用域
        return replace.call(this, regexp, replaceEl.delegate());
    }
    return fn.apply(this, arguments); // first run
}

Date.prototype.format

日期格式化。详见我以往博客文章：《JavaScript自定义日期格式化函数》http://blog.csdn.net/zhangxin09/archive/2011/01/01/6111294.aspx 例子：

alert(new Date().format("yyyy-MM-dd hh:mm:ss"));

Date.prototype.format 源码如下：

/**
 * 日期格式化
 * @param 	{String} format
 * @return	{String}
*/
Date.prototype.format = function (format) {
    var $1, o = {
        "M+": this.getMonth() + 1,		// 月份，从0开始算
        "d+": this.getDate(),   		// 日期
        "h+": this.getHours(),   		// 小时
        "m+": this.getMinutes(), 		// 分钟
        "s+": this.getSeconds(), 		// 秒钟
								        // 季度 quarter
        "q+": Math.floor((this.getMonth() + 3) / 3),
        "S": this.getMilliseconds()	// 千秒
    };
    var key, value;

    if (/(y+)/.test(format)) {
        $1 = RegExp.$1, 
        format = format.replace($1, String(this.getFullYear()).substr(4 - $1));
    }

    for (key in o) { // 如果没有指定该参数，则子字符串将延续到 stringvar 的最后。
        if (new RegExp("(" + key + ")").test(format)) {
            $1		= RegExp.$1,
	    	value	= String(o[key]),
	    	value	= $1.length == 1 ? value : ("00" + value).substr(value.length),
    		format	= format.replace($1, value);
        }
    }
    return format;
}

Function.prototype.delegate

delegate() 即是委派的意思，Function.prototype.delegate() 就是函数的委托。delegate 方法字在我所使用的库中应用广泛，大体可以分为两个地方的使用，即在函数的参数中使用和在函数的作用域中使用。后者指的是封装对象（this或者环绕闭包）。delegate 方法可以使得函数的 this 指针改变。预设函数的作用域。考查下面两个方法：

Function.prototype.delegateScope = function (scope){
	var self = this;
	return function(){
		return self.apply(scope, arguments);
	}
}
	
Function.prototype.delegateArgs = function(){
	var self  = this, args	 = arguments;
		    
	return function(){
		return self.apply(this, args);
	};
}

Function.prototype.delegate 源码如下（另有 after 方法，比较简单，请看源码）：

/**
* 函数委托 force Args！ so there's no args, it server as Args!
* @return {Function}
*/
Function.prototype.delegate = function () {
    var self = this, scope = this.scope, args = arguments, aLength = arguments.length, fnToken = 'function';

    return function () {
        var 
    	 bLength = arguments.length
    	, Length = (aLength > bLength) ? aLength : bLength;

        // mission one:
        for (var i = 0; i < Length; i++) {
            if (arguments[i]) {
                args[i] = arguments[i]; // 拷贝参数
            }
        }

        args.length = Length; // 在 MS jscript下面，arguments作为数字来使用还是有问题，就是length不能自动更新。修正如左:

        // mission two:
        for (var i = 0, j = args.length; i < j; i++) {
            var _arg = args[i];
            if (_arg && typeof _arg == fnToken && _arg.late == true) {
                args[i] = _arg.apply(scope || this, args);
            }
        }

        return self.apply(scope || this, args);
    };
}

if (!Function.prototype.bind) {
    Function.prototype.bind = function (scope) {
        this.scope = scope;
        return this.delegate();
    }
}

/**
* 设置一个后置函数。
* @param  {Function} composeFn
* @param  {Boolean}  isForceCall 是否强行执行 call 方法。设置为 true 在数组作为单独对象的时候有用。
* @return {Function}
*/
Function.prototype.after = function (composeFn, isForceCall, scope) {
    var self = this;

    return function () {
        var result = self.apply(scope || this, arguments);

        if (isForceCall) {
            return composeFn.call(this, result);
        }

        return result && (typeof result.pop != 'undefined') && (typeof result.pop != 'unknown')
    		 ? composeFn.apply(this, result)
    		 : composeFn.call(this, result);
    };
}

碉堡了！

有次使用 String.prototype.format，发现它要依赖 Function.prototype.delegate，而且又闭包、又正则什么乱七八糟的，十分累的说。于是上网搜索更好的方案，起初是抱着试试看的心态，没想发现一个极其简洁的思路！十分自然而且效率高。回想之前搞的，可能也是从这么简单开始的，但越走越后，却走火入魔了，到现在真是“反人类的”。

String.prototype.format = function () {
	var str = this; 
	for(var i = 0, j = arguments.length; i < j; i++){
		str = str.replace(new RegExp('\\{' + i +'\\}', 'g'), arguments[i]);
	}

	return str;
}

console.log('hihih {0}, ,{2}'.format('dfasda', '34324343','dffds34324'));