我正在寻找一个等效于C / PHP printf()或C＃/ Java程序员的String.Format() （适用于.NET的IFormatProvider String.Format() JavaScript。

我的基本要求是现在使用数字的千位分隔符格式，但是可以处理很多组合（包括日期）的东西会很好。

我意识到Microsoft的Ajax库提供了String.Format()的版本，但是我们不希望该框架的全部开销。

#1楼

我这里的JavaScript格式化程序稍长...

您可以通过以下几种方式进行格式化：

String.format(input, args0, arg1, ...)
String.format(input, obj)
"literal".format(arg0, arg1, ...)
"literal".format(obj)

另外，如果您说一个ObjectBase.prototype.format（例如DateJS ），它将使用它。

例子...

var input = "numbered args ({0}-{1}-{2}-{3})";
console.log(String.format(input, "first", 2, new Date()));
//Outputs "numbered args (first-2-Thu May 31 2012...Time)-{3})"console.log(input.format("first", 2, new Date()));
//Outputs "numbered args(first-2-Thu May 31 2012...Time)-{3})"console.log(input.format("object properties ({first}-{second}-{third:yyyy-MM-dd}-{fourth})",{'first':'first','second':2,'third':new Date() //assumes Date.prototype.format method}
));
//Outputs "object properties (first-2-2012-05-31-{3})"

我还使用.asFormat作为别名，并在已经存在string.format的情况下进行了一些检测（例如，使用MS Ajax Toolkit（我讨厌该库））。

#2楼

我没有看到String.format变体：

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

#3楼

一个非常不同的版本，我喜欢的版本（此版本使用{xxx}令牌而不是{0}编号的参数，它具有更多的自说明性，并且更适合本地化）：

String.prototype.format = function(tokens) {var formatted = this;for (var token in tokens)if (tokens.hasOwnProperty(token))formatted = formatted.replace(RegExp("{" + token + "}", "g"), tokens[token]);return formatted;
};

一个变化是：

  var formatted = l(this);

首先调用l（）本地化函数。

#4楼

我想分享我对“问题”的解决方案。我还没有重新发明轮子，而是尝试根据JavaScript已经完成的工作找到解决方案。好处是，您可以免费获得所有隐式转换。设置String的原型属性$提供了一种非常简洁的语法（请参见下面的示例）。这可能不是最有效的方法，但是在大多数情况下，处理输出不必进行超级优化。

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'

#5楼

与jQuery.ajax（）成功函数一起使用。仅传递单个参数，并将字符串替换为该对象的属性作为{propertyName}：

String.prototype.format = function () {var formatted = this;for (var prop in arguments[0]) {var regexp = new RegExp('\\{' + prop + '\\}', 'gi');formatted = formatted.replace(regexp, arguments[0][prop]);}return formatted;
};

例：

var userInfo = ("Email: {Email} - Phone: {Phone}").format({ Email: "someone@somewhere.com", Phone: "123-123-1234" });

#6楼

我为JavaScript使用了一个名为String.format的小型库，该库支持大多数格式字符串功能（包括数字和日期格式），并使用.NET语法。该脚本本身小于4 kB，因此不会产生太多开销。

#7楼

有了sprintf.js，就可以制作出漂亮的小格式

String.prototype.format = function(){var _args = arguments Array.prototype.unshift.apply(_args,[this])return sprintf.apply(undefined,_args)
}
// this gives you:
"{%1$s}{%2$s}".format("1", "0")
// {1}{0}

#8楼

在zippoxer的答案中，我使用以下功能：

String.prototype.format = function () {var a = this, b;for (b in arguments) {a = a.replace(/%[a-z]/, arguments[b]);}return a; // Make chainable
};var s = 'Hello %s The magic number is %d.';
s.format('world!', 12); // Hello World! The magic number is 12.

我也有一个非原型版本，该版本更常用于类似Java的语法：

