How to change node.js’s console font color?

The Question :

643 people think this question is useful

I had to change the console background color to white because of eye problems, but the font is gray colored and it makes the messages unreadable. How can I change it?

The Question Comments :
  • In the same place you already used to change the background color, you can change the other colors.
  • I’m having the same problem. I suspect @Viclib is using windows (as am I), which is why instructions to change terminal colors are a foreign concept. The windows command prompt allows changing 2 foreground and 2 background colors. Node uses other colors which windows command prompt cannot define.
  • @GregWoods. the accepted answer below does work in Windows !
  • I later discovered that my mental model for how Windows command prompt colours worked, was completely wrong. I assumed incorrectly (due to a terrible UI) that you can only change foreground, background colours. This is wrong. All 16 colours can be used by a console app, and it is vital to pick sensible colours for all 16, and to ALWAYS use colour tile 1 as background (and tile 9 for “popup background”). This was such a revelation to me, I wrote a blog post (a rare event indeed). gregwoods.co.uk/2015/04/…

The Answer 1

1346 people think this answer is useful

Below you can find colors reference of text to command when running node.js application:

console.log('\x1b[36m%s\x1b[0m', 'I am cyan');  //cyan
console.log('\x1b[33m%s\x1b[0m', stringToMakeYellow);  //yellow

