function format(number,pattern){
    var str            = number.toString();
    var strInt;
    var strFloat;
    var formatInt;
    var formatFloat;
    if(/\./g.test(pattern)){
        formatInt        = pattern.split('.')[0];
        formatFloat        = pattern.split('.')[1];
    }else{
        formatInt        = pattern;
        formatFloat        = null;
    }
    if(/\./g.test(str)){
        if(formatFloat!=null){
            var tempFloat    = Math.round(parseFloat('0.'+str.split('.')[1])*Math.pow(10,formatFloat.length))/Math.pow(10,formatFloat.length);
            strInt        = (Math.floor(number)+Math.floor(tempFloat)).toString();                
            strFloat    = /\./g.test(tempFloat.toString())?tempFloat.toString().split('.')[1]:'0';            
        }else{
            strInt        = Math.round(number).toString();
            strFloat    = '0';
        }
    }else{
        strInt        = str;
        strFloat    = '0';
    }
    if(formatInt!=null){
        var outputInt    = '';
        var zero        = formatInt.match(/0*$/)[0].length;
        var comma        = null;
        if(/,/g.test(formatInt)){
            comma        = formatInt.match(/,[^,]*/)[0].length-1;
        }
        var newReg        = new RegExp('(\\d{'+comma+'})','g');        if(strInt.length<zero){
            outputInt        = new Array(zero+1).join('0')+strInt;
            outputInt        = outputInt.substr(outputInt.length-zero,zero)
        }else{
            outputInt        = strInt;
        }        var 
        outputInt            = outputInt.substr(0,outputInt.length%comma)+outputInt.substring(outputInt.length%comma).replace(newReg,(comma!=null?',':'')+'$1')
        outputInt            = outputInt.replace(/^,/,'');        strInt    = outputInt;
    }    if(formatFloat!=null){
        var outputFloat    = '';
        var zero        = formatFloat.match(/^0*/)[0].length;        if(strFloat.length<zero){
            outputFloat        = strFloat+new Array(zero+1).join('0');
            //outputFloat        = outputFloat.substring(0,formatFloat.length);
            var outputFloat1    = outputFloat.substring(0,zero);
            var outputFloat2    = outputFloat.substring(zero,formatFloat.length);
            outputFloat        = outputFloat1+outputFloat2.replace(/0*$/,'');
        }else{
            outputFloat        = strFloat.substring(0,formatFloat.length);
        }        strFloat    = outputFloat;
    }else{
        if(pattern!='' || (pattern=='' && strFloat=='0')){
            strFloat    = '';
        }
    }    return strInt+(strFloat==''?'':'.'+strFloat);
}
alert(format(123,   '#.00 ') )
alert(format(123,   '0.## ') )
alert(format(123,   '0000.00')) 

