Szukam dobrego odpowiednika JavaScript dla C / PHP printf()lub dla programistów C # / Java String.Format()( IFormatProviderdla .NET).

Moje podstawowe wymaganie to na razie format separatora tysięcy dla liczb, ale dobrze byłoby coś, co obsługuje wiele kombinacji (łącznie z datami).

Zdaję sobie sprawę, że biblioteka Ajax Microsoftu zawiera wersję String.Format(), ale nie chcemy całego narzutu tego frameworka.

Od wersji ES6 możesz używać ciągów szablonów:

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

Zobacz szczegóły odpowiedzi Kim poniżej.

Inaczej:

Spróbuj sprintf () dla JavaScript .

Jeśli naprawdę chcesz samodzielnie wykonać prostą metodę formatowania, nie rób zamienników kolejno, ale rób to jednocześnie.

Ponieważ większość innych wymienionych propozycji kończy się niepowodzeniem, gdy ciąg zastępujący poprzedniej zamiany zawiera również sekwencję formatowania taką jak ta:

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

Normalnie można oczekiwać, że wynik będzie, {1}{0}ale rzeczywisty wynik to {1}{1}. Więc rób jednocześnie zamianę, jak w sugestii strachu .

Opierając się na wcześniej sugerowanych rozwiązaniach:

// 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")

wyjścia

ASP nie żyje, ale ASP.NET żyje! ASP {2}

Jeśli wolisz nie modyfikować Stringprototypu:

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
      ;
    });
  };
}

Daje ci znacznie bardziej znane:

String.format('{0} is dead, but {1} is alive! {0} {2}', 'ASP', 'ASP.NET');

z tym samym wynikiem:

ASP nie żyje, ale ASP.NET żyje! ASP {2}

To zabawne, ponieważ Stack Overflow faktycznie ma własną funkcję formatowania Stringzwanego prototypem formatUnicorn. Spróbuj! Wejdź do konsoli i wpisz coś takiego:

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

Otrzymasz ten wynik:

Hello, Gabriel, are you feeling OK?

Jako argumentów możesz używać obiektów, tablic i ciągów! Mam jego kod i przerobiłem go, aby utworzyć nową wersję 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;
};

Zwróć uwagę na sprytne Array.prototype.slice.call(arguments)wywołanie - oznacza to, że jeśli wrzucisz argumenty, które są ciągami lub liczbami, a nie pojedynczym obiektem w stylu JSON, String.Formatzachowanie C # jest prawie dokładne.

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

To dlatego, że Arraynic nie slicezmusi wszystko co w argumentsw produkt Array, czy to pierwotnie, czy nie, i keybędzie indeks (0, 1, 2 ...) każdego elementu tablicy zmuszane do łańcucha (na przykład «0», a więc "\\{0\\}"dla pierwszego wzorca wyrażenia regularnego).

Schludny.

Formatowanie liczb w JavaScript

Doszedłem do tej strony pytań, mając nadzieję na znalezienie sposobu formatowania liczb w JavaScript, bez wprowadzania kolejnej biblioteki. Oto, co znalazłem:

Zaokrąglanie liczb zmiennoprzecinkowych

Wydaje się, że odpowiednikiem sprintf("%.2f", num)w JavaScript jest num.toFixed(2)formatowanie numdo 2 miejsc po przecinku z zaokrąglaniem (ale patrz komentarz @ ars265 na temat Math.roundponiżej).

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

Forma wykładnicza

Odpowiednikiem sprintf("%.2e", num)jest num.toExponential(2).

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

Podstawy szesnastkowe i inne

Aby wydrukować liczby w bazie B, spróbuj num.toString(B). JavaScript obsługuje automatyczną konwersję do i od zasad od 2 do 36 (ponadto niektóre przeglądarki mają ograniczoną obsługę kodowania base64 ).

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

Strony referencyjne

Szybki samouczek na temat formatowania liczb JS

Strona referencyjna Mozilla dla toFixed () (z linkami do toPrecision (), toExponential (), toLocaleString (), ...)

Od wersji ES6 możesz używać ciągów szablonów :

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

