Javascript 与jQuery中的String.format等效

我正在尝试将一些JavaScript代码从MicrosoftAjax迁移到JQuery。我在MicrosoftAjax中使用了流行的.net方法的JavaScript等价物，例如String.format（）、String.startsWith（）等。jQuery中是否有与它们等价的东西？

供您参考，因此您可以选择它，并将要继续使用的部分包含到单独的JS文件中。或者，您可以将它们移植到jQuery

这是格式化函数

String.format = function() {
  var s = arguments[0];
  for (var i = 0; i < arguments.length - 1; i++) {       
    var reg = new RegExp("\\{" + i + "\\}", "gm");             
    s = s.replace(reg, arguments[i + 1]);
  }

  return s;
}

有一个（某种程度上）官方选项：

附带jQuery验证插件1.6（至少）。
与.NET中的

String.Format

非常相似

编辑修复了断开的链接。

这是Josh发布的函数的一个更快/更简单的（原型）变体：

String.prototype.format = String.prototype.f = function() {
    var s = this,
        i = arguments.length;

    while (i--) {
        s = s.replace(new RegExp('\\{' + i + '\\}', 'gm'), arguments[i]);
    }
    return s;
};

用法：

'Added {0} by {1} to your collection'.f(title, artist)
'Your balance is {0} USD'.f(77.7) 

var one = strFormat('"{0}" is not {1}', 'aalert', 'defined');
var two = strFormat('{0} {0} {1} {2}', 3.14, 'a{2}bc', 'foo');

我经常使用它，因此我将其别名为

f

，但您也可以使用更详细的

格式。e、 g.
“你好{0}！”。格式（名称）
这是我的：

String.format = function(tokenised){
        var args = arguments;
        return tokenised.replace(/{[0-9]}/g, function(matched){
            matched = matched.replace(/[{}]/g, "");
            return args[parseInt(matched)+1];             
        });
    }

不是防弹的，但如果你明智地使用它，它会起作用
 我无法得到乔什·斯托多拉的工作答案，但以下几点对我很有用。请注意
原型的规格。（在IE、FF、Chrome和Safari上测试）：

