Node.js util.format() Method

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

Syntax:

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

Parameters: This method accepts 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 the specifier with a single percent sign (‘%%’/‘%’) and doesn’t consume any argument even if it is provided.
• %s (String): It converts all values according to the 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: In this example, we will see the use of the util.format().

index.js

javascript

// Node.js to demonstrate the
// util.format() method

// Import the util module
const util = require('util');

function fun1() {
    let val1 = util.format('%s:%s:%s', 'abc');
    // Returns: 'foo:%s'

    let val2 = util.format('%s:%s',
        'abc', 'def', 'ghi', 'jkl');
    // Returns: 'foo:bar baz'

    let val3 = util.format(10, 20, 30);
    // Returns: '1 2 3'

    let val4 = util.format('%% : %s : %d');
    // Returns: '%% %s'

    let val5 = util.format('%% : %s', 567);
    // Returns: '% : 567'

    console.log(val1, '\n', val2, '\n',
        val3, '\n', val4, '\n', val5);
}

// Function call
fun1();

Run the index.js file using the following command: 

node index.js

Output:

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

Example 2: In this example, we will see the use of the util.format().

index.js

javascript

// 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 Number
// 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'; }
    },
    'abc',
    943036854775807
));

// Random class
class randomClass { }

// Inspecting random class
console.log("11.>",
    util.inspect(new randomClass()));

Run the index.js file using the following command: 

node index.js

Output:

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

Conditions:

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

Reference: https://nodejs.org/api/util.html#util_util_format_format_args