当前JavaScript

从上的ES6可以使用模板字符串：

let soMany = 10;
console.log(`This is ${soMany} times easier!`);
// "This is 10 times easier!"

详见下文Kim的回答。

较旧的答案

试试JavaScript的sprintf（）。

如果你真的想自己做一个简单的格式化方法，不要连续替换，而是同时替换。

因为当先前替换的替换字符串也包含如下格式序列时，提到的大多数其他建议都会失败：

"{0}{1}".format("{1}", "{0}")

通常，您希望输出为｛1｝｛0｝，但实际输出为｛1｝{1｝｝。所以要像恐惧噬菌体的建议那样同时进行替换。

我很惊讶没有人使用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”）);

旧答案的修改代码https://stackoverflow.com/a/18234317/19531844效率更高（没有较慢的RegExp）且更短

String.prototype.formatUnicorn = function () {
    let str = this.toString();
    if(!arguments.length) {
        return;
    };
    const [args] = arguments;
    for (const key of Object.keys(args)) {
        str = str.replaceAll(`{${key}}`, args[key]);
    };
    return str;
};

用法：

"{test} {test_2} {test}".formatUnicorn({"test": "hello", "test_2": "world"}); // yields hello world hello

新旧基准：https://jsben.ch/BRovx

我想分享我对“问题”的解决方案。我没有重新发明轮子，但试图根据JavaScript已经做的事情找到解决方案。优点是，您可以免费获得所有隐式转换。设置字符串的原型属性$提供了一个非常好和紧凑的语法（参见下面的示例）。这可能不是最有效的方法，但在大多数情况下，处理输出时不必进行超级优化。

String.form = function(str, arr) {
    var i = -1;
    function callback(exp, p0, p1, p2, p3, p4) {
        if (exp=='%%') return '%';
        if (arr[++i]===undefined) return undefined;
        exp  = p2 ? parseInt(p2.substr(1)) : undefined;
        var base = p3 ? parseInt(p3.substr(1)) : undefined;
        var val;
        switch (p4) {
            case 's': val = arr[i]; break;
            case 'c': val = arr[i][0]; break;
            case 'f': val = parseFloat(arr[i]).toFixed(exp); break;
            case 'p': val = parseFloat(arr[i]).toPrecision(exp); break;
            case 'e': val = parseFloat(arr[i]).toExponential(exp); break;
            case 'x': val = parseInt(arr[i]).toString(base?base:16); break;
            case 'd': val = parseFloat(parseInt(arr[i], base?base:10).toPrecision(exp)).toFixed(0); break;
        }
        val = typeof(val)=='object' ? JSON.stringify(val) : val.toString(base);
        var sz = parseInt(p1); /* padding size */
        var ch = p1 && p1[0]=='0' ? '0' : ' '; /* isnull? */
        while (val.length<sz) val = p0 !== undefined ? val+ch : ch+val; /* isminus? */
       return val;
    }
    var regex = /%(-)?(0?[0-9]+)?([.][0-9]+)?([#][0-9]+)?([scfpexd%])/g;
    return str.replace(regex, callback);
}

String.prototype.$ = function() {
    return String.form(this, Array.prototype.slice.call(arguments));
}

以下是几个示例：

String.format("%s %s", [ "This is a string", 11 ])
console.log("%s %s".$("This is a string", 11))
var arr = [ "12.3", 13.6 ]; console.log("Array: %s".$(arr));
var obj = { test:"test", id:12 }; console.log("Object: %s".$(obj));
console.log("%c", "Test");
console.log("%5d".$(12)); // '   12'
console.log("%05d".$(12)); // '00012'
console.log("%-5d".$(12)); // '12   '
console.log("%5.2d".$(123)); // '  120'
console.log("%5.2f".$(1.1)); // ' 1.10'
console.log("%10.2e".$(1.1)); // '   1.10e+0'
console.log("%5.3p".$(1.12345)); // ' 1.12'
console.log("%5x".$(45054)); // ' affe'
console.log("%20#2x".$("45054")); // '    1010111111111110'
console.log("%6#2d".$("111")); // '     7'
console.log("%6#16d".$("affe")); // ' 45054'

/**
 * Format string by replacing placeholders with value from element with
 * corresponsing index in `replacementArray`.
 * Replaces are made simultaneously, so that replacement values like
 * '{1}' will not mess up the function.
 *
 * Example 1:
 * ('{2} {1} {0}', ['three', 'two' ,'one']) -> 'one two three'
 *
 * Example 2:
 * ('{0}{1}', ['{1}', '{0}']) -> '{1}{0}'
 */
function stringFormat(formatString, replacementArray) {
    return formatString.replace(
        /\{(\d+)\}/g, // Matches placeholders, e.g. '{1}'
        function formatStringReplacer(match, placeholderIndex) {
            // Convert String to Number
            placeholderIndex = Number(placeholderIndex);

            // Make sure that index is within replacement array bounds
            if (placeholderIndex < 0 ||
                placeholderIndex > replacementArray.length - 1
            ) {
                return placeholderIndex;
            }

            // Replace placeholder with value from replacement array
            return replacementArray[placeholderIndex];
        }
    );
}

JavaScript中的数字格式

我来到这个问题页面，希望找到如何在JavaScript中格式化数字，而不引入另一个库。以下是我的发现：

舍入浮点数

JavaScript中sprintf（“%.2f”，num）的等价物似乎是num.toFixed（2），它将num格式化为2位小数，并带舍入（但请参见@ars265下面关于Math.round的评论）。

(12.345).toFixed(2); // returns "12.35" (rounding!)
(12.3).toFixed(2); // returns "12.30" (zero padding)

指数形式

sprintf（“%.2e”，num）的等效值为num.toExponential（2）。

(33333).toExponential(2); // "3.33e+4"

十六进制和其他基数

要以基数B打印数字，请尝试num.toString（B）。JavaScript支持从基数2到36的自动转换（此外，某些浏览器对base64编码的支持有限）。

(3735928559).toString(16); // to base 16: "deadbeef"
parseInt("deadbeef", 16); // from base 16: 3735928559

参考页

JS数字格式快速教程

toFixed（）的Mozilla参考页（带有指向Precision（）、toExponential（）、toLocaleString（）等的链接）