J'ai dû changer la couleur d'arrière-plan de la console en blanc à cause de problèmes oculaires, mais la police est de couleur grise et cela rend les messages illisibles. Comment puis-je le changer?

Vous trouverez ci-dessous la référence des couleurs du texte à commander lors de l'exécution de l'application node.js:

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

La note %sest l'endroit où dans la chaîne (le deuxième argument) est injecté. \x1b[0mréinitialise la couleur du terminal afin qu'elle ne continue plus d'être la couleur choisie après ce point.

Référence des couleurs

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"

ÉDITER:

Par exemple, \x1b[31mest une séquence d'échappement qui sera interceptée par votre terminal et lui demandera de passer à la couleur rouge. En fait, \x1bc'est le code du caractère de contrôle non imprimable escape . Les séquences d'échappement traitant uniquement des couleurs et des styles sont également connues sous le nom de code d'échappement ANSI et sont standardisées, elles doivent donc (devraient) fonctionner sur n'importe quelle plate-forme.

Wikipedia a une belle comparaison de la façon dont les différents terminaux affichent les couleurs https://en.wikipedia.org/wiki/ANSI_escape_code#Colors

Plusieurs packages sont disponibles pour formater le texte de la console dans Node.js. Les plus populaires sont:

• chalk
• cli-color
• colors
  
  

Usage:

CRAIE:

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

COULEUR CLI:

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

COULEURS:

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

Beaucoup de gens ont noté leur désapprobation de la colorsmodification du prototype String . Si vous préférez que vos prototypes soient laissés seuls, utilisez plutôt le code suivant:

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

Si vous voulez changer les couleurs directement sans module, essayez

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

Commencez \x1b[36mpar changer les couleurs 36, puis revenez à la couleur du terminal0 .

Voici une liste des codes de couleur ANSI

pour colorer votre sortie Vous pouvez utiliser des exemples à partir de là:
https://help.ubuntu.com/community/CustomizingBashPrompt

Aussi un Gist pour nodeJs

Par exemple, si vous voulez une partie du texte en rouge, faites simplement console.log avec:

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

Sur cette base, j'ai créé l'extension "colog" pour Node.js. Vous pouvez l'installer en utilisant:

npm install colog

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

Il s'agit d'une liste des couleurs disponibles (fond, premier plan) dans la console avec les actions disponibles (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"
 }
};

Utilisez-le comme suit:

 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

Vous pouvez également installer:

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

L'informatique vous donnera une sortie plus proche de la console côté client:

Selon cette documentation , vous pouvez modifier les couleurs en fonction du type de données de la sortie:

// 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 ] }

Ceux-ci semblent être des codes d'échappement ANSI SGR, où le premier numéro est le code à émettre avant la sortie, et le deuxième numéro est le code à émettre après. Donc, si nous regardons le tableau des codes ANSI SGR sur Wikipedia , vous verrez que la plupart d'entre eux commencent par un nombre 30-37 pour définir la couleur de premier plan et se terminent par 39 pour réinitialiser la couleur de premier plan par défaut.

Donc, une chose que je n'aime pas, c'est la noirceur de certains d'entre eux. Surtout les dates. Allez-y et essayez new Date()dans la console. Le magenta foncé sur le noir est vraiment difficile à lire. Modifions cela à un magenta clair à la place.

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

Maintenant, quand vous essayez new Date() , la sortie est beaucoup plus lisible.

Si vous souhaitez définir automatiquement les couleurs lors du lancement du nœud, créez un script qui lance la repl, comme ceci:

// 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({});

Enregistrez ce fichier (par exemple, init.js), puis exécuteznode.exe init.js . Il définira les couleurs et lancera l'invite de commande node.js.

(Merci à loganfsmyth dans cette réponse pour l'idée de repl.)

Cette bibliothèque de Sindre Sorhus est la meilleure du moment:

craie

• Très performant
• Ne s'étend pas String.prototype
• API expressive
• Possibilité d'imbriquer des styles
• Propre et concentré
• Détecte automatiquement la prise en charge des couleurs
• Maintenu activement
• Utilisé par plus de 5500 modules

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"

Par exemple, si vous voulez avoir un texte Dim, rouge avec un fond bleu, vous pouvez le faire en Javascript comme ceci:

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

L'ordre des couleurs et des effets ne semble pas si important, mais n'oubliez pas de réinitialiser les couleurs et les effets à la fin.

Un one-liner pratique que j'ai écrit pour les scripts npm qui ne peuvent pas avoir de dépendances:

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')}`)

Modifier: r,g,b,w,c,m,y,k signifie rouge, vert, bleu, blanc, cyan, magenta, jaune et noir (k)

Emoji

Vous pouvez utiliser des couleurs pour le texte comme d'autres mentionnées dans leurs réponses.

Mais vous pouvez utiliser des emojis à la place! par exemple, vous pouvez utiliser Vous pouvez utiliser ⚠️pour les messages d'avertissement et les messages 🛑d'erreur.

Ou utilisez simplement ces carnets comme couleur:

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

Prime:

Cette méthode vous aide également à analyser rapidement et à trouver des journaux directement dans le code source .

_{Mais la police emoji par défaut de linux n'est pas colorée par défaut et vous pouvez d'abord les rendre colorées.}

Pour une alternative populaire aux couleurs qui ne dérange pas avec les méthodes intégrées de l'objet String, je recommande de vérifier cli-color .

Inclut les couleurs et les styles chaînables tels que gras, italique et souligné.

Pour une comparaison des différents modules de cette catégorie, voir ici .

Pas de bibliothèques, pas de complications, tout simplement:

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

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

Il y a deux façons de regarder les couleurs changeantes pour une console Node.js aujourd'hui.

La première consiste à utiliser des bibliothèques à usage général qui peuvent décorer une chaîne de texte avec des balises de couleur, que vous sortez ensuite via la norme console.log .

Les meilleures bibliothèques pour cela aujourd'hui:

• craie
• couleurs
• cli-color

Et dans l'autre sens - patcher les méthodes de console existantes. Une telle bibliothèque - manakin vous permet de définir automatiquement les couleurs standard pour toutes les méthodes de la console ( log, warn, erroret info).

Une différence significative par rapport aux bibliothèques de couleurs génériques - il peut définir des couleurs globalement ou localement, tout en conservant une syntaxe et un format de sortie cohérents pour chaque méthode de console Node.js, que vous utilisez ensuite sans avoir à spécifier les couleurs, car elles sont toutes définies automatiquement .

J'ai dû changer la couleur d'arrière-plan de la console en blanc à cause de problèmes oculaires, mais la police est de couleur grise et cela rend les messages illisibles. Comment puis-je le changer?

Spécifiquement pour votre problème, voici la solution la plus simple:

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

Il définira la couleur noire pour chaque console.logappel dans votre application. Voir plus de codes couleurs .

Couleurs par défaut utilisées par manakin :

J'ai surchargé les méthodes de la console.

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

La sortie est.

Je suis tombé sur cette question et je voulais utiliser des couleurs sur stdout sans aucune dépendance. Cela combine certaines des autres grandes réponses ici.

Voici ce que j'ai. (Nécessite le nœud v4 ou supérieur)

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

Exigez simplement le fichier, puis utilisez-le comme ceci:

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

Les codes couleurs prédéfinis sont disponibles ici

console de peinture

Journal à colorier simple. Prise en charge de l'inspection des objets et de la mise à jour sur une seule ligne Ce package repeint simplement la console.

installer

npm install paint-console

usage

require('paint-console');

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

démo

Je ne veux aucune dépendance pour cela et seuls ceux-ci ont fonctionné pour moi sur OS X. Tous les autres exemples de réponses ici m'ont donné des Octal literalerreurs.

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

J'ai trouvé cette réponse ci-dessus ( https://stackoverflow.com/a/41407246/4808079 ) très utile, mais incomplète. Si vous ne souhaitiez colorier quelque chose qu'une seule fois, je suppose que ce serait bien, mais je pense que le partager sous une forme fonctionnelle exécutable est beaucoup plus applicable aux cas d'utilisation réels.

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

Utilisez-le comme ceci:

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

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

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

Ensuite, utilisez-le comme:

console.logBgGreen(" grüner Hintergrund ")

Cela dépend quelque peu de la plateforme sur laquelle vous vous trouvez. La façon la plus courante de procéder consiste à imprimer des séquences d'échappement ANSI. Pour un exemple simple, voici du code python des scripts de construction de blender:

// 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'
}

Pour utiliser un code comme celui-ci, vous pouvez faire quelque chose comme

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

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

Vous pouvez également utiliser Colorworks .

Usage:

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

Pour vous faciliter la vie, vous pouvez également créer une fonction avec.

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

Vous pouvez maintenant faire:

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

Refroidisseurs

Il est assez bon à utiliser ou à étendre. Vous pouvez utiliser simplement:

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

Ou avec config:

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

Et semble vraiment drôle à étendre:

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

Voir le module Coolors

J'ai créé mon propre module, StyleMe . Je l'ai fait pour que je puisse faire beaucoup avec peu de frappe. Exemple:

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.

Il peut également être imbriqué:

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

Ou, si vous ne souhaitez pas étendre le prototype de chaîne, vous pouvez simplement choisir l'une des 3 autres options:

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

Dans ubuntu, vous pouvez simplement utiliser des codes de couleur:

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

node-colorify

Fournit des fonctions pour imprimer des textes en couleur et également pour effectuer un formatage de texte tel que gras, clignotant, etc.

J'ai vraiment aimé la réponse de @ Daniel, mais les fonctions console.log {color} ne fonctionnaient pas de la même manière que console.log classique. J'ai apporté quelques modifications, et maintenant tous les paramètres des nouvelles fonctions seront passés à console.log (ainsi que les codes de couleur).

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

2017:

De façon simple, en ajoutant de la couleur temporelle au message, vous n'avez pas besoin de changer votre code, utilisez keep your console.log ('msg') ou 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)
    );
  };
});

