JavaScript equivalente a printf / String.Format
https://stackoverflow.com/questions/610406
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Sto cercando un buon equivalente JavaScript di C / PHP printf() o di programmatori C # / Java, String.Format() (IFormatProvider per .NET).
Il mio requisito di base è un formato di mille separatori per i numeri per ora, ma qualcosa che gestisce molte combinazioni (comprese le date) sarebbe buono.
Mi rendo conto che la libreria Ajax di Microsoft fornisce una versione di <=>, ma non vogliamo l'intero overhead di quel framework.
Soluzione
Da ES6 in poi è possibile utilizzare stringhe di modelli:
let soMany = 10;
console.log(`This is ${soMany} times easier!`);
// "This is 10 times easier!
Vedi la risposta di Kim di seguito per i dettagli.
In caso contrario:
Prova sprintf () per JavaScript .
Se vuoi davvero fare un semplice metodo di formattazione da solo, non & # 8217; t esegui le sostituzioni in successione ma eseguile contemporaneamente.
Poiché la maggior parte delle altre proposte menzionate fallisce quando una stringa di sostituzione della sostituzione precedente contiene anche una sequenza di formati come questa:
"{0}{1}".format("{1}", "{0}")
Normalmente ci si aspetta che l'output sia {1}{0} ma l'output effettivo è {1}{1}. Quindi esegui una sostituzione simultanea invece come in fearphage & # 8217; suggerimento s .
Altri suggerimenti
Basandosi sulle soluzioni precedentemente suggerite:
// 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")
uscite
ASP è morto, ma ASP.NET è vivo! ASP {2}
Se preferisci non modificare il prototipo di 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
;
});
};
}
Ti dà molto più familiare:
String.format('{0} is dead, but {1} is alive! {0} {2}', 'ASP', 'ASP.NET');
con lo stesso risultato:
ASP è morto, ma ASP.NET è vivo! ASP {2}
È divertente perché Stack & nbsp; Overflow ha in realtà una propria funzione di formattazione per il String prototipo chiamato formatUnicorn. Provalo! Vai nella console e digita qualcosa del tipo:
"Hello, {name}, are you feeling {adjective}?".formatUnicorn({name:"Gabriel", adjective: "OK"});
Ottieni questo output:
Hello, Gabriel, are you feeling OK?
Puoi usare oggetti, matrici e stringhe come argomenti! Ho ottenuto il suo codice e lo ho rielaborato per produrre una nuova versione di 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;
};
Nota la chiamata intelligente Array.prototype.slice.call(arguments) - ciò significa che se lanci argomenti che sono stringhe o numeri, non un singolo oggetto in stile JSON, otterrai <# href = "https://msdn.microsoft.com di C # /en-us/library/system.string.format(v=vs.110).aspx#Starting "> String.Format comportamento quasi esattamente.
"a{0}bcd{1}ef".formatUnicorn("foo", "bar"); // yields "aFOObcdBARef"
Questo perché Array forza slice ciò che è contenuto in arguments in un key, sia esso originariamente o meno, e "\\{0\\}" sarà l'indice (0, 1, 2 .. .) di ogni elemento dell'array forzato in una stringa (ad es. " 0 " ;, quindi <=> per il tuo primo modello regexp).
Neat.
Formattazione numerica in JavaScript
Sono arrivato a questa pagina di domande sperando di trovare come formattare i numeri in JavaScript, senza introdurre ancora un'altra libreria. Ecco cosa ho trovato:
Arrotondamento di numeri in virgola mobile
L'equivalente di sprintf("%.2f", num) in JavaScript sembra essere num.toFixed(2), che formatta da num a 2 cifre decimali, con arrotondamento (ma vedi il commento di @ ars265 su Math.round di seguito).
(12.345).toFixed(2); // returns "12.35" (rounding!)
(12.3).toFixed(2); // returns "12.30" (zero padding)
Modulo esponenziale
L'equivalente di sprintf("%.2e", num) è num.toExponential(2).
(33333).toExponential(2); // "3.33e+4"
Esadecimale e altre basi
Per stampare i numeri nella base B, provare num.toString(B). JavaScript supporta la conversione automatica da e verso le basi da 2 a 36 (inoltre, alcuni browser hanno supporto limitato per la codifica base64 ).
(3735928559).toString(16); // to base 16: "deadbeef"
parseInt("deadbeef", 16); // from base 16: 3735928559
Pagine di riferimento
Tutorial rapido sulla formattazione dei numeri JS
Pagina di riferimento di Mozilla per toFixed () (con collegamenti a toPrecision (), toExponential (), toLocaleString (), ...)
Da ES6 in poi è possibile utilizzare stringhe di modelli :
let soMany = 10;
console.log(`This is ${soMany} times easier!`);
// "This is 10 times easier!
Tieni presente che le stringhe di modello sono circondate da backtick `anziché da (singole) virgolette.
Per ulteriori informazioni:
https://developers.google.com/web/updates/2015/01 / ES6-Template-Strings
https://developer.mozilla.org/en-US/docs/Web / JavaScript / Reference / template_strings
Nota: Controlla il sito di mozilla per trovare un elenco di browser supportati.
jsxt, Zippo
Questa opzione si adatta meglio.
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;
};
Con questa opzione posso sostituire stringhe come queste:
'The {0} is dead. Don\'t code {0}. Code {1} that is open source!'.format('ASP', 'PHP');
Con il tuo codice il secondo {0} non verrebbe sostituito. ;)
Uso questa semplice funzione:
String.prototype.format = function() {
var formatted = this;
for( var arg in arguments ) {
formatted = formatted.replace("{" + arg + "}", arguments[arg]);
}
return formatted;
};
È molto simile a string.format:
"{0} is dead, but {1} is alive!".format("ASP", "ASP.NET")
Per gli utenti Node.js c'è util.format che ha funzionalità simili a printf:
util.format("%s world", "Hello")
Ecco un'implementazione minima di sprintf in JavaScript: fa solo "% s " e "% d " ;, ma ho lasciato spazio per estenderlo. È inutile per il PO, ma altre persone che si imbattono in questa discussione proveniente da Google potrebbero trarne beneficio.
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, %d
var val = null;
if (m[2]) {
val = m[2];
} else {
val = args[i];
// A switch statement so that the formatter can be extended. Default is %s
switch (m) {
case '%d':
val = parseFloat(val);
if (isNaN(val)) {
val = 0;
}
break;
}
i++;
}
return val;
});
}
Esempio:
alert(sprintf('Latitude: %s, Longitude: %s, Count: %d', 41.847, -87.661, 'two'));
// Expected output: Latitude: 41.847, Longitude: -87.661, Count: 0
Contrariamente a soluzioni simili nelle risposte precedenti, questa sostituisce tutte le sostituzioni in una volta , quindi non sostituirà parti di valori precedentemente sostituiti.
Sono sorpreso che nessuno abbia usato < codice> riduci , questa è una funzione JavaScript concisa e potente nativa.
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"
Come funziona:
riduci applica una funzione su un accumulatore e su ogni elemento dell'array (da sinistra a destra) per ridurla a un singolo valore.
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")
);
I programmatori JavaScript possono utilizzare String.prototype.sprintf all'indirizzo https: //github.com/ildar-shaimordanov/jsxt/blob/master/js/String.js . Di seguito è riportato un esempio:
var d = new Date();
var dateStr = '%02d:%02d:%02d'.sprintf(
d.getHours(),
d.getMinutes(),
d.getSeconds());
+1 Zippo con l'eccezione che il corpo della funzione deve essere come di seguito o altrimenti aggiunge la stringa corrente ad ogni iterazione:
String.prototype.format = function() {
var formatted = this;
for (var arg in arguments) {
formatted = formatted.replace("{" + arg + "}", arguments[arg]);
}
return formatted;
};
Aggiungendo alla risposta di zippoxer , utilizzo questa funzione:
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.
Ho anche una versione non prototipo che uso più spesso per la sua sintassi simile a 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
Aggiornamento ES 2015
Tutte le fantastiche novità di ES 2015 rendono tutto molto più semplice:
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."
Ho pensato che dato che questo, come i più vecchi, in realtà non analizza le lettere, potrebbe anche usare un solo token %% . Questo ha il vantaggio di essere ovvio e di non rendere difficile l'uso di un singolo % . Tuttavia, se hai bisogno di %% per qualche motivo, dovrai sostituirlo con se stesso:
format("I love percentage signs! %%", "%%");
// "I love percentage signs! %%"
Aggiungerò le mie scoperte che ho trovato da quando le ho chiesto:
- number_format (per migliaia di formattazione separatore / valuta)
- sprintf (stesso autore di cui sopra)
Sfortunatamente sembra che sprintf non gestisca la formattazione di migliaia di separatori come il formato stringa di .NET.
Uso una piccola libreria chiamata String.format per JavaScript che supporta la maggior parte del formato funzionalità di stringa (incluso il formato di numeri e date) e utilizza la sintassi .NET. Lo script stesso è più piccolo di 4 kB, quindi non crea sovraccarico.
Molto elegante:
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}")
Il credito va a (link non funzionante) https://gist.github.com/0i0/1519811
Voglio condividere la mia soluzione per il "problema". Non ho reinventato la ruota ma cerco di trovare una soluzione basata su ciò che già JavaScript fa. Il vantaggio è che puoi ottenere gratuitamente tutte le conversioni implicite. L'impostazione della proprietà prototipo $ di String fornisce una sintassi molto piacevole e compatta (vedere gli esempi di seguito). Forse non è il modo più efficiente, ma nella maggior parte dei casi gestire l'output non deve essere super ottimizzato.
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));
}
Ecco alcuni esempi:
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'
Ho una soluzione molto vicina a quella di Peter, ma riguarda il caso dei numeri e degli oggetti.
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);
});
};
}
Forse potrebbe essere ancora meglio affrontare tutti i casi profondi, ma per le mie esigenze va bene.
"This is an example from {name}".format({name:"Blaine"});
"This is an example from {0}".format("Blaine");
PS: questa funzione è molto interessante se stai utilizzando traduzioni in framework di modelli come AngularJS :
<h1> {{('hello-message'|translate).format(user)}} <h1>
<h1> {{('hello-by-name'|translate).format( user ? user.name : 'You' )}} <h1>
Dove en.json è qualcosa di simile
{
"hello-message": "Hello {name}, welcome.",
"hello-by-name": "Hello {0}, welcome."
}
Il progetto PHPJS ha scritto implementazioni JavaScript per molte delle funzioni di PHP. Poiché la funzione sprintf () di PHP è sostanzialmente la stessa di printf () di C, la loro implementazione in JavaScript di esso dovrebbe soddisfare le tue esigenze.
Uso questo:
String.prototype.format = function() {
var newStr = this, i = 0;
while (/%s/.test(newStr))
newStr = newStr.replace("%s", arguments[i++])
return newStr;
}
Quindi lo chiamo:
"<h1>%s</h1><p>%s</p>".format("Header", "Just a test!");
Una versione leggermente diversa, quella che preferisco (questa usa token {xxx} anziché {0} argomenti numerati, è molto più autocompattante e si adatta molto meglio alla localizzazione):
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;
};
Una variazione sarebbe:
var formatted = l(this);
che chiama prima una funzione di localizzazione l ().
Esiste " sprintf " per JavaScript che puoi trovare su http://www.webtoolkit.info/javascript-sprintf.html .
Per coloro a cui piace Node.JS e i suoi util.format , l'ho appena estratto nel suo modulo JavaScript vanilla (con solo le funzioni utilizzate da 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 primitive
if (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 it
if (ctx.customInspect &&
value &&
isFunction(value.inspect) &&
// Filter out the util module, it's inspect function is special
value.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 properties
var 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 reasons
if (!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 redundant
keys = 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 primitives
if (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 Array
if (isArray(value)) {
array = true;
braces = ['[', ']'];
}
// Make functions say that they are functions
if (isFunction(value)) {
var n = value.name ? ': ' + value.name : '';
base = ' [Function' + n + ']';
}
// Make RegExps say that they are RegExps
if (isRegExp(value)) {
base = ' ' + RegExp.prototype.toString.call(value);
}
// Make dates with properties first say the date
if (isDate(value)) {
base = ' ' + Date.prototype.toUTCString.call(value);
}
// Make error with message first say the error
if (isError(value)) {
base = ' ' + formatError(value);
}
// Make boxed primitive Strings look like such
if (isString(raw)) {
formatted = formatPrimitiveNoColor(ctx, raw);
base = ' ' + '[String: ' + formatted + ']';
}
// Make boxed primitive Numbers look like such
if (isNumber(raw)) {
formatted = formatPrimitiveNoColor(ctx, raw);
base = ' ' + '[Number: ' + formatted + ']';
}
// Make boxed primitive Booleans look like such
if (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 options
var 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" object
exports._extend(ctx, opts);
}
// set default options
if (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;
};
Raccolto da: https://github.com/joyent/node/blob/master/ lib / util.js
Ho un formattatore leggermente più lungo per JavaScript qui ...
Puoi eseguire la formattazione in diversi modi:
-
String.format (input, args0, arg1, ...) -
String.format (input, obj) -
" letteral " .format (arg0, arg1, ...) -
" letterale " .format (obj)
Inoltre, se hai detto un ObjectBase.prototype.format (come con DateJS ) utilizzerà che.
Gli esempi ...
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})"
Ho anche fatto le alias con .asFormat e ho un po 'di rilevamento nel caso in cui ci sia già un string.format (come con MS Ajax Toolkit (odio quella libreria).
Nel caso in cui qualcuno abbia bisogno di una funzione per prevenire l'inquinamento dell'ambito globale, ecco la funzione che fa lo stesso:
function _format (str, arr) {
return str.replace(/{(\d+)}/g, function (match, number) {
return typeof arr[number] != 'undefined' ? arr[number] : match;
});
};
Per la formattazione di base:
var template = jQuery.validator.format("{0} is not a valid value");
var result = template("abc");
Non ho visto la variante 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;
});
};
Da utilizzare con le funzioni di successo jQuery.ajax (). Passa solo un singolo argomento e la stringa sostituisce con le proprietà di quell'oggetto come {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;
};
Esempio:
var userInfo = ("Email: {Email} - Phone: {Phone}").format({ Email: "someone@somewhere.com", Phone: "123-123-1234" });
Con sprintf.js in atto, si può creare un piccolo formato elegante
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}