function format() {var a, b, c;a = arguments[0];b = [];for(c = 1; c < arguments.length; c++){b.push(arguments[c]);}for (c in b) {a = a.replace(/%[a-z]/, b[c]);}return a;
}
format('%d ducks, 55 %s', 12, 'cats'); // 12 ducks, 55 cats

ES 2015更新

ES 2015中所有超酷的新功能都使此操作变得更加容易：

function format(fmt, ...args){return fmt.split("%%").reduce((aggregate, chunk, i) =>aggregate + chunk + (args[i] || ""), "");
}format("Hello %%! I ate %% apples today.", "World", 44);
// "Hello World, I ate 44 apples today."

我认为，由于这与较旧的字母一样，实际上并没有解析字母，因此最好只使用单个标记%% 。这具有明显的好处，并且不会很难使用单个% 。但是，如果由于某种原因需要%% ，则需要将其替换为自身：

format("I love percentage signs! %%", "%%");
// "I love percentage signs! %%"

#9楼

这很有趣，因为Stack Overflow实际上对String原型拥有自己的格式化功能，称为formatUnicorn 。试试吧！进入控制台并输入如下内容：

"Hello, {name}, are you feeling {adjective}?".formatUnicorn({name:"Gabriel", adjective: "OK"});

您得到以下输出：

Hello, Gabriel, are you feeling OK?

您可以使用对象，数组和字符串作为参数！我得到了它的代码，并对其进行了重新处理以生成String.prototype.format的新版本：

String.prototype.formatUnicorn = String.prototype.formatUnicorn ||
function () {"use strict";var str = this.toString();if (arguments.length) {var t = typeof arguments[0];var key;var args = ("string" === t || "number" === t) ?Array.prototype.slice.call(arguments): arguments[0];for (key in args) {str = str.replace(new RegExp("\\{" + key + "\\}", "gi"), args[key]);}}return str;
};

请注意聪明的Array.prototype.slice.call(arguments)调用-这意味着，如果您抛出的参数是字符串或数字，而不是单个JSON样式的对象，则几乎完全可以得到C＃的String.Format行为。

"a{0}bcd{1}ef".formatUnicorn("foo", "bar"); // yields "aFOObcdBARef"

这是因为Array的slice将把arguments所有内容强制放入Array ，无论它是否是原始的，并且key将是每个数组元素的索引（0，1，2 ...）强制转换为字符串（例如， “ 0”，因此第一个正则表达式模式为"\\\\{0\\\\}" 。

整齐。

#10楼

我用这个：

String.prototype.format = function() {var newStr = this, i = 0;while (/%s/.test(newStr))newStr = newStr.replace("%s", arguments[i++])return newStr;
}

然后我称之为：

"<h1>%s</h1><p>%s</p>".format("Header", "Just a test!");

#11楼

对于Node.js用户，有util.format具有类似于printf的功能：

util.format("%s world", "Hello")

#12楼

我有一个非常接近Peter的解决方案，但是它涉及数字和对象的情况。

if (!String.prototype.format) {String.prototype.format = function() {var args;args = arguments;if (args.length === 1 && args[0] !== null && typeof args[0] === 'object') {args = args[0];}return this.replace(/{([^}]*)}/g, function(match, key) {return (typeof args[key] !== "undefined" ? args[key] : match);});};
}

也许处理所有深层问题可能会更好，但是对于我的需求而言，这很好。

"This is an example from {name}".format({name:"Blaine"});
"This is an example from {0}".format("Blaine");

PS：如果您在AngularJS之类的模板框架中使用翻译，则此功能非常酷：

<h1> {{('hello-message'|translate).format(user)}} <h1>
<h1> {{('hello-by-name'|translate).format( user ? user.name : 'You' )}} <h1>

en.json就像

{"hello-message": "Hello {name}, welcome.","hello-by-name": "Hello {0}, welcome."
}

#13楼