String.prototype.format=function（）{
var s=此；
if（t.length-1！=参数长度）{
警报（“String.format（）：参数数量不正确”）；
}
对于（var i=0；i

s
实际上应该是该
的克隆，这样就不会是一种破坏性的方法，但它不是真正必要的。
上述许多函数（除了Julian Jelfs）包含以下错误：

js> '{0} {0} {1} {2}'.format(3.14, 'a{2}bc', 'foo');
3.14 3.14 afoobc foo

或者，对于从参数列表末尾向后计数的变量：

js> '{0} {0} {1} {2}'.format(3.14, 'a{0}bc', 'foo');
3.14 3.14 a3.14bc foo

这是一个正确的函数。这是Julian Jelfs代码的原型变体，我把它做得更紧了一点：

String.prototype.format = function () {
  var args = arguments;
  return this.replace(/\{(\d+)\}/g, function (m, n) { return args[n]; });
};

这里有一个更高级的版本，它允许你通过加倍大括号来摆脱大括号：

String.prototype.format = function () {
  var args = arguments;
  return this.replace(/\{\{|\}\}|\{(\d+)\}/g, function (m, n) {
    if (m == "{{") { return "{"; }
    if (m == "}}") { return "}"; }
    return args[n];
  });
};

这是正确的：

js> '{0} {{0}} {{{0}}} {1} {2}'.format(3.14, 'a{2}bc', 'foo');
3.14 {0} {3.14} a{2}bc foo

这是Blair Mitchelmore的另一个很好的实现，它有一系列很好的额外功能：
这是我的版本，它能够避开“{”，并清理那些未分配的占位符

function getStringFormatPlaceHolderRegEx(placeHolderIndex) {
    return new RegExp('({)?\\{' + placeHolderIndex + '\\}(?!})', 'gm')
}

function cleanStringFormatResult(txt) {
    if (txt == null) return "";

    return txt.replace(getStringFormatPlaceHolderRegEx("\\d+"), "");
}

String.prototype.format = function () {
    var txt = this.toString();
    for (var i = 0; i < arguments.length; i++) {
        var exp = getStringFormatPlaceHolderRegEx(i);
        txt = txt.replace(exp, (arguments[i] == null ? "" : arguments[i]));
    }
    return cleanStringFormatResult(txt);
}
String.format = function () {
    var s = arguments[0];
    if (s == null) return "";

    for (var i = 0; i < arguments.length - 1; i++) {
        var reg = getStringFormatPlaceHolderRegEx(i);
        s = s.replace(reg, (arguments[i + 1] == null ? "" : arguments[i + 1]));
    }
    return cleanStringFormatResult(s);
}

函数getStringFormatPlaceHolderRegEx（占位符索引）{
返回新的正则表达式（'（{）\\{'+placeHolderIndex+'\\}（？！}）'gm'）
}
函数cleanStringFormatResult（txt）{
如果（txt==null）返回“”；
返回txt.replace（getStringFormatPlaceHolderRegEx（“\\d+”）”）；
}
String.prototype.format=函数（）{
var txt=this.toString（）；
for（var i=0；i

创建了一个格式函数，该函数将集合或数组作为参数

用法：

format("i can speak {language} since i was {age}",{language:'javascript',age:10});

format("i can speak {0} since i was {1}",'javascript',10});

代码：

---

虽然不完全是Q所要求的，但我构建了一个类似的占位符，但使用命名占位符而不是编号占位符。我个人更喜欢命名参数，只需将对象作为参数发送给它（更详细，但更易于维护）

下面是一个示例用法

alert("Hello {name}".format({ name: 'World' }));

---

到目前为止，没有一个答案对使用enclosure初始化一次并存储正则表达式以供后续使用没有明显的优化

// DBJ.ORG string.format function
// usage:   "{0} means 'zero'".format("nula") 
// returns: "nula means 'zero'"
// place holders must be in a range 0-99.
// if no argument given for the placeholder, 
// no replacement will be done, so
// "oops {99}".format("!")
// returns the input
// same placeholders will be all replaced 
// with the same argument :
// "oops {0}{0}".format("!","?")
// returns "oops !!"
//
if ("function" != typeof "".format) 
// add format() if one does not exist already
  String.prototype.format = (function() {
    var rx1 = /\{(\d|\d\d)\}/g, rx2 = /\d+/ ;
    return function() {
        var args = arguments;
        return this.replace(rx1, function($0) {
            var idx = 1 * $0.match(rx2)[0];
            return args[idx] !== undefined ? args[idx] : (args[idx] === "" ? "" : $0);
        });
    }
}());

alert("{0},{0},{{0}}!".format("{X}"));

---

此外，如果已经存在format（）实现，则所有示例都不考虑format（）实现。

如果使用验证插件，则可以使用：

jQuery.validator.format（“{0}{1}”，“酷”，“格式化”）=“酷格式化”

…

var str=”http://xyz.html?ID={0}&TId={1}&STId={2}&RId={3}，14480,3,38”；
write（FormatString（str））；
函数格式化字符串（str）{
var args=str.split（'，'）；
对于（变量i=0；i

以下答案可能是最有效的，但有一点需要注意：只适用于参数的1对1映射。这是连接字符串的最快方法（类似于stringbuilder：字符串数组，连接）。这是我自己的代码。不过可能需要更好的分隔符

String.format = function(str, args)
{
    var t = str.split('~');
    var sb = [t[0]];
    for(var i = 0; i < args.length; i++){
        sb.push(args[i]);
        sb.push(t[i+1]);
    }
    return sb.join("");
}

String.format=函数（str，args）
{
var t=str.split（'~'）；
var sb=[t[0]]；
对于（变量i=0；i

像这样使用它：

alert(String.format("<a href='~'>~</a>", ["one", "two"]));

alert（String.format（“，[“一”，“二]））；

扩展adamJLev的伟大答案，以下是TypeScript版本：

// Extending String prototype
interface String {
    format(...params: any[]): string;
}

// Variable number of params, mimicking C# params keyword
// params type is set to any so consumer can pass number
// or string, might be a better way to constraint types to
// string and number only using generic?
String.prototype.format = function (...params: any[]) {
    var s = this,
        i = params.length;

    while (i--) {
        s = s.replace(new RegExp('\\{' + i + '\\}', 'gm'), params[i]);
    }

    return s;
};

---

这违反了DRY原则，但这是一个简洁的解决方案：

var button = '<a href="{link}" class="btn">{text}</a>';
button = button.replace('{text}','Authorize on GitHub').replace('{link}', authorizeUrl);

var按钮=“”；
button=button.replace（{text}，'Authorize on GitHub'）。replace（{link}'，authorizeUrl）；

我有一个plunker，可以将其添加到字符串原型中： 它不仅和其他一些例子一样短，而且更加灵活

用法与c#版本类似：

此外，还添加了对使用名称和对象属性的支持

var str1 = "Meet you on {day}, ask for {Person}";
var result1 = str1.format({day: "Thursday", person: "Frank"}); 
//result: Meet you on Thursday, ask for Frank

---

您还可以使用这样的替换来关闭数组

var url = '/getElement/_/_/_'.replace(/_/g, (_ => this.ar[this.i++]).bind({ar: ["invoice", "id", 1337],i: 0}))
> '/getElement/invoice/id/1337

或者您可以尝试

bind

'/getElement/_/_/_'.replace(/_/g, (function(_) {return this.ar[this.i++];}).bind({ar: ["invoice", "id", 1337],i: 0}))

现在您可以使用：

var w=“这个词”；
var num1=2；
var num2=3；
var long\u multiline\u string=`这非常长
多行模板字符串。将某些内容放在此处：
${w}
我甚至可以使用expresion插值：
二加三=${num1+num2}
或者使用标记的模板文本
var button = '<a href="{link}" class="btn">{text}</a>';
button = button.replace('{text}','Authorize on GitHub').replace('{link}', authorizeUrl);

var str2 = "Meet you on {0}, ask for {1}";
var result2 = str2.format("Friday", "Suzy"); 
//result: Meet you on Friday, ask for Suzy
//NB: also accepts an array

var str1 = "Meet you on {day}, ask for {Person}";
var result1 = str1.format({day: "Thursday", person: "Frank"}); 
//result: Meet you on Thursday, ask for Frank

var url = '/getElement/_/_/_'.replace(/_/g, (_ => this.ar[this.i++]).bind({ar: ["invoice", "id", 1337],i: 0}))
> '/getElement/invoice/id/1337

'/getElement/_/_/_'.replace(/_/g, (function(_) {return this.ar[this.i++];}).bind({ar: ["invoice", "id", 1337],i: 0}))

var name = "Waleed";
var message = `Hello ${name}!`;

var one = strFormat('"{0}" is not {1}', 'aalert', 'defined');
var two = strFormat('{0} {0} {1} {2}', 3.14, 'a{2}bc', 'foo');

function strFormat() {
    var args = Array.prototype.slice.call(arguments, 1);
    return arguments[0].replace(/\{(\d+)\}/g, function (match, index) {
        return args[index];
    });
}

"aalert" is not defined
3.14 3.14 a{2}bc foo