Skip to content
Related Articles

Related Articles

Node.js util.format() Method
  • Last Updated : 22 Jul, 2020

The util.format() (Added in v0.5.3) method is an inbuilt application programming interface of the util module which is like printf format string and returns a formatted string using the first argument. The formatted string contains zero or more format specifiers in which the corresponding argument value is converted and replaced. It is used as a debugging tool is a synchronous method hence, it can have a significant performance overhead that could block the event loop. It is recommended not to use this function in a hot code path.


util.format(format[, ...args])

Parameters: This method accept two parameters as mentioned above and described below:

  • format: It consists of specifiers of <string> type, which is like printf format string.

  • args: It is the <string> type list of arguments.

    Supported specifiers are:

    • %%: It replaces specifier with a single percent sign (‘%%’/‘%’) and doesn’t consume any argument even if it provided.
    • %s (String): It converts all values according to given format except Object, BigInt, and -0. Objects that have no user-defined toString function are inspected using util.inspect() and BigInt values are represented with n.
    • %c(CSS): If any CSS is passed, it will be skipped. Usually, this specifier is ignored.
    • %d (Number): It converts all values according to the given format except Symbol and BigInt.
    • %i (parseInt()): It parses a <string> and returns an integer, it is used for all values except BigInt and Symbol.
    • %f (parseFloat()): It parses a string and returns a floating-point number, it is used for all values except Symbols.
    • %j (JSON): No complicated parsing or translations, if there are circular references in the argument then it is replaced with the string ‘[Circular]’.
    • %o(Object): It is a string representation of an object with generic JavaScript object formatting. Similar to util.inspect(). It shows the full object along with non-enumerable properties and proxies.
    • %O(Object): It is similar to ‘%o’ but without options, it does not include non-enumerable properties and proxies.

Return Value: It returns the formatted string of <string> type.

Example 1:

Filename: index.js

// Node.js to demonstrate the
// util.format() method 
// Import the util module 
const util = require('util');
function fun1() {
    var val1 = util.format('%s:%s:%s', 'abc');
    // Returns: 'foo:%s'
    var val2 = util.format('%s:%s'
        'abc', 'def', 'ghi', 'jkl');
    // Returns: 'foo:bar baz'
    var val3 = util.format(10, 20, 30);
    // Returns: '1 2 3'
    var val4 = util.format('%% : %s : %d');
    // Returns: '%% %s'
    var val5 = util.format('%% : %s', 567);
    // Returns: '% : 567'
    console.log(val1, '\n', val2, '\n'
        val3, '\n', val4, '\n', val5);
// Function call

Run index.js file using the following command:

node index.js


:abc:def ghi jkl
10 20 30
%% : %s : %d
% : 567

Example 2:

Filename: index.js

// Node.js program to demonstrate
// the util.format() method 
// Import the util module 
const util = require('util');
// Passing multiple values and
// -0 on string specifier
console.log("1.>", util.format(
    '%%: %s', 'abc', 'def', -0));
// Passing multiple values 
console.log("2.>", util.format(
    '%%', 'abc', 'def', 'ghi'));
// Passing bigInt to string specifier
console.log("3.>", util.format('%s'
    'abc', 94321321321223372036854775807));
// Creating and passing Object along 
// with null prototype and a variable
console.log("4.>", util.format('%s'
        'abc', Object.create(null,
        { [Symbol.toStringTag]: 
            { value: 'def' } })));
// Passing string to Number specifier
console.log("5.>", util.format('%d'
            'abc', 94303685));
// Passing Symbol and Number to
// parseInt specifier
console.log("6.>", util.format(
    '%i', '2020 year 2021, ', 'He was 40,'
    , '10.33, ', '10, ', 10));
// Passing string and Numbers
// to parseFloat specifier
console.log("7.>", util.format('%f'
    '94321321321.564000 year 6546',
    'abc', 943036854775807));
// Passing JSON string and Nunber
// to JSON specifier
console.log("8.>", util.format('%j',
    '{ "name":"John", "age":31, "city":"New York" }'
    'abc', 943036854775807));
// Passing class, string, and Number
// to object specifier
console.log("9.>", util.format('%o'
    class Bar { }, 'abc', 943036854775807));
// Passing class, string, and Number
// to Object specifier
console.log("10.>", util.format('%o:%d',
    class Foo { get [Symbol.toStringTag]() 
        { return 'abc'; } },
// Random class
class randomClass { }
// Inspecting random class
    util.inspect(new randomClass()));

Run index.js file using the following command:

node index.js


1.> %: abc def -0
2.> % abc def ghi
3.> abc 9.432132132122338e+28
4.> abc [Object: null prototype] [def] {}
5.> NaN 94303685
6.> 2020 He was 40, 10.33, 10, 10
7.> 94321321321.564 abc 943036854775807
8.> "{ \"name\":\"John\", \"age\":31, 
    \"city\":\"New York\" }" abc 943036854775807
9.> <ref *1> [Function: Bar] {
    [length]: 0,
    [prototype]: Bar { [constructor]: [Circular *1] },
    [name]: 'Bar'
   } abc 943036854775807
10.> <ref *1> [Function: Foo] {
    [length]: 0,
    [prototype]: Foo {
    [constructor]: [Circular *1],
    [Symbol(Symbol.toStringTag)]: [Getter]
    [name]: 'Foo'
   }:NaN 943036854775807
11.> randomClass {}


  • If no corresponding argument is passed to the specifier then it is not replaced.
  • If multiple arguments are passed than the number of specifiers, then extra arguments will be concatenated to the returned string.
  • If ‘values’ do not belong to format string and their type is not a string then they are formatted using util.inspect() method.
  • If the first argument doesn’t have a valid format specifier, then util.format() returns concatenated arguments.


My Personal Notes arrow_drop_up
Recommended Articles
Page :