万一有人需要一个防止污染全局范围的函数，下面的函数也可以这样做：

  function _format (str, arr) {return str.replace(/{(\d+)}/g, function (match, number) {return typeof arr[number] != 'undefined' ? arr[number] : match;});};

#14楼

对于那些喜欢Node.JS及其util.format功能的人，我只是将其提取到其原始JavaScript形式中（只有util.format使用的功能）：

exports = {};function isString(arg) {return typeof arg === 'string';
}
function isNull(arg) {return arg === null;
}
function isObject(arg) {return typeof arg === 'object' && arg !== null;
}
function isBoolean(arg) {return typeof arg === 'boolean';
}
function isUndefined(arg) {return arg === void 0;
}
function stylizeNoColor(str, styleType) {return str;
}
function stylizeWithColor(str, styleType) {var style = inspect.styles[styleType];if (style) {return '\u001b[' + inspect.colors[style][0] + 'm' + str +'\u001b[' + inspect.colors[style][3] + 'm';} else {return str;}
}
function isFunction(arg) {return typeof arg === 'function';
}
function isNumber(arg) {return typeof arg === 'number';
}
function isSymbol(arg) {return typeof arg === 'symbol';
}
function formatPrimitive(ctx, value) {if (isUndefined(value))return ctx.stylize('undefined', 'undefined');if (isString(value)) {var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + '\'';return ctx.stylize(simple, 'string');}if (isNumber(value)) {// Format -0 as '-0'. Strict equality won't distinguish 0 from -0,// so instead we use the fact that 1 / -0 < 0 whereas 1 / 0 > 0 .if (value === 0 && 1 / value < 0)return ctx.stylize('-0', 'number');return ctx.stylize('' + value, 'number');}if (isBoolean(value))return ctx.stylize('' + value, 'boolean');// For some reason typeof null is "object", so special case here.if (isNull(value))return ctx.stylize('null', 'null');// es6 symbol primitiveif (isSymbol(value))return ctx.stylize(value.toString(), 'symbol');
}
function arrayToHash(array) {var hash = {};array.forEach(function (val, idx) {hash[val] = true;});return hash;
}
function objectToString(o) {return Object.prototype.toString.call(o);
}
function isDate(d) {return isObject(d) && objectToString(d) === '[object Date]';
}
function isError(e) {return isObject(e) &&(objectToString(e) === '[object Error]' || e instanceof Error);
}
function isRegExp(re) {return isObject(re) && objectToString(re) === '[object RegExp]';
}
function formatError(value) {return '[' + Error.prototype.toString.call(value) + ']';
}
function formatPrimitiveNoColor(ctx, value) {var stylize = ctx.stylize;ctx.stylize = stylizeNoColor;var str = formatPrimitive(ctx, value);ctx.stylize = stylize;return str;
}
function isArray(ar) {return Array.isArray(ar);
}
function hasOwnProperty(obj, prop) {return Object.prototype.hasOwnProperty.call(obj, prop);
}
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {var name, str, desc;desc = Object.getOwnPropertyDescriptor(value, key) || {value: value[key]};if (desc.get) {if (desc.set) {str = ctx.stylize('[Getter/Setter]', 'special');} else {str = ctx.stylize('[Getter]', 'special');}} else {if (desc.set) {str = ctx.stylize('[Setter]', 'special');}}if (!hasOwnProperty(visibleKeys, key)) {name = '[' + key + ']';}if (!str) {if (ctx.seen.indexOf(desc.value) < 0) {if (isNull(recurseTimes)) {str = formatValue(ctx, desc.value, null);} else {str = formatValue(ctx, desc.value, recurseTimes - 1);}if (str.indexOf('\n') > -1) {if (array) {str = str.split('\n').map(function (line) {return '  ' + line;}).join('\n').substr(2);} else {str = '\n' + str.split('\n').map(function (line) {return '   ' + line;}).join('\n');}}} else {str = ctx.stylize('[Circular]', 'special');}}if (isUndefined(name)) {if (array && key.match(/^\d+$/)) {return str;}name = JSON.stringify('' + key);if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {name = name.substr(1, name.length - 2);name = ctx.stylize(name, 'name');} else {name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'").replace(/\\\\/g, '\\');name = ctx.stylize(name, 'string');}}return name + ': ' + str;
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {var output = [];for (var i = 0, l = value.length; i < l; ++i) {if (hasOwnProperty(value, String(i))) {output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,String(i), true));} else {output.push('');}}keys.forEach(function (key) {if (!key.match(/^\d+$/)) {output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,key, true));}});return output;
}
function reduceToSingleString(output, base, braces) {var length = output.reduce(function (prev, cur) {return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;}, 0);if (length > 60) {return braces[0] +(base === '' ? '' : base + '\n ') +' ' +output.join(',\n  ') +' ' +braces[1];}return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}
function formatValue(ctx, value, recurseTimes) {// Provide a hook for user-specified inspect functions.// Check that value is an object with an inspect function on itif (ctx.customInspect &&value &&isFunction(value.inspect) &&// Filter out the util module, it's inspect function is specialvalue.inspect !== exports.inspect &&// Also filter out any prototype objects using the circular check.!(value.constructor && value.constructor.prototype === value)) {var ret = value.inspect(recurseTimes, ctx);if (!isString(ret)) {ret = formatValue(ctx, ret, recurseTimes);}return ret;}// Primitive types cannot have propertiesvar primitive = formatPrimitive(ctx, value);if (primitive) {return primitive;}// Look up the keys of the object.var keys = Object.keys(value);var visibleKeys = arrayToHash(keys);if (ctx.showHidden) {keys = Object.getOwnPropertyNames(value);}// This could be a boxed primitive (new String(), etc.), check valueOf()// NOTE: Avoid calling `valueOf` on `Date` instance because it will return// a number which, when object has some additional user-stored `keys`,// will be printed out.var formatted;var raw = value;try {// the .valueOf() call can fail for a multitude of reasonsif (!isDate(value))raw = value.valueOf();} catch (e) {// ignore...}if (isString(raw)) {// for boxed Strings, we have to remove the 0-n indexed entries,// since they just noisey up the output and are redundantkeys = keys.filter(function (key) {return !(key >= 0 && key < raw.length);});}// Some type of object without properties can be shortcutted.if (keys.length === 0) {if (isFunction(value)) {var name = value.name ? ': ' + value.name : '';return ctx.stylize('[Function' + name + ']', 'special');}if (isRegExp(value)) {return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');}if (isDate(value)) {return ctx.stylize(Date.prototype.toString.call(value), 'date');}if (isError(value)) {return formatError(value);}// now check the `raw` value to handle boxed primitivesif (isString(raw)) {formatted = formatPrimitiveNoColor(ctx, raw);return ctx.stylize('[String: ' + formatted + ']', 'string');}if (isNumber(raw)) {formatted = formatPrimitiveNoColor(ctx, raw);return ctx.stylize('[Number: ' + formatted + ']', 'number');}if (isBoolean(raw)) {formatted = formatPrimitiveNoColor(ctx, raw);return ctx.stylize('[Boolean: ' + formatted + ']', 'boolean');}}var base = '', array = false, braces = ['{', '}'];// Make Array say that they are Arrayif (isArray(value)) {array = true;braces = ['[', ']'];}// Make functions say that they are functionsif (isFunction(value)) {var n = value.name ? ': ' + value.name : '';base = ' [Function' + n + ']';}// Make RegExps say that they are RegExpsif (isRegExp(value)) {base = ' ' + RegExp.prototype.toString.call(value);}// Make dates with properties first say the dateif (isDate(value)) {base = ' ' + Date.prototype.toUTCString.call(value);}// Make error with message first say the errorif (isError(value)) {base = ' ' + formatError(value);}// Make boxed primitive Strings look like suchif (isString(raw)) {formatted = formatPrimitiveNoColor(ctx, raw);base = ' ' + '[String: ' + formatted + ']';}// Make boxed primitive Numbers look like suchif (isNumber(raw)) {formatted = formatPrimitiveNoColor(ctx, raw);base = ' ' + '[Number: ' + formatted + ']';}// Make boxed primitive Booleans look like suchif (isBoolean(raw)) {formatted = formatPrimitiveNoColor(ctx, raw);base = ' ' + '[Boolean: ' + formatted + ']';}if (keys.length === 0 && (!array || value.length === 0)) {return braces[0] + base + braces[1];}if (recurseTimes < 0) {if (isRegExp(value)) {return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');} else {return ctx.stylize('[Object]', 'special');}}ctx.seen.push(value);var output;if (array) {output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);} else {output = keys.map(function (key) {return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);});}ctx.seen.pop();return reduceToSingleString(output, base, braces);
}
function inspect(obj, opts) {// default optionsvar ctx = {seen: [],stylize: stylizeNoColor};// legacy...if (arguments.length >= 3) ctx.depth = arguments[2];if (arguments.length >= 4) ctx.colors = arguments[3];if (isBoolean(opts)) {// legacy...ctx.showHidden = opts;} else if (opts) {// got an "options" objectexports._extend(ctx, opts);}// set default optionsif (isUndefined(ctx.showHidden)) ctx.showHidden = false;if (isUndefined(ctx.depth)) ctx.depth = 2;if (isUndefined(ctx.colors)) ctx.colors = false;if (isUndefined(ctx.customInspect)) ctx.customInspect = true;if (ctx.colors) ctx.stylize = stylizeWithColor;return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
inspect.colors = {'bold': [1, 22],'italic': [3, 23],'underline': [4, 24],'inverse': [7, 27],'white': [37, 39],'grey': [90, 39],'black': [30, 39],'blue': [34, 39],'cyan': [36, 39],'green': [32, 39],'magenta': [35, 39],'red': [31, 39],'yellow': [33, 39]
};// Don't use 'blue' not visible on cmd.exe
inspect.styles = {'special': 'cyan','number': 'yellow','boolean': 'yellow','undefined': 'grey','null': 'bold','string': 'green','symbol': 'green','date': 'magenta',// "name": intentionally not styling'regexp': 'red'
};var formatRegExp = /%[sdj%]/g;
exports.format = function (f) {if (!isString(f)) {var objects = [];for (var j = 0; j < arguments.length; j++) {objects.push(inspect(arguments[j]));}return objects.join(' ');}var i = 1;var args = arguments;var len = args.length;var str = String(f).replace(formatRegExp, function (x) {if (x === '%%') return '%';if (i >= len) return x;switch (x) {case '%s':return String(args[i++]);case '%d':return Number(args[i++]);case '%j':try {return JSON.stringify(args[i++]);} catch (_) {return '[Circular]';}default:return x;}});for (var x = args[i]; i < len; x = args[++i]) {if (isNull(x) || !isObject(x)) {str += ' ' + x;} else {str += ' ' + inspect(x);}}return str;
};

摘自： https : //github.com/joyent/node/blob/master/lib/util.js

#15楼

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

ES6（EcmaScript2015）

 String.prototype.format = function() { return [...arguments].reduce((p,c) => p.replace(/%s/,c), this); }; console.log('Is that a %s or a %s?... No, it\\'s %s!'.format('plane', 'bird', '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= function(p,c){return p.replace(/%s/,c)}; console.log( ["a", "b", "c"].reduce(_r, "[%s], [%s] and [%s]") + '\\n', [1, 2, 3].reduce(_r, "%s+%s=%s") + '\\n', ["cool", 1337, "stuff"].reduce(_r, "%s %s %s") );

#16楼

从ES6开始，您可以使用模板字符串 ：

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

请注意，模板字符串用反引号 `代替，而不是（单引号）。

了解更多信息：

https://developers.google.com/web/updates/2015/01/ES6-Template-Strings

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/template_strings

注意：检查mozilla站点以找到支持的浏览器列表。

#17楼

对于基本格式：

var template = jQuery.validator.format("{0} is not a valid value");
var result = template("abc");

#18楼

我使用以下简单功能：

String.prototype.format = function() {var formatted = this;for( var arg in arguments ) {formatted = formatted.replace("{" + arg + "}", arguments[arg]);}return formatted;
};

这与string.format非常相似：

"{0} is dead, but {1} is alive!".format("ASP", "ASP.NET")

#19楼

+1 Zippo，除了函数体必须如下所示，否则它将在每次迭代后附加当前字符串：

String.prototype.format = function() {var formatted = this;for (var arg in arguments) {formatted = formatted.replace("{" + arg + "}", arguments[arg]);}return formatted;
};

#20楼

JavaScript程序员可以在https://github.com/ildar-shaimordanov/jsxt/blob/master/js/String.js上使用String.prototype.sprintf。下面是示例：

var d = new Date();
var dateStr = '%02d:%02d:%02d'.sprintf(d.getHours(), d.getMinutes(), d.getSeconds());

#21楼

jsxt，Zippo

此选项更合适。

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

使用此选项，我可以替换以下字符串：

'The {0} is dead. Don\'t code {0}. Code {1} that is open source!'.format('ASP', 'PHP');

使用您的代码，第二个{0}将不会被替换。 ;）

#22楼

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

// 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} is dead, but {1} is alive! {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} is dead, but {1} is alive! {0} {2}', 'ASP', 'ASP.NET');

结果相同：

ASP已经死了，但是ASP.NET还活着！ ASP {2}

#23楼

这是sprintf在JavaScript中的最小实现：它仅执行“％s”和“％d”，但我留有扩展空间。它对OP没有用，但是其他偶然发现来自Google的线程的人可能会从中受益。

function sprintf() {var args = arguments,string = args[0],i = 1;return string.replace(/%((%)|s|d)/g, function (m) {// m is the matched format, e.g. %s, %dvar val = null;if (m[2]) {val = m[2];} else {val = args[i];// A switch statement so that the formatter can be extended. Default is %sswitch (m) {case '%d':val = parseFloat(val);if (isNaN(val)) {val = 0;}break;}i++;}return val;});
}

例：

alert(sprintf('Latitude: %s, Longitude: %s, Count: %d', 41.847, -87.661, 'two'));
// Expected output: Latitude: 41.847, Longitude: -87.661, Count: 0

与以往的答复类似的解决方案对比，这其中确实一气呵成所有替换，所以它不会取代先前所取代值的部分。

#24楼

我们可以为Typescript使用简单的轻量级String.Format字符串操作库。

String.Format（）：

var id = image.GetId()
String.Format("image_{0}.jpg", id)
output: "image_2db5da20-1c5d-4f1a-8fd4-b41e34c8c5b5.jpg";

说明符的字符串格式：

var value = String.Format("{0:L}", "APPLE"); //output "apple"value = String.Format("{0:U}", "apple"); // output "APPLE"value = String.Format("{0:d}", "2017-01-23 00:00"); //output "23.01.2017"value = String.Format("{0:s}", "21.03.2017 22:15:01") //output "2017-03-21T22:15:01"value = String.Format("{0:n}", 1000000);
//output "1.000.000"value = String.Format("{0:00}", 1);
//output "01"

对象的字符串格式，包括说明符：

var fruit = new Fruit();
fruit.type = "apple";
fruit.color = "RED";
fruit.shippingDate = new Date(2018, 1, 1);
fruit.amount = 10000;String.Format("the {type:U} is {color:L} shipped on {shippingDate:s} with an amount of {amount:n}", fruit);
// output: the APPLE is red shipped on 2018-01-01 with an amount of 10.000

#25楼

PHPJS项目已经为许多PHP函数编写了JavaScript实现。由于PHP的sprintf()函数与C的printf()基本相同，因此他们的JavaScript实现应该可以满足您的需求。

#26楼

从ES6开始，您可以使用模板字符串：

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

有关详细信息，请参见下面的Kim 答案。

除此以外：

尝试sprintf（）for JavaScript 。

如果您真的想自己做一个简单的格式化方法，请不要先后进行替换，而要同时进行。

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

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

通常，您希望输出为{1}{0}但实际输出为{1}{1} 。因此，应同时进行替换，而不是像在噬菌体的建议中那样。

#27楼

您可以在http://www.webtoolkit.info/javascript-sprintf.html上找到JavaScript的“ sprintf”。

#28楼

我将添加自询问以来发现的发现：

number_format（用于千位分隔符/货币格式）
sprintf（与上述作者相同）

可悲的是，似乎sprintf无法处理.NET的字符串格式之类的千位分隔符格式。

#29楼

如果要处理千位分隔符，则应真正使用JavaScript Number类中的toLocaleString（），因为它将格式化用户区域的字符串。

JavaScript Date类可以格式化本地化的日期和时间。

#30楼

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数字格式快速教程

MoFi的toFixed（）参考页（带有toPrecision（），toExponential（），toLocaleString（）等的链接）

#31楼

十分优雅：

String.prototype.format = function (){var args = arguments;return this.replace(/\{\{|\}\}|\{(\d+)\}/g, function (curlyBrack, index) {return ((curlyBrack == "{{") ? "{" : ((curlyBrack == "}}") ? "}" : args[index]));});
};// Usage:
"{0}{1}".format("{1}", "{0}")

归功于 ~~（链接断开）~~ https://gist.github.com/0i0/1519811

JavaScript等同于printf / String.Format相关推荐

String.Format in javascript
有些时候,我们确实需要在JavaScript中进行字符串替换,类似于C#中的String.Format()方法一样,只不过这种格式化替换只局限于对由'{0}','{1}','{2}'...所组成的&q ...
String.format System.out.printf的用法-简单
其实我的需求很简单,就是向字符串里面传递几个变量.解决方法是使用静态方法String.format ,网上搜的解释看的人头晕,一堆参数比如这个(http://blueram.javaeye.com/b ...
编写javascript、Jquery的String.format();
在javascript.Jquery里面好像是没有String.format();这个函数的,所以我们在拼接字符串的时候就特别的辛苦,生怕又打错,而且又乱,所以就自己去写一个函数来代替. String ...
Java字符串格式化—String.format()的使用以及Printf的使用
Java字符串格式化-String.format()的使用以及Printf的使用 tring类的format()方法用于创建格式化的字符串以及连接多个字符串对象.记得C语言的printf()方法,两者 ...
JAVA String.format 方法使用介绍
在JDK1.5中,String类增加了静态方法format(String format, Objects... args),format(Local l ,String format, Objects ...
JAVA String format 方法使用介绍
分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow 也欢迎大家转载本篇文章.分享知识,造福人民,实现我们中华民族伟大复兴! 在JDK ...
java string... 参数_Java String.Format() 方法及参数说明
JDK1.5中,String类新增了一个很有用的静态方法String.format(): format(Locale l, String format, Object... args) 使用指定的语言 ...
java 补齐字符串_使用String.format()格式化字符串，java自动补全自增长字符串
JDK1.5中,String类新增了一个很有用的静态方法String.format(): format(Locale l, String format, Object... args) 使用指定的语言 ...
java 填充字符串_Java字符串右补齐——String.format
Java字符串右补齐方法: System.out.println(String.format("%-4s", "ab")); //"%-4s" ...

JavaScript等同于printf / String.Format

#1楼

#2楼

#3楼

#4楼

#5楼

#6楼

#7楼

#8楼