String.prototype.repeat = function(n) { 
    return new Array(++n).join(this); 
};

String.prototype.pad = function(requiredLength, paddingStr, paddingType) {    
    var n = requiredLength - this.length; 

    if (n) {
        paddingType = paddingType ? paddingType.toLowerCase() : '';
        paddingStr = paddingStr || ' ';
        paddingStr = paddingStr.repeat( Math.ceil(n / paddingStr.length) ).substr(0, n);

        if (paddingType == 'both') {
            n /= 2;
            return paddingStr.substr( 0, Math.ceil(n) ) + this + paddingStr.substr( 0, Math.floor(n) );
        }   

        if (paddingType == 'left') {
            return paddingStr + this;
        }

        return this + paddingStr;
    } 

    return this; 
}; 

// синтаксис аналогичен printf
// 'Привет, %s!'.format('мир') -> "Привет, мир!"
// '%.1s.%.1s. %s'.format('Иван', 'Иванович', 'Иванов') -> "И.И. Иванов"
String.prototype.format = function() {
    var i = 0, 
        params = arguments;

    return this.replace(/%(?:%|(?:(|[+-]+)(|0|'.+?)([1-9]\d*)?(?:\.([1-9]\d*))?)?(s|d|f))/g, function(match, sign, padding, width, precision, type) {
        if (match == '%%') { 
            return '%'; 
        }

        var v = params[i++];

        if (type == 'd') { 
            v = Math.round(v); 
        }
        else if (type == 'f') {
            v = v.toFixed(precision ? precision : 6);
        }

        if (/\+/.test(sign) && v > 0) {
            v = '+' + v;
        }

        v += '';

        if (type != 'f' && precision) {
            v = v.substr(0, precision);
        }

        if (width) {
            v = v.pad(width, padding == '' ? ' ' : padding[0] == "'" ? padding.substr(1) : padding, /-/.test(sign) ? 'right' : 'left'); 
        }

        return v;
    });
};

// this.name = 'Вася';
// console.log( 'Привет, ${name}!'.template(this) );
// "Привет, Вася!"
String.prototype.template = function(context) {
    return this.replace(/\$\{(.*?)\}/g, function(match, name) {
        return context[name];
    });
};

基于先前建议的解决方案：

// First, checks if it isn't implemented yet.
if (!String.prototype.format) {
  String.prototype.format = function() {
    var args = arguments;
    return this.replace(/{(\d+)}/g, function(match, number) { 
      return typeof args[number] != 'undefined'
        ? args[number]
        : match
      ;
    });
  };
}

“｛0｝已死亡，但｛1｝仍活着！｛0｛｛2｝”.format（“ASP”，“ASP.NET”）

输出

ASP死了，但ASP.NET活了！ASP｛2｝

如果您不想修改String的原型：

if (!String.format) {
  String.format = function(format) {
    var args = Array.prototype.slice.call(arguments, 1);
    return format.replace(/{(\d+)}/g, function(match, number) { 
      return typeof args[number] != 'undefined'
        ? args[number] 
        : match
      ;
    });
  };
}

让您更加熟悉：

String.format（“｛0｝无效，但｛1｝有效！｛0｛｛2｝”，“ASP”，“ASP.NET”）；

结果相同：

ASP死了，但ASP.NET活了！ASP｛2｝

我需要一个函数，它可以以用户喜欢的方式格式化价格（以美分为单位），而棘手的是，格式是由用户指定的——我不希望我的用户理解类似printf的语法或regexp等。我的解决方案与Basic中使用的解决方案有些相似，因此用户只需使用数字的#位置进行标记，例如：

simple_format(1234567,"$ ###,###,###.##")
"$ 12,345.67"
simple_format(1234567,"### ### ###,## pln")
"12 345,67 pln"

我相信这很容易被用户理解，也很容易实现：

function simple_format(integer,format){
  var text = "";
  for(var i=format.length;i--;){
    if(format[i]=='#'){
      text = (integer%10) + text;
      integer=Math.floor(integer/10);
      if(integer==0){
        return format.substr(0,i).replace(/#(.*#)?/,"")+text;
      }
    }else{
      text = format[i] + text;
    }
  }
  return text;
}

我需要更进一步的解决方案。

我可以重用一个模板，不仅在声明中生成字符串，而且在执行时间的随机时间生成字符串。

所以我遇到了这个夹具：

 class Texplate{
    constructor(...args){
        this.data = args;
    }

    apply(...args){
        var text = "";
        var i = 0, j = 0, n = this.data.length, m = args.length;
        for(;i < n && j < m; i++, j++){
            text += this.data[i] + args[j];
        }

        for (; i < n; i++){
            text += this.data[i];
        }

        for (; j < m; j++){
            text += args[j];
        }

        return text;        
    }
}

这允许创建一个文本模板，该模板在内部用作数组合并算法，从构造函数中定义的文本数组开始。

使用示例：

var Textplate example = new Texplate("Hello, ", "!"); 
console.log(example.apply("Frank"));
console.log(example.apply("Mary"));
console.log(example.apply());
console.log(example.apply("Frank", " Have a good day!"));

String.prototype.format=函数（）{var final=字符串（this）；for（设i=0；i<arguments.length；i++）{final=final.replace（“%s$｛i+1｝”，参数[i]）}return final |“”}console.log（（“hello%s2 how%s3 you%s1”）.format（'hi'，'hello'，'how'））；<h1 id=“text”></h1>

我很惊讶没有人使用reduce，这是一个本机简洁而强大的JavaScript函数。

ES6（EcmaScript2015）

String.prototype.format=函数（）{return[…arguments].reduce（（p，c）=>p.replace（/%s/，c），this）；};console.log（'是%s还是%s？…不，是%s！'。格式（'平面'，'鸟'，'SOman'）；

<ES6

function interpolate(theString, argumentArray) {
    var regex = /%s/;
    var _r=function(p,c){return p.replace(regex,c);}
    return argumentArray.reduce(_r, theString);
}

interpolate("%s, %s and %s", ["Me", "myself", "I"]); // "Me, myself and I"

工作原理：

reduce对累加器和数组中的每个元素（从左到右）应用一个函数，以将其减少为单个值。

var _r=函数（p，c）｛return p.replace（/%s/，c）｝；控制台日志([“a”，“b”，“c”].reduce（_r，“[%s]，[%s]和[%s]”）+'\n'，[1，2，3].reduce（_r，“%s+%s=%s”）+'\n'，[“cool”，1337，“stuff”].reduce（_r，“%s%s%s”）);