javascript बदलन जावास्क्रिप्ट printf/string.format के बराबर है




हेक्साडेसिमल संख्या में दशमलव संख्या 126 कन्वर्ट (24)

आप पर 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/en-US/docs/Web/JavaScript/Reference/template_strings

नोट: समर्थित ब्राउज़र की सूची खोजने के लिए मोज़िला-साइट देखें।

मैं सी / PHP printf() या सी # / जावा प्रोग्रामर, IFormatProvider String.Format() (.NET के लिए IFormatProvider String.Format() लिए एक अच्छा जावास्क्रिप्ट समतुल्य खोज रहा हूं।

मेरी मूल आवश्यकता अब के लिए संख्याओं के लिए एक हजार विभाजक प्रारूप है, लेकिन कुछ संयोजन जो कई संयोजनों (तिथियों सहित) को संभालता है वह अच्छा होगा।

मुझे एहसास है कि माइक्रोसॉफ्ट की Ajax लाइब्रेरी String.Format() का एक संस्करण प्रदान करती है, लेकिन हम उस ढांचे के पूरे ओवरहेड को नहीं चाहते हैं।


यह मजाकिया है क्योंकि स्टैक ओवरफ्लो में String प्रोटोटाइप के लिए वास्तव में अपना स्वयं का स्वरूपण कार्य है जिसे formatUnicorn कहा जाता है। कोशिश करो! कंसोल में जाएं और कुछ टाइप करें:

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

आपको यह आउटपुट मिलता है:

Hello, Gabriel, are you feeling OK?

आप तर्क के रूप में वस्तुओं, सरणी, और तारों का उपयोग कर सकते हैं! मुझे अपना कोड मिला और String.prototype.format का एक नया संस्करण बनाने के लिए इसे फिर से 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- शैली ऑब्जेक्ट नहीं, तो आपको सी # स्ट्रिंग मिलती है। String.Format व्यवहार लगभग बिल्कुल ठीक है।

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

ऐसा इसलिए है क्योंकि Array का slice किसी भी Array में arguments में जो कुछ भी है, चाहे वह मूल रूप से हो या नहीं, और key एक स्ट्रिंग में घुमाए गए प्रत्येक सरणी तत्व का सूचकांक (0, 1, 2 ...) होगा (उदाहरण के लिए, "0", इसलिए "\\{0\\}" आपके पहले regexp पैटर्न के लिए)।

साफ।


I didn't see pyformat in the list so I thought I'd throw it in:

console.log(pyformat( 'The {} {} jumped over the {}'
                , ['brown' ,'fox' ,'foobar']
                ))
console.log(pyformat('The {0} {1} jumped over the {1}'
                , ['brown' ,'fox' ,'foobar']
                ))
console.log(pyformat('The {color} {animal} jumped over the {thing}'
                , [] ,{color: 'brown' ,animal: 'fox' ,thing: 'foobaz'}
                ))

बहुत खूबसूरत:

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


मैं 'समाधान' के लिए अपना समाधान साझा करना चाहता हूं। मैंने पहिया का पुन: आविष्कार नहीं किया है लेकिन जावास्क्रिप्ट पहले से ही क्या करता है इसके आधार पर समाधान ढूंढने का प्रयास करता है। लाभ यह है कि आप सभी निहित रूपांतरण मुफ्त में प्राप्त करते हैं। स्ट्रिंग की प्रोटोटाइप प्रॉपर्टी $ सेट करना बहुत अच्छा और कॉम्पैक्ट सिंटैक्स देता है (नीचे उदाहरण देखें)। यह शायद सबसे प्रभावी तरीका नहीं है, लेकिन अधिकांश मामलों में आउटपुट से निपटने में इसे सुपर अनुकूलित नहीं किया जाना चाहिए।

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;
        var 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.out("%s %s".$("This is a string", 11))