Note %s is where in the string (the second argument) gets injected. \x1b[0m resets the terminal color so it doesn’t continue to be the chosen color anymore after this point.

Colors reference

Reset = "\x1b[0m"
Bright = "\x1b[1m"
Dim = "\x1b[2m"
Underscore = "\x1b[4m"
Blink = "\x1b[5m"
Reverse = "\x1b[7m"
Hidden = "\x1b[8m"

FgBlack = "\x1b[30m"
FgRed = "\x1b[31m"
FgGreen = "\x1b[32m"
FgYellow = "\x1b[33m"
FgBlue = "\x1b[34m"
FgMagenta = "\x1b[35m"
FgCyan = "\x1b[36m"
FgWhite = "\x1b[37m"

BgBlack = "\x1b[40m"
BgRed = "\x1b[41m"
BgGreen = "\x1b[42m"
BgYellow = "\x1b[43m"
BgBlue = "\x1b[44m"
BgMagenta = "\x1b[45m"
BgCyan = "\x1b[46m"
BgWhite = "\x1b[47m"

EDIT:

For example, \x1b[31m is an escape sequence that will be intercepted by your terminal and instructs it to switch to the red color. In fact, \x1b is the code for the non-printable control character escape. Escape sequences dealing only with colors and styles are also known as ANSI escape code and are standardized, so therefore they (should) work on any platform.

Wikipedia has a nice comparison of how different terminals display colors https://en.wikipedia.org/wiki/ANSI_escape_code#Colors

The Answer 2

358 people think this answer is useful

There are multiple packages available for formatting console text in Node.js. The most popular are:

Usage:

CHALK:

const chalk = require('chalk');
console.log(chalk.red('Text in red'));


COLORS:

const colors = require('colors');
console.log('Text in red'.red);


CLI-COLOR:

const clc = require('cli-color');
console.log(clc.red('Text in red'));


Many people have noted their disapproval of colors altering the String prototype. If you prefer your prototypes to be left alone, use the following code instead:

const colors = require('colors/safe');
console.log(colors.red('Text in red'));

The Answer 3

165 people think this answer is useful

If you want to change the colors directly yourself without a module try

console.log('\x1b[36m', 'sometext' ,'\x1b[0m');

First \x1b[36m to change the colors to 36 and then back to terminal color 0.

Here’s a list of ANSI color codes

The Answer 4

70 people think this answer is useful

to color your output You can use examples from there:
https://help.ubuntu.com/community/CustomizingBashPrompt

Also a Gist for nodeJs

For example if you want part of the text in red color, just do console.log with:

"\033[31m this will be red \033[91m and this will be normal"

Based on that I’ve created “colog” extension for Node.js. You can install it using:

npm install colog

Repo and npm: https://github.com/dariuszp/colog

The Answer 5

43 people think this answer is useful

This is a list of available colors (background,foreground) in console with available actions (reset,reverse,…).

const colors = {
 Reset: "\x1b[0m",
 Bright: "\x1b[1m",
 Dim: "\x1b[2m",
 Underscore: "\x1b[4m",
 Blink: "\x1b[5m",
 Reverse: "\x1b[7m",
 Hidden: "\x1b[8m",
 fg: {
  Black: "\x1b[30m",
  Red: "\x1b[31m",
  Green: "\x1b[32m",
  Yellow: "\x1b[33m",
  Blue: "\x1b[34m",
  Magenta: "\x1b[35m",
  Cyan: "\x1b[36m",
  White: "\x1b[37m",
  Crimson: "\x1b[38m" //القرمزي
 },
 bg: {
  Black: "\x1b[40m",
  Red: "\x1b[41m",
  Green: "\x1b[42m",
  Yellow: "\x1b[43m",
  Blue: "\x1b[44m",
  Magenta: "\x1b[45m",
  Cyan: "\x1b[46m",
  White: "\x1b[47m",
  Crimson: "\x1b[48m"
 }
};

Use it as following :

 console.log(colors.bg.Blue, colors.fg.White , "I am white message with blue background", colors.Reset) ; 
 //don't forget "colors.Reset" to stop this color and return back to the default color

You can also install :

npm install console-info console-warn console-error --save-dev

IT will give you an output closer to console of client side :

enter image description here

The Answer 6

30 people think this answer is useful

Per this documentation, you can change the colors based on the data type of the output:

// you'll need the util module
var util = require('util');

// let's look at the defaults: 
util.inspect.styles

{ special: 'cyan',
  number: 'yellow',
  boolean: 'yellow',
  undefined: 'grey',
  null: 'bold',
  string: 'green',
  date: 'magenta',
  regexp: 'red' }

// what are the predefined colors?
util.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 ] }

These appear to be ANSI SGR escape codes, where the first number is the code to emit before the output, and the second number is the code to emit after. So if we look at the chart of ANSI SGR codes on Wikipedia, you’ll see that most of these start with a number 30-37 to set the foreground color, and end in 39 to reset to the default foreground color.

So one thing I don’t like is how dark some of these are. Especially dates. Go ahead and try new Date() in the console. Dark magenta on black is really hard to read. Let’s change that to a light magenta instead.

// first define a new color
util.inspect.colors.lightmagenta = [95,39];

// now assign it to the output for date types
util.inspect.styles.date = 'lightmagenta';

Now when you try new Date(), the output is much more readable.

If you’d like to set colors automatically when launching node, create a script that launches the repl, like this:

// set your colors however desired
var util = require('util');
util.inspect.colors.lightmagenta = [95,39];
util.inspect.styles.date = 'lightmagenta';

// start the repl    
require('repl').start({});

Save this file (for example, init.js), then run node.exe init.js. It will set the colors and launch the node.js command prompt.

(Thanks to loganfsmyth in this answer for the repl idea.)

The Answer 7

21 people think this answer is useful

This library by Sindre Sorhus is the best at the moment:

chalk

  • Highly performant
  • Doesn’t extend String.prototype
  • Expressive API
  • Ability to nest styles
  • Clean and focused
  • Auto-detects color support
  • Actively maintained
  • Used by 5500+ modules

The Answer 8

21 people think this answer is useful

Color codes are as mentioned

Reset: "\x1b[0m"
Bright: "\x1b[1m"
Dim: "\x1b[2m"
Underscore: "\x1b[4m"
Blink: "\x1b[5m"
Reverse: "\x1b[7m"
Hidden: "\x1b[8m"

FgBlack: "\x1b[30m"
FgRed: "\x1b[31m"
FgGreen: "\x1b[32m"
FgYellow: "\x1b[33m"
FgBlue: "\x1b[34m"
FgMagenta: "\x1b[35m"
FgCyan: "\x1b[36m"
FgWhite: "\x1b[37m"

BgBlack: "\x1b[40m"
BgRed: "\x1b[41m"
BgGreen: "\x1b[42m"
BgYellow: "\x1b[43m"
BgBlue: "\x1b[44m"
BgMagenta: "\x1b[45m"
BgCyan: "\x1b[46m"
BgWhite: "\x1b[47m"

For example if you want to have a Dim, Red text with Blue background you can do it in Javascript like this:

console.log("\x1b[2m", "\x1b[31m", "\x1b[44m", "Sample Text", "\x1b[0m");

The order of the colors and effects seems to not be that important but always remember to reset the colors and effects at the end.

The Answer 9

21 people think this answer is useful

Emoji

You can use colors for text as others mentioned in their answers.

But you can use emojis instead! for example, you can use⚠️ for warning messages and 🛑 for error messages.

Or simply use these notebooks as a color:

📕: error message
📙: warning message
📗: ok status message
📘: action message
📓: canceled status message
📔: Or anything you like and want to recognize immediately by color

🎁 Bonus:

This method also helps you to quickly scan and find logs directly in the source code.

But Linux default emoji font is not colorful by default and you may want to make them colorful, first.

The Answer 10

18 people think this answer is useful

A handy one-liner I wrote for npm scripts that can’t have dependencies:

const { r, g, b, w, c, m, y, k } = [
  ['r', 1], ['g', 2], ['b', 4], ['w', 7],
  ['c', 6], ['m', 5], ['y', 3], ['k', 0],
].reduce((cols, col) => ({
  ...cols,  [col[0]]: f => `\x1b[3${col[1]}m${f}\x1b[0m`
}), {})

console.log(`${g('I')} love ${r('Italy')}`)

r,g,b,w,c,m,y,k stands for red, green, blue, white, cyan, magenta, yellow and black.

The Answer 11

11 people think this answer is useful

No libraries no complications just simple:

console.log(red('Error!'));

function red(s) {
    return '\033[31m' + s;
}

The Answer 12

10 people think this answer is useful

For a popular alternative to colors that doesn’t mess with the built-in methods of the String object, I recommend checking out cli-color.

Includes both colors and chainable styles such as bold, italic, and underline.

For a comparison of various modules in this category, see here.

The Answer 13

7 people think this answer is useful

There are two ways to look at changing colors for a Node.js console today.

One is through general-purpose libraries that can decorate a text string with color tags, which you then output through the standard console.log.

The top libraries for that today:

And the other way – patching the existing console methods. One such library – manakin lets you automatically set standard colors for all your console methods (log, warn, error and info).

One significant difference from the generic color libraries – it can set colors either globally or locally, while keeping consistent syntax and output format for every Node.js console method, which you then use without having to specify the colors, as they are all set automatically.

I had to change the console background color to white because of eye problems, but the font is gray colored and it makes the messages unreadable. How can I change it?

Specifically for your problem, here’s the simplest solution:

var con = require('manakin').global;
con.log.color = 30; // Use black color for console.log

It will set black color for every console.log call in your application. See more color codes.

Default colors as used by manakin:

enter image description here

The Answer 14

7 people think this answer is useful

I overloaded the console methods.

var colors={
Reset: "\x1b[0m",
Red: "\x1b[31m",
Green: "\x1b[32m",
Yellow: "\x1b[33m"
};

var infoLog = console.info;
var logLog = console.log;
var errorLog = console.error;
var warnLog = console.warn;

console.info= function(args)
{
    var copyArgs = Array.prototype.slice.call(arguments);
    copyArgs.unshift(colors.Green);
    copyArgs.push(colors.Reset);
    infoLog.apply(null,copyArgs);
};

console.warn= function(args)
{
    var copyArgs = Array.prototype.slice.call(arguments);
    copyArgs.unshift(colors.Yellow);
    copyArgs.push(colors.Reset);
    warnLog.apply(null,copyArgs);
};
console.error= function(args)
{
    var copyArgs = Array.prototype.slice.call(arguments);
    copyArgs.unshift(colors.Red);
    copyArgs.push(colors.Reset);
    errorLog.apply(null,copyArgs);
};

// examples
console.info("Numeros",1,2,3);
console.warn("pares",2,4,6);
console.error("reiniciandooo");

The output is.

enter image description here

The Answer 15

6 people think this answer is useful

Came across this question, and wanted to use some colors on stdout without any dependencies. This combines some of the other great answers here.

Here’s what I’ve got. (Requires node v4 or greater)

// colors.js
const util = require('util')

function colorize (color, text) {
  const codes = util.inspect.colors[color]
  return `\x1b[${codes[0]}m${text}\x1b[${codes[1]}m`
}

function colors () {
  let returnValue = {}
  Object.keys(util.inspect.colors).forEach((color) => {
    returnValue[color] = (text) => colorize(color, text)
  })
  return returnValue
}

module.exports = colors()

Just require the file, then use it like so:

const colors = require('./colors')
console.log(colors.green("I'm green!"))

The predefinied color codes are available here

The Answer 16

6 people think this answer is useful

This somewhat depends on what platform you are on. The most common way to do this is by printing ANSI escape sequences. For a simple example, here’s some python code from the blender build scripts:

// This is a object for use ANSI escape to color the text in the terminal
const bColors = {
    HEADER    : '\033[95m',
    OKBLUE    : '\033[94m',
    OKGREEN   : '\033[92m',
    WARNING   : '\033[93m',
    FAIL      : '\033[91m',
    ENDC      : '\033[0m', 
    BOLD      : '\033[1m',   
    UNDERLINE : '\033[4m'
}

To use code like this, you can do something like

console.log(`${bColors.WARNING} My name is sami ${bColors.ENDC}`)

The Answer 17

5 people think this answer is useful

I don’t want any dependency for this and only these worked for me on OS X. All other samples from answers here gave me Octal literal errors.

Reset = "\x1b[0m"
Bright = "\x1b[1m"
Dim = "\x1b[2m"
Underscore = "\x1b[4m"
Blink = "\x1b[5m"
Reverse = "\x1b[7m"
Hidden = "\x1b[8m"

FgBlack = "\x1b[30m"
FgRed = "\x1b[31m"
FgGreen = "\x1b[32m"
FgYellow = "\x1b[33m"
FgBlue = "\x1b[34m"
FgMagenta = "\x1b[35m"
FgCyan = "\x1b[36m"
FgWhite = "\x1b[37m"

BgBlack = "\x1b[40m"
BgRed = "\x1b[41m"
BgGreen = "\x1b[42m"
BgYellow = "\x1b[43m"
BgBlue = "\x1b[44m"
BgMagenta = "\x1b[45m"
BgCyan = "\x1b[46m"
BgWhite = "\x1b[47m"

source: https://coderwall.com/p/yphywg/printing-colorful-text-in-terminal-when-run-node-js-script

The Answer 18

4 people think this answer is useful

paint-console

Simple colorable log. Support inspect objects and single line update This package just repaint console.

install

npm install paint-console

usage

require('paint-console');

console.info('console.info();');
console.warn('console.warn();');
console.error('console.error();');
console.log('console.log();');

demo

The Answer 19

4 people think this answer is useful

I found this answer above (https://stackoverflow.com/a/41407246/4808079) very useful, but incomplete. If you only ever wanted to color something once, I guess it’d be fine, but I think sharing it in a runnable functional form is much more applicable to real life use cases.

const Color = {
  Reset: "\x1b[0m",
  Bright: "\x1b[1m",
  Dim: "\x1b[2m",
  Underscore: "\x1b[4m",
  Blink: "\x1b[5m",
  Reverse: "\x1b[7m",
  Hidden: "\x1b[8m",

  FgBlack: "\x1b[30m",
  FgRed: "\x1b[31m",
  FgGreen: "\x1b[32m",
  FgYellow: "\x1b[33m",
  FgBlue: "\x1b[34m",
  FgMagenta: "\x1b[35m",
  FgCyan: "\x1b[36m",
  FgWhite: "\x1b[37m",

  BgBlack: "\x1b[40m",
  BgRed: "\x1b[41m",
  BgGreen: "\x1b[42m",
  BgYellow: "\x1b[43m",
  BgBlue: "\x1b[44m",
  BgMagenta: "\x1b[45m",
  BgCyan: "\x1b[46m",
  BgWhite: "\x1b[47m"
}

function colorString(color, string) {
  return `${color}${string}${Color.Reset}`;
}

function colorStringLog(color, string) {
  console.log(colorString(color, string));
}

Use it like this:

colorStringLog(Color.FgYellow, "Some Yellow text to console log");

console.log([
  colorString(Color.FgRed, "red"),
  colorString(Color.FgGreen, "green"),
  colorString(Color.FgBlue, "blue"),
].join(", "));

The Answer 20

4 people think this answer is useful
var colorSet = {
    Reset: "\x1b[0m",
    Red: "\x1b[31m",
    Green: "\x1b[32m",
    Yellow: "\x1b[33m",
    Blue: "\x1b[34m",
    Magenta: "\x1b[35m"
};

var funcNames = ["info", "log", "warn", "error"];
var colors = [colorSet.Green, colorSet.Blue, colorSet.Yellow, colorSet.Red];

for (var i = 0; i < funcNames.length; i++) {
    let funcName = funcNames[i];
    let color = colors[i];
    let oldFunc = console[funcName];
    console[funcName] = function () {
        var args = Array.prototype.slice.call(arguments);
        if (args.length) {
            args = [color + args[0]].concat(args.slice(1), colorSet.Reset);
        }
        oldFunc.apply(null, args);
    };
}

// Test:
console.info("Info is green.");
console.log("Log is blue.");
console.warn("Warn is orange.");
console.error("Error is red.");
console.info("--------------------");
console.info("Formatting works as well. The number = %d", 123);

The Answer 21

4 people think this answer is useful

logger/index.js

const colors = {
    Reset : "\x1b[0m",
    Bright : "\x1b[1m",
    Dim : "\x1b[2m",
    Underscore : "\x1b[4m",
    Blink : "\x1b[5m",
    Reverse : "\x1b[7m",
    Hidden : "\x1b[8m",

    FgBlack : "\x1b[30m",
    FgRed : "\x1b[31m",
    FgGreen : "\x1b[32m",
    FgYellow : "\x1b[33m",
    FgBlue : "\x1b[34m",
    FgMagenta : "\x1b[35m",
    FgCyan : "\x1b[36m",
    FgWhite : "\x1b[37m",

    BgBlack : "\x1b[40m",
    BgRed : "\x1b[41m",
    BgGreen : "\x1b[42m",
    BgYellow : "\x1b[43m",
    BgBlue : "\x1b[44m",
    BgMagenta : "\x1b[45m",
    BgCyan : "\x1b[46m",
    BgWhite : "\x1b[47m",
};

module.exports = () => {
    Object.keys(colors).forEach(key => {
        console['log' + key] = (strg) => {
            if(typeof strg === 'object') strg = JSON.stringify(strg, null, 4);
            return console.log(colors[key]+strg+'\x1b[0m');
        }
    });
}

app.js

require('./logger')();

Then use it like:

console.logBgGreen(" grüner Hintergrund ")

The Answer 22

3 people think this answer is useful

I created my own module, StyleMe. I made it so I can do much with little typing. Example:

var StyleMe = require('styleme');
StyleMe.extend() // extend the string prototype

console.log("gre{Hello} blu{world}!".styleMe()) // Logs hello world! with 'hello' being green, and 'world' being blue with '!' being normal.

It can also be nested:

console.log("This is normal red{this is red blu{this is blue} back to red}".styleMe())

Or, if you dont want to extend the string prototype, you can just any of the 3 other options:

console.log(styleme.red("a string"))
console.log("Hello, this is yellow text".yellow().end())
console.log(styleme.style("some text","red,bbl"))

The Answer 23

3 people think this answer is useful

You can also use colorworks.

Usage:

var cw = require('colorworks').create();
console.info(cw.compile('[[red|Red message with a [[yellow|yellow]] word.]]'));

To make life easier, you can also make a function with it.

function say(msg) {
  console.info(cw.compile(msg));
}

Now you can do:

say(`[[yellow|Time spent: [[green|${time}]]ms.]]`);

The Answer 24

2 people think this answer is useful

Coolors

It’s pretty good for use or extend. You can use simply:

var coolors = require('coolors');
console.log(coolors('My cool console log', 'red'));

Or with config:

var coolors = require('coolors');
console.log(coolors('My cool console log', {
   text: 'yellow',
   background: 'red',
   bold: true,
   underline: true,
   inverse: true,
   strikethrough: true
}));

And seems really funny to extend:

var coolors = require('coolors');
function rainbowLog(msg){
    var colorsText = coolors.availableStyles().text;
    var rainbowColors = colorsText.splice(3);
    var lengthRainbowColors = rainbowColors.length;
    var msgInLetters = msg.split('');
    var rainbowEndText = '';
    var i = 0;
    msgInLetters.forEach(function(letter){
        if(letter != ' '){
            if(i === lengthRainbowColors) i = 0;
            rainbowEndText += coolors(letter, rainbowColors[i]);
            i++;
        }else{
            rainbowEndText += ' ';
        }
    });
    return rainbowEndText;
}
coolors.addPlugin('rainbow', rainbowLog);
console.log(coolorsExtended('This its a creative example extending core with a cool rainbown style', 'rainbown'));

View Coolors module

The Answer 25

2 people think this answer is useful

2017:

Simple way, adding time color to the message, you don’t need to change your code, use keep your console.log(‘msg’) or console.err(‘error’)

var clc = require("cli-color");
var mapping = {
  log: clc.blue,
  warn: clc.yellow,
  error: clc.red
};

["log", "warn", "error"].forEach(function(method) {
  var oldMethod = console[method].bind(console);
  console[method] = function() {
    oldMethod.apply(
      console,
      [mapping[method](new Date().toISOString())]
      .concat(arguments)
    );
  };
});

enter image description here

The Answer 26

1 people think this answer is useful

In ubuntu you can simply use color codes:

var sys = require('sys');
process.stdout.write("x1B[31m" + your_message_in_red + "\x1B[0m\r\n");

The Answer 27

1 people think this answer is useful

node-colorify

Provides functions to print texts in color and also to do text formatting such as bold, blink, etc..

The Answer 28

1 people think this answer is useful

I really liked @Daniel’s answer, but the console.log{color} functions didn’t work the same way as regular console.log. I have made a few changes, and now all parameters to the new functions will be passed to console.log (as well as the color codes).

const _colors = {
    Reset : "\x1b[0m",
    Bright : "\x1b[1m",
    Dim : "\x1b[2m",
    Underscore : "\x1b[4m",
    Blink : "\x1b[5m",
    Reverse : "\x1b[7m",
    Hidden : "\x1b[8m",

    FgBlack : "\x1b[30m",
    FgRed : "\x1b[31m",
    FgGreen : "\x1b[32m",
    FgYellow : "\x1b[33m",
    FgBlue : "\x1b[34m",
    FgMagenta : "\x1b[35m",
    FgCyan : "\x1b[36m",
    FgWhite : "\x1b[37m",

    BgBlack : "\x1b[40m",
    BgRed : "\x1b[41m",
    BgGreen : "\x1b[42m",
    BgYellow : "\x1b[43m",
    BgBlue : "\x1b[44m",
    BgMagenta : "\x1b[45m",
    BgCyan : "\x1b[46m",
    BgWhite : "\x1b[47m",
};

const enableColorLogging = function(){
    Object.keys(_colors).forEach(key => {
        console['log' + key] = function(){
            return console.log(_colors[key], ...arguments, _colors.Reset);
        }
    });
}

The Answer 29

0 people think this answer is useful

If you are using Windows CMD then go to the terminal Properties/Colors (CMD top left) and then redefine the RGB value of the offensive color. In my case I believe it’s the fifth color square from the left, which I changed to (222,222,222). It does not matter if the currently selected radio button shows Screen Text or Screen Background as you just redefine that specific “system” color. Once you changed the color don’t forget to select back the preferred color for the background or text before clicking OK.

After the change all these reddish messages from Node (Ember in my case) are clearly visible.

The Answer 30

0 people think this answer is useful

This is an approach for Windows 10 (maybe for 7) and it changes the color scheme (theme) for cmd, npm terminal itself, not only console output for a particular app.

I found the working Windows plugin – Color Tool, which is presumably developed under Windows umbrella. A description is available at the link.

I added colortool directory into system environment path variable and now it is available whenever I start terminal (NodeJs command prompt, cmd).

Add a Comment