Należy pamiętać, że ciągi szablonów są otoczone znakami wstecznymi `zamiast (pojedynczych) cudzysłowów.

W celu uzyskania dalszych informacji:

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

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings

Uwaga: Sprawdź stronę mozilla, aby znaleźć listę obsługiwanych przeglądarek.

jsxt, Zippo

Ta opcja pasuje lepiej.

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;
};

Dzięki tej opcji mogę zastąpić ciągi takie jak te:

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

Z twoim kodem drugi {0} nie zostałby zastąpiony. ;)

Używam tej prostej funkcji:

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

Jest to bardzo podobne do string.format:

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

Dla użytkowników Node.js istnieje util.formatfunkcja podobna do printf:

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

Dziwię się, że nikt tego nie używał reduce, jest to natywna zwięzła i potężna funkcja 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"

Jak to działa:

redukcja stosuje funkcję względem akumulatora i każdego elementu w tablicy (od lewej do prawej), aby zredukować go do pojedynczej wartości.

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")
);

Oto minimalna implementacja sprintf w JavaScript: robi to tylko „% s” i „% d”, ale zostawiłem miejsce na rozszerzenie. Jest to bezużyteczne dla OP, ale inne osoby, które natkną się na ten wątek pochodzący od Google, mogą z niego skorzystać.

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;
    });
}

Przykład:

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

W przeciwieństwie do podobnych rozwiązań w poprzednich odpowiedziach, ta dokonuje wszystkich zamian za jednym razem , więc nie zastąpi części wcześniej zastąpionych wartości.

Programiści JavaScript mogą używać String.prototype.sprintf pod adresem https://github.com/ildar-shaimordanov/jsxt/blob/master/js/String.js . Poniżej znajduje się przykład:

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

Dodając do zippoxerodpowiedzi, używam tej funkcji:

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.

Mam również nieprototypową wersję, której używam częściej ze względu na jej składnię podobną do języka 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

Aktualizacja ES 2015

Wszystkie nowe, fajne rzeczy w ES 2015 sprawiają, że jest to o wiele łatwiejsze:

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."

Uznałem, że ponieważ tak jak starsze, tak naprawdę nie analizuje liter, równie dobrze może użyć tylko jednego tokena %%. Ma to tę zaletę, że jest oczywiste i nie utrudnia korzystania z jednego %. Jeśli jednak %%z jakiegoś powodu potrzebujesz, musisz go zastąpić samym:

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

+1 Zippo z wyjątkiem tego, że treść funkcji musi być taka, jak poniżej, w przeciwnym razie dołącza bieżący ciąg na każdej iteracji:

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

Chcę podzielić się moim rozwiązaniem problemu. Nie wynalazłem koła na nowo, ale próbuję znaleźć rozwiązanie oparte na tym, co już robi JavaScript. Zaletą jest to, że wszystkie niejawne konwersje są bezpłatne. Ustawienie właściwości prototypowej $ String daje bardzo ładną i zwartą składnię (patrz przykłady poniżej). Być może nie jest to najskuteczniejszy sposób, ale w większości przypadków w przypadku produkcji nie musi ona być superoptymalizowana.

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));
}

Oto kilka przykładów:

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'

Dodam własne odkrycia, które znalazłem odkąd zapytałem:

• liczba_format (dla separatora tysięcy / formatowania walut)
• sprintf (ten sam autor jak wyżej)

Niestety wydaje się, że sprintf nie obsługuje formatowania tysięcy separatorów, takich jak format ciągów .NET.

Korzystam z małej biblioteki o nazwie String.format dla JavaScript, która obsługuje większość możliwości formatowania ciągu znaków (w tym formatu liczb i dat) i wykorzystuje składnię .NET. Sam skrypt jest mniejszy niż 4 kB, więc nie powoduje dużego obciążenia.

Bardzo elegancko:

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}")

Kredyt trafia do (uszkodzony link) https://gist.github.com/0i0/1519811

Jeśli chcesz obsłużyć separator tysięcy, naprawdę powinieneś użyć metody toLocaleString () z klasy JavaScript Number, ponieważ sformatuje ona ciąg dla regionu użytkownika.

Klasa daty JavaScript może formatować zlokalizowane daty i godziny.

Projekt PHPJS napisał implementacje JavaScript dla wielu funkcji PHP. Ponieważ sprintf()funkcja PHP jest zasadniczo taka sama jak w języku C printf(), ich implementacja JavaScript powinna zaspokoić twoje potrzeby.

Używam tego:

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

    return newStr;
}

Następnie nazywam to:

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

Mam rozwiązanie bardzo zbliżone do rozwiązania Petera, ale dotyczy ono liczby i przypadku.

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);
    });
  };
}

Może lepiej byłoby zajmować się wszystkimi najgłębszymi sprawami, ale dla moich potrzeb jest to w porządku.

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

PS: Ta funkcja jest bardzo fajna, jeśli używasz tłumaczeń w ramach szablonów, takich jak AngularJS :

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

Gdzie jest en.json

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

Jedna nieco inna wersja, ta, którą preferuję (ta używa tokenów {xxx} zamiast numerowanych argumentów {0}, jest to o wiele bardziej samodokumentujące i lepiej pasuje do lokalizacji):

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;
};

Wariant byłby:

  var formatted = l(this);

która najpierw wywołuje funkcję lokalizacji l ().

Istnieje „sprintf” dla JavaScript, który można znaleźć na stronie http://www.webtoolkit.info/javascript-sprintf.html .

Dla tych, którzy lubią Node.JS i jego util.formatfunkcję, właśnie wyodrębniłem go do waniliowej formy JavaScript (tylko z funkcjami, które wykorzystuje use.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;
};

Zebrane z: https://github.com/joyent/node/blob/master/lib/util.js

Do podstawowego formatowania:

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

Mam nieco dłuższy formatowania dla JavaScriptu tutaj ...

Możesz przeprowadzić formatowanie na kilka sposobów:

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

Ponadto, jeśli powiesz ObjectBase.prototype.format (na przykład z DateJS ), użyje go.

Przykłady ...

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})"

Użyłem również aliasu z .asFormat i mam pewne wykrycie na wypadek, gdyby już istniał łańcuch. Format (np. Z MS Ajax Toolkit (nienawidzę tej biblioteki).

Na wypadek, gdyby ktoś potrzebował funkcji zapobiegającej zanieczyszczeniu zasięgu globalnego, oto funkcja, która robi to samo:

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

Możemy użyć prostej, lekkiej biblioteki operacji na łańcuchach znaków String.Format dla maszynopisu.

String.Format ():

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

Format ciągu dla specyfikatorów:

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"

Format ciągu dla obiektów, w tym specyfikatory:

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

Nie widziałem String.formatwariantu:

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;
    });
};

Do użytku z funkcjami powodzenia jQuery.ajax (). Przekaż tylko jeden argument i ciąg znaków zamień na właściwości tego obiektu jako {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;
};

Przykład:

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