var arr = [ "12.3", 13.6 ]; console.out("Array: %s".$(arr));
var obj = { test:"test", id:12 }; console.out("Object: %s".$(obj));
console.out("%c", "Test");
console.out("%5d".$(12)); // '   12'
console.out("%05d".$(12)); // '00012'
console.out("%-5d".$(12)); // '12   '
console.out("%5.2d".$(123)); // '  120'
console.out("%5.2f".$(1.1)); // ' 1.10'
console.out("%10.2e".$(1.1)); // '   1.10e+0'
console.out("%5.3p".$(1.12345)); // ' 1.12'
console.out("%5x".$(45054)); // ' affe'
console.out("%20#2x".$("45054")); // '    1010111111111110'
console.out("%6#2d".$("111")); // '     7'
console.out("%6#16d".$("affe")); // ' 45054'

यदि आप हजारों विभाजक को संभालने की तलाश में हैं, तो आपको जावास्क्रिप्ट Number क्लास से वास्तव में लोकालेस्ट्रिंग () का उपयोग करना चाहिए क्योंकि यह उपयोगकर्ता के क्षेत्र के लिए स्ट्रिंग को प्रारूपित करेगा।

जावास्क्रिप्ट Date वर्ग स्थानीयकृत तिथियों और समय को प्रारूपित कर सकता है।


मैं अपनी खुद की खोजों को जोड़ दूंगा जो मैंने पाया है क्योंकि मैंने पूछा था:

अफसोस की बात है कि ऐसा लगता है कि sprintf हजार विभाजक स्वरूपण को .NET के स्ट्रिंग प्रारूप की तरह संभाल नहीं करता है।


I have a slightly longer formatter for JavaScript here ...

You can do formatting several ways:

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

Also, if you have say a ObjectBase.prototype.format (such as with DateJS ) it will use that.

Examples...

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

I've also aliased with .asFormat and have some detection in place in case there's already a string.format (such as with MS Ajax Toolkit (I hate that library).


मुझे आश्चर्य है कि कोई भी reduce नहीं किया जाता है, यह एक देशी संक्षिप्त और शक्तिशाली जावास्क्रिप्ट फ़ंक्शन है।

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

<ईएस 6

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"

यह काम किस प्रकार करता है:

कम करने के लिए एक संचयक के खिलाफ एक फ़ंक्शन और सरणी में प्रत्येक तत्व (बाएं से दाएं) को एक मान पर कम करने के लिए लागू होता है।

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



Just in case someone needs a function to prevent polluting global scope, here is the function that does the same:

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

यहां जावास्क्रिप्ट में स्प्रिंटफ का न्यूनतम कार्यान्वयन है: यह केवल "% s" और "% d" करता है, लेकिन मैंने इसे विस्तारित करने के लिए स्थान छोड़ा है। यह ओपी के लिए बेकार है, लेकिन 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, %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;
    });
}

उदाहरण:

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

पिछले उत्तरों में समान समाधानों के विपरीत, यह एक ही समय में सभी प्रतिस्थापन करता है, इसलिए यह पहले प्रतिस्थापित मूल्यों के हिस्सों को प्रतिस्थापित नहीं करेगा।


मेरे पास पीटर के बहुत करीब समाधान है, लेकिन यह संख्या और ऑब्जेक्ट केस से संबंधित है।

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

पीएस: यदि आप 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."
}

पहले सुझाए गए समाधानों पर बिल्डिंग:

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

आउटपुट