解决方案 »

  1.   

    格式字符串只有 #.00,   0.##,   0000.00,###,###.00,   (####)########, 这几种情况?
    如果是的话就比较好写,如1楼说的,用IF判断再做处理就OK了啊
      

  2.   

    呵呵蛮有意思..
    <script type="text/javascript">
    var format = function (number, form) {
    //大概就先这样,代码先不浓缩了。。:D
    var forms = form.split('.'), number = '' + number, numbers = number.split('.')
    , leftnumber = numbers[0].split('')
    , exec = function (lastMatch, $1, $2) {
    if ($1 !== '' || $2 !== '') {
    if (leftnumber.length) {
    return leftnumber.pop();
    } else if ($2 !== '') {
    return lastMatch;
    } else {
    return '';
    }
    } else {
    return lastMatch;
    }
    }, string

    string = forms[0].split('').reverse().join('').replace(/(?:(#)|(0)|.)/g, exec).split('').reverse().join('');
    string = leftnumber.join('') + string;

    if (forms[1] && forms[1].length) {
    leftnumber = (numbers[1] && numbers[1].length) ? numbers[1].split('').reverse() : [];
    string += '.' + forms[1].replace(/(?:(#)|(0)|.)/g, exec);
    }
    alert(string.replace(/\.$/, ''));
    };
    format(123, '#.00')                                           //输出   123.00 
    format(123, '0.##')                                           //输出   123 
    format(123, '0000.00 ')                                     //输出   0123.00 
    format(123456, '###,###.00')                         //输出   123,456.00 
    format(07552482630, '(####)########')       //输出   (0755)2482630 
    </script>
      

  3.   

    format(07552482630, '(####)########')       //输出   (0755)2482630 这个注释不对.
    LZ注意下.
    07数值类型会直接成7
    然后你的#里又多写了个
      

  4.   

    我改下...郁闷...刚从FF里测试,没问题,没想到在IE里出问题...
    捕获竟然有差别...IE是undefined FF是'' 索性直接改了不捕获了.
    <script type="text/javascript">
    var format = function (number, form) {
    //大概就先这样,代码先不浓缩了。。:D
        var forms = form.split('.'), number = '' + number, numbers = number.split('.')
            , leftnumber = numbers[0].split('')
            , exec = function (lastMatch) {
                if (lastMatch == '0' || lastMatch == '#') {
                    if (leftnumber.length) {
                        return leftnumber.pop();
                    } else if (lastMatch == '0') {
                        return lastMatch;
                    } else {
                        return '';
                    }
                } else {
                    return lastMatch;
                }
        }, string
        
        string = forms[0].split('').reverse().join('').replace(/./g, exec).split('').reverse().join('');
        string = leftnumber.join('') + string;
        
        if (forms[1] && forms[1].length) {
            leftnumber = (numbers[1] && numbers[1].length) ? numbers[1].split('').reverse() : [];
            string += '.' + forms[1].replace(/./g, exec);
        }
    return string.replace(/\.$/, '');
    };
    alert(format(123, '#.00'))                         //输出   123.00 
    alert(format(123, '0.##'))                         //输出   123 
    alert(format(123, '0000.00 '))                     //输出   0123.00 
    alert(format(123456, '###,###.00'))                //输出   123,456.00 
    alert(format(07552482630, '(####)########'))       //输出   (0755)2482630 
    </script>
      

  5.   

    to muxrwc:谢谢你的回答,试了一下还是有点问题。谢谢各位的回答,从中得到不少启发,现在已经想到解决办法了,
    等我自己写出来后,将贴上来给大家分享
      

  6.   

    格式符设计不良 
    这种东西是不宜用正则的
    用这个:status machine
      

  7.   

    这里我再补充一下规则:
    对于#匹配符号不产生对数字的截取,对于0匹配符才对数字产生截取(当0的数量小于数字数量时),
    格式化之后的数字 开头不能为“,”号,结束也不能为“,”。想了一下,用正则不大容易实现,以下是我写的,经过测试无误!
    如果用正则能实现,望大家能贴出分享,谢谢    <script language="javascript">
            //格式化数字
            function format(v, formatString){
                var parterns = formatString.split(".");
                var numbers = v.split(".");
                
                var lparterns = parterns[0].split("");
                var lparternsbak = parterns[0].split("");
                var lnumbers = numbers[0].split("");
                
                var lkeep = "";
                var rkeep = "";
                
                //得到左侧要替换的部分
                var lplaces = [];
                for(var i=0;i<lparterns.length;i++){
                    var parternchar = lparterns[i];
                    if (parternchar == "#" || parternchar == "0"){
                        lplaces.push(i);
                    }
                }            //替换左侧,左侧有数字才要替换,以避免v = .99型的数字而产生错误
                if (lnumbers[0] && lnumbers[0].length>0){
                    var numberIndex = lnumbers.length - 1;
                    var replaced = 0; 
                    for(var i=lplaces.length - 1;i>=0;i--){
                        replaced ++;    //被替换的字符数量
                        var place = lplaces[i];
                        lparterns[place] = lnumbers[numberIndex];
                        
                        if (numberIndex == 0) {
                            break;
                        }
                        numberIndex--;
                    }
                    
                    //处理以#为第一个格式(#前可能有非0的其他串也在此范围)的格式串,对于以#开头的格式串,将不会截取数字串,要补齐
                    var lstartIdx = lplaces[0];
                    
                    if (lparternsbak[lstartIdx]=="#"){
                        if (lnumbers.length > replaced){
                            var idx = lnumbers.length - replaced;
                            for(var i=0;i<idx;i++){
                                lkeep += lnumbers[i];
                            }
                            
                            lparterns[lstartIdx] = lkeep + lparterns[lstartIdx];
                        }
                    }
                }
                
                //替换右侧
                if (parterns[1] && parterns[1].length > 0){
                    var rparterns = parterns[1].split("");
                    var rparternsbak = parterns[1].split("");
                    
                    if (numbers[1] && numbers[1].length>0){
                        var rnumbers = numbers[1].split("");                    //得到右侧将要替换的部分
                        var rplaces = [];
                        for(var i=0;i<rparterns.length;i++){
                            var parternchar = rparterns[i];
                            if (parternchar == "#" || parternchar == "0"){
                                rplaces.push(i);
                            }
                        }
                        
                        var replaced = 0; 
                        for(var i=0;i<rplaces.length;i++){
                            replaced ++;    //被替换的字符数量
                            var place = rplaces[i];
                            rparterns[place] = rnumbers[i];
                            
                            if (i==rnumbers.length - 1){
                                break;
                            }
                        }
                        
                        //处理以#结束的(#后有非0的串也在此范围)
                        var rlastIdx = rplaces[rplaces.length-1];
                        if (rparternsbak[rlastIdx]=="#"){
                            for(var i=replaced-1;i<rnumbers.length;i++){
                                rkeep += rnumbers[i];
                            }
                            
                            rparterns[rlastIdx] += rkeep;
                        }
                    }
                }
                
                for(var i=0;i<lparterns.length;i++){
                    if (lparterns[i]=="#"){
                        lparterns[i] = "";
                    }
                }
                
                var result = lparterns.join("");
                if (parterns[1]){
                    for(var i=0;i<rparterns.length;i++){
                        if (rparterns[i] == "#"){
                            rparterns[i] = "";
                        }
                    }
                    result += "." + rparterns.join("");
                }
                
                //第一位不能为,号
                if (result.substring(0,1)==","){
                    result = result.substring(1);
                }
                
                //最后一位也不能为,号
                if (result.substring(result.length-1)==","){
                    result = result.substring(0,result.length);
                }
                return result;
            }        alert(format("12345.67","#,###.00"));          //输出:12,345.67
            alert(format("12345.67","0,000.00"));          //输出:2,345.67(0匹配符,产生了截取)
            alert(format("12345.67","#.00"));              //输出:12345.00
            alert(format("12345.67","¥#,###元0角0分"));    //输出:¥12,345元6角7分
            alert(format(".67","#,###.00"));               //输出:.67
            alert(format(".67","###,##0.00"));             //输出:0.67
            alert(format("12345.67","FUCK CNN#想怎样输出就怎样,##输出#FUCK JAPANESE.0祖国万岁"));
            //输出:FUCK CNN12想怎样输出就怎样,34输出5FUCK JAPANESE.6祖国万岁  (:D,一般没这么离谱,在前后加特殊字符比较常用)
            alert(format("12345.67","钱不少啊¥###,##0.00元"));       //输出:钱不少啊¥12,345.67元
            alert(format("075524826309","(#)########"));            //输出:(0755)24826309
            alert(format("075524826309","(000)########"));          //输出:(755)24826309 (取三位区号)    </script>
      

  8.   


    编程动力 http://www.bcexe.com 专业的编程开发类网站,网络编程,软件开发,网站开发,一切尽在这里!
      

  9.   

    <script>
    String.prototype.format = function(f) {
    this.fStr = function (n,f,p){
    var fc=s=r="",pos;
    if(!p){
    n=n.split("").reverse().join("")
    f=f.split("").reverse().join("")
    }
    for (var i=j=0; i<f.length; i++,j++) {
    s = n.charAt(j)
    fc = f.charAt(i)
    switch (fc) {
    case "#" :
    r += s;pos=i;break;
    case "0" :
    r = s||s==fc?(r+s):(p?0+r:r+0);pos=i;break;
    case "." :
    r += s==fc?s:(j--,fc);break;
    case "," :
    r += s==fc?s:(j--,fc);break;
    default :
    r += fc;
    j--;
    }
    }
    if(j!=n.length&&f.charAt(f.length-1)!="0"&&pos!=f.length&&f.charAt(pos)!="0")r = r.substr(0,pos+1)+n.substr(j)+r.substr(pos+1)
    return (p?r:r.split("").reverse().join("")).replace(/(^,)|(,$)|(,,+)/g,"");
    }
    var n = this.toString();
    if(n.length==0)return "";
    if (f == undefined)return this;
    f = f.split("."),n = n.split(".");
    return  f.length>1?this.fStr(n[0],f[0])+"."+this.fStr(n[1],f[1],1):this.fStr(n[0],f[0]);
    }
    n = "12442.0911";
    document.write(n.format("a#a0#.0##a"))
    </script>
    用截取字符串的方法写了一个,测一下看是否还有特例没包含进去的。
      

  10.   

    <script>
    String.prototype.format = function(f) {
    this.fStr = function (n,f,p){
    var fc=s=r="",pos;
    if(!p){
    n=n.split("").reverse().join("")
    f=f.split("").reverse().join("")
    }
    for (var i=j=0; i<f.length; i++,j++) {
    s = n.charAt(j)
    fc = f.charAt(i)
    switch (fc) {
    case "#" :
    r += s;pos=i;break;
    case "0" :
    r = s||s==fc?(r+s):r+0;pos=i;break;//原方法,这里对小数点后的处理有点问题.
    case "." :
    r += s==fc?s:(j--,fc);break;
    case "," :
    r += s==fc?s:(j--,fc);break;
    default :
    r += fc;
    j--;
    }
    }
    if(j!=n.length&&f.charAt(f.length-1)!="0"&&pos!=f.length&&f.charAt(pos)!="0")r = r.substr(0,pos+1)+n.substr(j)+r.substr(pos+1)
    return (p?r:r.split("").reverse().join("")).replace(/(^,)|(,$)|(,,+)/g,"");
    }
    var n = this.toString();
    if(n.length==0)return "";
    if (f == undefined)return this;
    f = f.split("."),n = n.split(".");
    return  f.length>1?this.fStr(n[0],f[0])+"."+this.fStr(n[1],f[1],1):this.fStr(n[0],f[0]);
    }
    n = ".0911";
    document.write(n.format("a00#a0#00.0#0000a"))
    </script>
    上面的有个错误,改了一下.
      

  11.   

    发现一个小错误,当数字为整数,格式带有小数时会出错。改了改。并且改成函数方式,如下:function num_format(num_in,f){
        
    var n = num_in.toString();
    if(n.length==0)return "";
    if (f == undefined)return num_in;
        f = f.split("."),n = n.split(".");
        return     f.length>1?fStr(n[0],f[0])+"."+ (n.length<=1?fStr("0",f[1],1):fStr(n[1],f[1],1)):fStr(n[0],f[0]);//就改了这一行

        function fStr(n,f,p){        
            var fc=s=r="",pos;
            if(!p){
                n=n.split("").reverse().join("")
                f=f.split("").reverse().join("")
            }
            for (var i=j=0; i<f.length; i++,j++) {
                s = n.charAt(j)
                fc = f.charAt(i)
                switch (fc) {
                    case "#" :
                        r += s;pos=i;break;
                    case "0" :
                        r = s||s==fc?(r+s):r+0;pos=i;break;
                    case "." :
                        r += s==fc?s:(j--,fc);break;
                    case "," :
                        r += s==fc?s:(j--,fc);break;
                    default :
                        r += fc;
                        j--;
                }
            }
            if(j!=n.length&&f.charAt(f.length-1)!="0"&&pos!=f.length&&f.charAt(pos)!="0")r = r.substr(0,pos+1)+n.substr(j)+r.substr(pos+1)
            return (p?r:r.split("").reverse().join("")).replace(/(^,)|(,$)|(,,+)/g,"");
        }    
    };
      

  12.   

    收藏!!!!!!GOOD!!!!
      

  13.   

    在楼主的函数基础上改的,主要是改正四舍五入,%号,与整数部分像format(343,"0.00")输出3.00截错数的问题// JScript 文件
            function format(val, formatString){ 
                var re=/%/;
                  if(re.test(formatString))
                 {
                 val=val*100;
                 }
                 
                var patterns = formatString.split("."); 
                var numbers = (val+"").split("."); 
                var lpatterns = patterns[0].split(""); 
                var lpatternsbak = patterns[0].split(""); 
              
                
                var lkeep = ""; 
                var rkeep = ""; 
               
               
                   //小数点后大于样式长度进行四舍五入
                if (numbers[1]){ 
                var rnumbers=numbers[1].split("");
                var count=0;
                 if(patterns[1]){
                 var rpatterns = patterns[1].split(""); 
                  
                  for(var i=0;i< rpatterns.length;i++){
                   if(rpatterns[i]=="#"|| rpatterns[i]=="0"){
                      count++;
                     }
                   }
                 }
                  if(rnumbers.length>count){
                   numbers = ( val.toFixed(count)+"").split("."); 
                  }
                     
                 }
                  var lnumbers = numbers[0].split(""); 
                      //得到左侧要替换的部分 
                var lplaces = [];
                for(var i=0;i <lpatterns.length;i++){ 
                    var parternchar = lpatterns[i];
                     
                    if (parternchar == "#" || parternchar == "0"){ 
                        lplaces.push(i); 
                    } 
                } 
            
                //替换左侧,左侧有数字才要替换,以避免v = .99型的数字而产生错误 
                if (lnumbers[0] && lnumbers[0].length>0){ 
                    var numberIndex = lnumbers.length - 1; 
                    var replaced = 0; 
                    for(var i=lplaces.length - 1;i>=0;i--){ 
                        replaced ++;    //被替换的字符数量 
                        var place = lplaces[i]; 
                        lpatterns[place] = lnumbers[numberIndex]; 
                        
                        if (numberIndex == 0) { 
                            break; 
                        } 
                        numberIndex--; 
                    } 
                    
                    //处理以#为第一个格式(#前可能有非0的其他串也在此范围)的格式串,对于以#开头的格式串,将不会截取数字串,要补齐 
                    var lstartIdx = lplaces[0]; 
                    
                    //补漏
                var nlen=lnumbers.length;
                var plen=lplaces.length;
                if(nlen>plen)
                 lpatternsbak.splice(lstartIdx,0,"#");
                    
                    
                    if (lpatternsbak[lstartIdx]=="#"){ 
                        if (lnumbers.length > replaced){ 
                            var idx = lnumbers.length - replaced; 
                            for(var i=0;i <idx;i++){ 
                                lkeep += lnumbers[i]; 
                            } 
                            
                            lpatterns[lstartIdx] = lkeep + lpatterns[lstartIdx]; 
                        } 
                    } 
                } 
                
                //替换右侧 
                if (patterns[1] && patterns[1].length > 0){ 
                    var rpatterns = patterns[1].split(""); 
                     if (numbers[1] && numbers[1].length>0){ 
                        var rnumbers = numbers[1].split("");                     //得到右侧将要替换的部分 
                        var rplaces = []; 
                        for(var i=0;i <rpatterns.length;i++){ 
                            var parternchar = rpatterns[i]; 
                            if (parternchar == "#" || parternchar == "0"){ 
                                rplaces.push(i); 
                            } 
                        } 
                        
                        var replaced = 0; 
                        for(var i=0;i <rplaces.length;i++){ 
                            replaced ++;    //被替换的字符数量 
                            var place = rplaces[i]; 
                            rpatterns[place] = rnumbers[i]; 
                            
                            if (i==rnumbers.length - 1){ 
                                break; 
                            } 
                        } 
                        
                      
                     
                    } 
                } 
                
                for(var i=0;i <lpatterns.length;i++){ 
                    if (lpatterns[i]=="#"){ 
                        lpatterns[i] = ""; 
                    } 
                } 
                
                var result = lpatterns.join(""); 
                if (patterns[1]){ 
                    for(var i=0;i <rpatterns.length;i++){ 
                        if (rpatterns[i] == "#"){ 
                            rpatterns[i] = ""; 
                        } 
                    } 
                    result += "." + rpatterns.join(""); 
                } 
                
                //第一位不能为,号 
                if (result.substring(0,1)==","){ 
                    result = result.substring(1); 
                } 
                
                //最后一位也不能为,号 
                if (result.substring(result.length-1)==","){ 
                    result = result.substring(0,result.length); 
                } 
                return result; 
            } format(0.784,"0.0%")=78.4%;
    format(321.49,"0.0")=321.5;(vb的format是这样的,整数不应该截走,小数却可以)