JavaScriptでString.Formatを使用していますか？
これは私を夢中にさせています。これとまったく同じ質問をしたと思いますが、もう見つかりません（Stack Overflow検索、Google検索を使用し、投稿を手動で検索し、コードを検索しました）。
私はあなたが何かをすることができるC＃String.Formatのようなものが欲しかった
string format = String.Format("Hi {0}",name);
もちろんJavaScriptのためだけに、ある人が簡単な答えをくれました。jQueryプラグインなどではありませんでしたが、JSONのようなものを作成したと思います。
私は私の人生のためにこの投稿を見つけることができません。
私は自分のコードにこれを持っていますが、それを使用するものを見つけることができないようで、私はそれを数回使用したと確信しています：
String.prototype.format = function(o)
{
return this.replace(/{([^{}]*)}/g,
function(a, b)
{
var r = o[b];
return typeof r === 'string' ? r : a;
}
);
};
MsAjax string のコードを適合させます。
すべての_validateParamsコードを使用すれば、JavaScriptで本格的な.NET文字列クラスを作成できます。
さて、msajax文字列クラスを解放し、msajaxの依存関係をすべて削除しました。 .NET文字列クラスと同様に、トリム関数、endsWith/startsWithなどを含めて、すばらしい動作をします。
追伸-すべてのVisual Studio JavaScript IntelliSenseヘルパーとXmlDocsをそのまま残しました。 Visual Studioを使用しない場合は無害ですが、必要に応じて削除できます。
<script src="script/string.js" type="text/javascript"></script>
<script type="text/javascript">
var a = String.format("Hello {0}!", "world");
alert(a);
</script>
String.js
// String.js - liberated from MicrosoftAjax.js on 03/28/10 by Sky Sanders
// permalink: http://stackoverflow.com/a/2534834/2343
/*
Copyright (c) 2009, CodePlex Foundation
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions
and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions
and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of CodePlex Foundation nor the names of its contributors may be used to endorse or
promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</textarea>
*/
(function(window) {
$type = String;
$type.__typeName = 'String';
$type.__class = true;
$prototype = $type.prototype;
$prototype.endsWith = function String$endsWith(suffix) {
/// <summary>Determines whether the end of this instance matches the specified string.</summary>
/// <param name="suffix" type="String">A string to compare to.</param>
/// <returns type="Boolean">true if suffix matches the end of this instance; otherwise, false.</returns>
return (this.substr(this.length - suffix.length) === suffix);
}
$prototype.startsWith = function String$startsWith(prefix) {
/// <summary >Determines whether the beginning of this instance matches the specified string.</summary>
/// <param name="prefix" type="String">The String to compare.</param>
/// <returns type="Boolean">true if prefix matches the beginning of this string; otherwise, false.</returns>
return (this.substr(0, prefix.length) === prefix);
}
$prototype.trim = function String$trim() {
/// <summary >Removes all leading and trailing white-space characters from the current String object.</summary>
/// <returns type="String">The string that remains after all white-space characters are removed from the start and end of the current String object.</returns>
return this.replace(/^\s+|\s+$/g, '');
}
$prototype.trimEnd = function String$trimEnd() {
/// <summary >Removes all trailing white spaces from the current String object.</summary>
/// <returns type="String">The string that remains after all white-space characters are removed from the end of the current String object.</returns>
return this.replace(/\s+$/, '');
}
$prototype.trimStart = function String$trimStart() {
/// <summary >Removes all leading white spaces from the current String object.</summary>
/// <returns type="String">The string that remains after all white-space characters are removed from the start of the current String object.</returns>
return this.replace(/^\s+/, '');
}
$type.format = function String$format(format, args) {
/// <summary>Replaces the format items in a specified String with the text equivalents of the values of corresponding object instances. The invariant culture will be used to format dates and numbers.</summary>
/// <param name="format" type="String">A format string.</param>
/// <param name="args" parameterArray="true" mayBeNull="true">The objects to format.</param>
/// <returns type="String">A copy of format in which the format items have been replaced by the string equivalent of the corresponding instances of object arguments.</returns>
return String._toFormattedString(false, arguments);
}
$type._toFormattedString = function String$_toFormattedString(useLocale, args) {
var result = '';
var format = args[0];
for (var i = 0; ; ) {
// Find the next opening or closing brace
var open = format.indexOf('{', i);
var close = format.indexOf('}', i);
if ((open < 0) && (close < 0)) {
// Not found: copy the end of the string and break
result += format.slice(i);
break;
}
if ((close > 0) && ((close < open) || (open < 0))) {
if (format.charAt(close + 1) !== '}') {
throw new Error('format stringFormatBraceMismatch');
}
result += format.slice(i, close + 1);
i = close + 2;
continue;
}
// Copy the string before the brace
result += format.slice(i, open);
i = open + 1;
// Check for double braces (which display as one and are not arguments)
if (format.charAt(i) === '{') {
result += '{';
i++;
continue;
}
if (close < 0) throw new Error('format stringFormatBraceMismatch');
// Find the closing brace
// Get the string between the braces, and split it around the ':' (if any)
var brace = format.substring(i, close);
var colonIndex = brace.indexOf(':');
var argNumber = parseInt((colonIndex < 0) ? brace : brace.substring(0, colonIndex), 10) + 1;
if (isNaN(argNumber)) throw new Error('format stringFormatInvalid');
var argFormat = (colonIndex < 0) ? '' : brace.substring(colonIndex + 1);
var arg = args[argNumber];
if (typeof (arg) === "undefined" || arg === null) {
arg = '';
}
// If it has a toFormattedString method, call it. Otherwise, call toString()
if (arg.toFormattedString) {
result += arg.toFormattedString(argFormat);
}
else if (useLocale && arg.localeFormat) {
result += arg.localeFormat(argFormat);
}
else if (arg.format) {
result += arg.format(argFormat);
}
else
result += arg.toString();
i = close + 1;
}
return result;
}
})(window);
これが私が使用するものです。この機能はユーティリティファイルで定義されています。
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;
}
そして、私はそれを次のように呼び出します：
var greeting = String.format("Hi, {0}", name);
これを見つけた場所は思い出せませんが、非常に役に立ちました。構文がC＃バージョンと同じであるため、気に入っています。
次のような一連の置換を実行できます。
function format(str)
{
for(i = 1; i < arguments.length; i++)
{
str = str.replace('{' + (i - 1) + '}', arguments[i]);
}
return str;
}
より良いアプローチは、関数パラメータで置換を使用することです：
function format(str, obj) {
return str.replace(/\{\s*([^}\s]+)\s*\}/g, function(m, p1, offset, string) {
return obj[p1]
})
}
この方法で、インデックスと名前付きパラメーターの両方を提供できます。
var arr = ['0000', '1111', '2222']
arr.a = 'aaaa'
str = format(" { 0 } , {1}, { 2}, {a}", arr)
// returns 0000 , 1111, 2222, aaaa
正規表現とキャプチャを使用した便利な文字列フォーマット関数は次のとおりです。
function format (fmtstr) {
var args = Array.prototype.slice.call(arguments, 1);
return fmtstr.replace(/\{(\d+)\}/g, function (match, index) {
return args[index];
});
}
文字列は、C＃String.Formatのようにフォーマットできます。
var str = format('{0}, {1}!', 'Hello', 'world');
console.log(str); // prints "Hello, world!"
形式は、順序が正しくない場合でも、正しい変数を正しい場所に配置します。
var str = format('{1}, {0}!', 'Hello', 'world');
console.log(str); // prints "world, Hello!"
お役に立てれば！
サードパーティ機能なし：
string format = "Hi {0}".replace('{0}', name)
複数のパラメーターの場合：
string format = "Hi {0} {1}".replace('{0}', name).replace('{1}', lastname)
.NET FrameworkのString.Formatメソッドには、 複数の署名 があります。私が好きなものは themost プロトタイプで params キーワードを使用しています。
public static string Format(
string format,
params Object[] args
)
このバージョンを使用すると、可変数の引数だけでなく、配列引数も渡すことができます。
私はジェレミーが提供する簡単なソリューションが好きなので、少し拡張したいと思います。
var StringHelpers = {
format: function(format, args) {
var i;
if (args instanceof Array) {
for (i = 0; i < args.length; i++) {
format = format.replace(new RegExp('\\{' + i + '\\}', 'gm'), args[i]);
}
return format;
}
for (i = 0; i < arguments.length - 1; i++) {
format = format.replace(new RegExp('\\{' + i + '\\}', 'gm'), arguments[i + 1]);
}
return format;
}
};
これで、次の方法でString.FormatのJavaScriptバージョンを使用できます。
StringHelpers.format("{0}{1}", "a", "b")
そして
StringHelpers.format("{0}{1}", ["a", "b"])
ECMAScript 6でテンプレートリテラルを使用します。
var customer = { name: "Foo" }
var card = { amount: 7, product: "Bar", unitprice: 42 }
var message = `Hello ${customer.name},
want to buy ${card.amount} ${card.product} for
a total of ${card.amount * card.unitprice} bucks?`
@roydukkeyの回答に基づいて、ランタイム用にもう少し最適化されています（正規表現をキャッシュします）。
(function () {
if (!String.prototype.format) {
var regexes = {};
String.prototype.format = function (parameters) {
for (var formatMessage = this, args = arguments, i = args.length; --i >= 0;)
formatMessage = formatMessage.replace(regexes[i] || (regexes[i] = RegExp("\\{" + (i) + "\\}", "gm")), args[i]);
return formatMessage;
};
if (!String.format) {
String.format = function (formatMessage, params) {
for (var args = arguments, i = args.length; --i;)
formatMessage = formatMessage.replace(regexes[i - 1] || (regexes[i - 1] = RegExp("\\{" + (i - 1) + "\\}", "gm")), args[i]);
return formatMessage;
};
}
}
})();
String.prototypeで動作するソリューションを次に示します。
String.prototype.format = function() {
var s = this;
for (var i = 0; i < arguments.length; i++) {
var reg = new RegExp("\\{" + i + "\\}", "gm");
s = s.replace(reg, arguments[i]);
}
return s;
}
この関数を作成して使用するだけです：
_function format(str, args) {
for (i = 0; i < args.length; i++)
str = str.replace("{" + i + "}", args[i]);
return str;
}
_strパラメーターを変更したくない場合は、forループの前に、それを新しいストリングに複製（複製）します（strの新しいコピーを作成します）、forループでコピーを設定し、最後にパラメーター自体の代わりにそれを返します。
C＃（Sharp）では、String.Clone()を呼び出すだけでコピーを簡単に作成できますが、JavaScriptでの方法はわかりませんが、Googleで検索したり、インターネットでネットサーフィンしたりする方法を学ぶことができます。
JavaScriptの文字列形式についてのアイデアをお伝えしました。
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}'.format('a','b');
// Result: 'a-b'
JavaのString.format()をJavaScriptに移植し始めたところです。それも役に立つかもしれません。
次のような基本的なものをサポートしています。
StringFormat.format("Hi %s, I like %s", ["Rob", "icecream"]);
結果として
Hi Rob, I like icecream.
しかし、次のようなより高度な数値書式と日付書式もあります。
StringFormat.format("Duke's Birthday: %1$tA %1$te %1$tB, %1$tY", [new Date("2014-12-16")]);
Duke's Birthday: Tuesday 16 December, 2014
例の詳細を参照してください。
こちらをご覧ください： https://github.com/RobAu/javascript.string.format
プロトタイプと機能の両方のオプションを許可するソリューションを次に示します。
// --------------------------------------------------------------------
// Add prototype for 'String.format' which is c# equivalent
//
// String.format("{0} i{2}a night{1}", "This", "mare", "s ");
// "{0} i{2}a night{1}".format("This", "mare", "s ");
// --------------------------------------------------------------------
if(!String.format)
String.format = function(){
for (var i = 0, args = arguments; i < args.length - 1; i++)
args[0] = args[0].replace("{" + i + "}", args[i + 1]);
return args[0];
};
if(!String.prototype.format && String.format)
String.prototype.format = function(){
var args = Array.prototype.slice.call(arguments).reverse();
args.Push(this);
return String.format.apply(this, args.reverse())
};
楽しい。
//Add "format" method to the string class
//supports: "Welcome {0}. You are the first person named {0}".format("David");
// and "First Name:{} Last name:{}".format("David","Wazy");
// and "Value:{} size:{0} shape:{1} weight:{}".format(value, size, shape, weight)
String.prototype.format = function () {
var content = this;
for (var i = 0; i < arguments.length; i++) {
var target = '{' + i + '}';
content=content.split(target).join(String(arguments[i]))
content = content.replace("{}", String(arguments[i]));
}
return content;
}
alert("I {} this is what {2} want and {} works for {2}!".format("hope","it","you"))
この機能を使用して、位置および「名前付き」の交換場所を使用して、組み合わせて一致させることができます。
Stringプロトタイプを変更しているという事実は別として、提供した関数には何も問題はありません。使用方法は次のとおりです。
"Hello {0},".format(["Bob"]);
スタンドアロンの機能として必要な場合は、これをわずかに変更できます。
function format(string, object) {
return string.replace(/{([^{}]*)}/g,
function(match, group_match)
{
var data = object[group_match];
return typeof data === 'string' ? data : match;
}
);
}
ヴィットーレの方法も優れています。彼の関数は、追加のフォーマットオプションが引数として渡されるたびに呼び出されますが、ユーザーはオブジェクトを期待しています。
これが実際にどのように見えるかは、John Resigの マイクロテンプレートエンジン です。
ここに私の 2セント があります：
function stringFormat(str) {
if (str !== undefined && str !== null) {
str = String(str);
if (str.trim() !== "") {
var args = arguments;
return str.replace(/(\{[^}]+\})/g, function(match) {
var n = +match.slice(1, -1);
if (n >= 0 && n < args.length - 1) {
var a = args[n + 1];
return (a !== undefined && a !== null) ? String(a) : "";
}
return match;
});
}
}
return "";
}
alert(stringFormat("{1}, {0}. You're looking {2} today.",
"Dave", "Hello", Math.random() > 0.5 ? "well" : "good"));
あなたの関数はすでにパラメータとしてJSONオブジェクトを取ります：
string format = "Hi {foo}".replace({
"foo": "bar",
"fizz": "buzz"
});
あなたが気づいた場合、コード：
var r = o[b];
パラメータ（o）を調べ、その中のキーと値のペアを使用して「置換」を解決します
String.prototype.format = function () {
var formatted = this;
for (var arg in arguments) {
formatted = formatted.split('{' + arg + '}').join(arguments[arg]);
}
return formatted;
};
使用法：
'Hello {0}!'.format('Word')->Hello World!
'He{0}{0}o World!'.format('l') _ ->Hello World!
'{0} {1}!'.format('Hello', 'Word')->Hello World!
'{0}!'.format('Hello {1}', 'Word')->Hello World!