How to use Node.js Console? & What is Console info?

Node.js Console

The comprehensive console and util modules in Node.js allow more sophisticated debugging and logging techniques than the simple console.log(). These tools will help you better understand how your application behaves and make your development output easier to read.

Advanced Console Methods

The console module in Node.js offers straightforward yet effective logging and debugging features, just like its browser counterpart.

The standard error (stderr) stream is the intended destination for console.error() output, whereas console.log() publishes messages to the standard output (stdout). This distinction is essential for distinguishing error messages from regular program output, which can be helpful for diverting output or for logging systems.

You can also provide informative messages using the console.info() method. It helps to semantically classify your output, even if it functions similarly to console.log() in its default behavior (publishing to stdout). Though it usually works similarly to console.error() for warnings, console.warn() is not covered in full are available.

Here’s an example demonstrating console.log() and console.error():

// Example: console_methods.js
console.log('This is a regular log message.');
console.info('This is an informational message.');
console.error('Oops! Something went wrong here.');

Code Output:

This is a regular log message.
This is an informational message.
Oops! Something went wrong here.

console.time() and console.timeEnd() are provided by Node.js for performance timing. console.time() initiates a timer with a distinct label. The timer terminates when console.timeEnd() is invoked with the same label, and stdout is displayed with the amount of time that has passed in milliseconds. This is really helpful when you want to benchmark synchronous actions in your code.

// Example: performance_timing.js
console.time('DataProcessing'); // Start timer with label 'DataProcessing'
// Simulate a long-running operation
for (let i = 0; i < 1000000; i++) {
  // Do some processing
}
console.timeEnd('DataProcessing'); // End timer and print elapsed time

Code Output:

DataProcessing: 5.123ms

(The exact time will vary based on your system and Node.js version.)

Other Useful Console Methods

1. console.dir(Object): Using the supplied object, console.dir(Object) executes util.inspect() and outputs the outcome to stdout. JavaScript objects can be extensively nested, and it’s useful for obtaining a thorough, structured string representation of them.
2. console.count(label): This useful method, console.count(label), counts the number of times a particular string label is displayed and shows the count next to it.
3. console.trace(): When you need to know the call stack that led to a certain section of your code, console.trace() will print the call stack trace. Debugging complex flows is made easier by this.

// Example: other_console_methods.js
const myObject = {
  name: 'Node.js',
  version: 'latest',
  details: {
    engine: 'V8',
    type: 'runtime'
  }
};
console.dir(myObject); // Detailed object inspection
function fun2() {
  console.trace('Reached fun2'); // Print stack trace
}
function fun1() {
  fun2();
}
console.count('UserLogin'); // First call
console.count('UserLogin'); // Second call
fun1(); // Call fun1
console.count('UserLogin'); // Third call

Code Output:

{ name: 'Node.js', version: 'latest', details: { engine: 'V8', type: 'runtime' } }
UserLogin: 1
UserLogin: 2
Trace: Reached fun2
    at fun2 (file:///path/to/your/other_console_methods.js:10:11)
    at fun1 (file:///path/to/your/other_console_methods.js:14:3)
    at Object.<anonymous> (file:///path/to/your/other_console_methods.js:17:1)
    // ... (rest of stack trace)
UserLogin: 3

Formatting Output

Beyond only showing data, Node.js offers formatting options for console output, such as the use of colors, to improve readability while the code is being developed.

General Formatting

A newline character is automatically added by the console.log() method, which is really a wrapper for process.stdout.write(). For more precise control over your terminal presentation, you can print content straight without a newline by using process.stdout.write().

// Example: process_stdout_write.js
process.stdout.write('This is the first part.');
process.stdout.write('This is the second part, on the same line.');
console.log('\nThis is a new line, introduced by console.log');

Code Output:

This is the first part.This is the second part, on the same line.
This is a new line, introduced by console.log

Colouring the Output

Your console output can be colored by using terminal (control) codes. These escape sequences are interpreted by the terminal as commands to modify the properties of the text. \033[31m, for example, changes the font color to red, and \033[0m resets the formatting.

For easier color management, Node.js also allows the use of libraries like Chalk, which improves code readability and is significantly more convenient than remembering escape codes. Such a library would normally be installed with npm (for example, npm install chalk) and then required in your script.

Here are some examples of standard terminal codes for colours:

Font Colours

• Black: \033[30m
• Red: \033[31m
• Green: \033[32m
• Yellow: \033[33m
• Blue: \033[34m
• Magenta: \033[35m
• Cyan: \033[36m
• White: \033[37m

Background Colours

• Black: \033[40m
• Red: \033[41m
• Green: \033[42m
• Yellow: \033[43m
• Blue: \033[44m
• Magenta: \033[45m
• Cyan: \033[46m
• White: \033[47m

(Remember to use \033[0m to reset formatting after applying colours.)

// Example: coloured_output.js
console.log('\x1b[31mThis text is red.\x1b[0m'); // Red font
console.log('\x1b[44m\x1b[37mWhite text on blue background.\x1b[0m'); // White font, blue background
// If chalk was installed (but for illustration as mentioned in ):
// const chalk = require('chalk');
// console.log(chalk.yellow('This text is yellow using Chalk.'));

Code Output: (Output will show coloured text in compatible terminals)

This text is red.
White text on blue background.

Advanced Formatting with Module

The util module offers developer-friendly tools, particularly for formatting, but its main purpose is to support Node.js’s internal APIs.

• util.format(format, [arg, arg…]): Using placeholders, you can create a formatted string using util.format(format, [arg, arg…]).
  • %s: Formats a variable as a string.
  • %d or %i: Formats a variable as an integer.
  • %f: Formats a variable as a floating-point number.
  • %j: Formats a variable as a JSON object.
  • %O: Prints an object representation. If more arguments are provided than placeholders, the extras are converted to strings via util.inspect() and concatenated at the end, separated by spaces.
• util.inspect(object, [options]): When you need a string representation of an object, you use util.inspect(object, [options]). This function gives you fine control over the output.
  • showHidden: If true, non-enumerable properties of the object will be shown (defaults to false).
  • depth: Determines how many levels deep util.inspect walks through before entering a nested object; by default, it is 2.
  • colors: If true, the output will be colourised. Data types have default color assignments, which can be found in util.inspect.styles.
  • customInspect: If an object has its own inspect method, its output will be used instead of the stringification that Node defaults to, which is true.

// Example: util_formatting.js
const util = require('util');
// util.format() examples
console.log(util.format('My %s has %d years.', 'dog', 5));
console.log(util.format('%s and %s, and a third %s.', 'apple', 'banana', 'orange', 'extra fruit'));
console.log(util.format('Object representation: %O', { a: 1, b: 'two' }));
// util.inspect() example
const complexObj = {
  id: 1,
  data: {
    nested1: 'value1',
    nested2: {
      deepNested: 'value2',
      hiddenProp: Symbol('secret')
    }
  },
  func: () => {}
};
console.log('--- util.inspect() with default options ---');
console.log(util.inspect(complexObj));
console.log('\n--- util.inspect() with showHidden and increased depth ---');
console.log(util.inspect(complexObj, { showHidden: true, depth: 3, colors: true }));

Code Output:

My dog has 5 years.
apple and banana, and a third orange. extra fruit
Object representation: { a: 1, b: 'two' }
--- util.inspect() with default options ---
{ id: 1, data: { nested1: 'value1', nested2: [Object] }, func: [Function: func] }
--- util.inspect() with showHidden and increased depth ---
{
  id: 1,
  data: {
    nested1: 'value1',
    nested2: {
      deepNested: 'value2',
      hiddenProp: Symbol(secret) // This will be coloured if terminal supports it
    }
  },
  func: [Function: func]
}

These sophisticated console and utility techniques give Node.js developers all the tools they need to debug efficiently and generate output that is incredibly legible when working on a project.