Si vous utilisez Windows CMD, accédez aux Propriétés / Couleurs du terminal (CMD en haut à gauche), puis redéfinissez la valeur RVB de la couleur offensive. Dans mon cas, je crois que c'est le cinquième carré de couleur à partir de la gauche, que j'ai changé en (222,222,222). Peu importe si le bouton radio actuellement sélectionné affiche Texte d'écran ou Arrière-plan d'écran, car vous redéfinissez simplement cette couleur "système" spécifique. Une fois que vous avez changé la couleur, n'oubliez pas de sélectionner de nouveau la couleur préférée pour l'arrière-plan ou le texte avant de cliquer sur OK.

Après le changement, tous ces messages rougeâtres de Node (Ember dans mon cas) sont clairement visibles.

Il s'agit d'une approche pour Windows 10 (peut-être pour 7) et elle change le schéma de couleurs (thème) pour cmd, le terminal npm lui-même, pas seulement la sortie de la console pour une application particulière.

J'ai trouvé le plugin Windows fonctionnel - Color Tool , qui est probablement développé sous l'égide de Windows. Une description est disponible sur le lien .

J'ai ajouté le répertoire colortool dans la variable de chemin de l'environnement système et maintenant il est disponible chaque fois que je démarre le terminal (invite de commande NodeJs, cmd).