एएसपी मर चुका है, लेकिन एएसपी.नेट जीवित है! एएसपी {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');

एक ही परिणाम के साथ:

एएसपी मर चुका है, लेकिन एएसपी.नेट जीवित है! एएसपी {2}


/**
 * Format string by replacing placeholders with value from element with
 * corresponsing index in `replacementArray`.
 * Replaces are made simultaneously, so that replacement values like
 * '{1}' will not mess up the function.
 *
 * Example 1:
 * ('{2} {1} {0}', ['three', 'two' ,'one']) -> 'one two three'
 *
 * Example 2:
 * ('{0}{1}', ['{1}', '{0}']) -> '{1}{0}'
 */
function stringFormat(formatString, replacementArray) {
    return formatString.replace(
        /\{(\d+)\}/g, // Matches placeholders, e.g. '{1}'
        function formatStringReplacer(match, placeholderIndex) {
            // Convert String to Number
            placeholderIndex = Number(placeholderIndex);

            // Make sure that index is within replacement array bounds
            if (placeholderIndex < 0 ||
                placeholderIndex > replacementArray.length - 1
            ) {
                return placeholderIndex;
            }

            // Replace placeholder with value from replacement array
            return replacementArray[placeholderIndex];
        }
    );
}

I did not see the String.format variant:

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

उन लोगों के लिए जो नोड.जेएस और इसकी util.format फीचर util.format करते हैं, मैंने इसे अपने वेनिला जावास्क्रिप्ट फॉर्म में निकाला है (केवल फ़ंक्शंस जो 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;
};

Harvested from: https://github.com/joyent/node/blob/master/lib/util.js


PHPJS प्रोजेक्ट ने PHP के कई कार्यों के लिए जावास्क्रिप्ट कार्यान्वयन लिखा है। चूंकि PHP का sprintf() फ़ंक्शन मूल रूप से सी के printf() , इसलिए इसका जावास्क्रिप्ट कार्यान्वयन आपकी आवश्यकताओं को पूरा करना चाहिए।


मैं इसका उपयोग करता हूं:

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

मैं जावास्क्रिप्ट के लिए String.format नामक एक छोटी लाइब्रेरी का उपयोग करता हूं जो अधिकांश प्रारूप स्ट्रिंग क्षमताओं (संख्याओं और तिथियों के प्रारूप सहित) का समर्थन करता है, और .NET वाक्यविन्यास का उपयोग करता है। स्क्रिप्ट स्वयं 4 केबी से छोटी है, इसलिए यह अधिकतर ओवरहेड नहीं बनाती है।


जावास्क्रिप्ट में संख्या स्वरूपण

मुझे यह प्रश्न पृष्ठ मिल गया है कि यह जानने के लिए कि जावास्क्रिप्ट में संख्याओं को कैसे प्रारूपित किया जाए, फिर भी एक और लाइब्रेरी पेश किए बिना। यहां मैंने जो पाया है:

फ़्लोटिंग-पॉइंट नंबर गोल करना

जावास्क्रिप्ट में sprintf("%.2f", num) num.toFixed(2) , जो गोल करने के साथ 2 दशमलव स्थानों पर num स्वरूपित करता है (लेकिन नीचे @ Maths265 की टिप्पणी के बारे में @ ars265 की टिप्पणी देखें)।

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

घातीय रूप

sprintf("%.2e", num) बराबर sprintf("%.2e", num) num.toExponential(2)

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

हेक्साडेसिमल और अन्य अड्डों

बेस बी में संख्याओं को मुद्रित करने के लिए, num.toString(B) आज़माएं। जावास्क्रिप्ट बेस से 2 से 36 तक स्वचालित रूपांतरण का समर्थन करता है (इसके अतिरिक्त, कुछ ब्राउज़रों के पास बेस 64 एन्कोडिंग के लिए सीमित समर्थन होता है )।

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

संदर्भ पृष्ठ

जेएस नंबर स्वरूपण पर त्वरित ट्यूटोरियल

मोज़िला संदर्भ पृष्ठ के लिए फिक्स्ड () (से प्रेसिजन (), toExponential (), toLocaleString (), के लिंक के साथ ...)


+1 ज़िप्पो अपवाद के साथ कि फ़ंक्शन बॉडी को नीचे या अन्यथा होने की आवश्यकता है, यह प्रत्येक पुनरावृत्ति पर वर्तमान स्ट्रिंग को जोड़ती है:

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

Node.js उपयोगकर्ताओं के लिए util.format जिसमें printf-like कार्यक्षमता है:

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

zippoxer के उत्तर में 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.

मेरे पास एक गैर-प्रोटोटाइप संस्करण भी है जिसका उपयोग मैं अपने जावा-जैसे वाक्यविन्यास के लिए अक्सर करता हूं:

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

ईएस 2015 अपडेट

ईएस 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! %%"




string.format