Ho dovuto cambiare il colore di sfondo della console in bianco a causa di problemi agli occhi, ma il carattere è di colore grigio e rende i messaggi illeggibili. Come posso cambiarlo?

Di seguito puoi trovare i colori di riferimento del testo da comandare durante l'esecuzione dell'applicazione node.js:

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

Nota %sè dove viene iniettato nella stringa (il secondo argomento). \x1b[0mreimposta il colore del terminale in modo che non continui più a essere il colore scelto dopo questo punto.

Riferimento colori

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"

MODIFICARE:

Ad esempio, \x1b[31mè una sequenza di escape che verrà intercettata dal terminale e gli imporrà di passare al colore rosso. In realtà, \x1bè il codice per il carattere di controllo non stampabile escape . Le sequenze di escape che si occupano solo di colori e stili sono anche conosciute come codice di escape ANSI e sono standardizzate, quindi dovrebbero (dovrebbero) funzionare su qualsiasi piattaforma.

Wikipedia ha un bel confronto su come i diversi terminali visualizzano i colori https://en.wikipedia.org/wiki/ANSI_escape_code#Colors

Sono disponibili più pacchetti per la formattazione del testo della console in Node.js. I più popolari sono:

• chalk
• cli-color
• colors
  
  

Uso:

GESSO:

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

CLI-COLOR:

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

COLORI:

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

Molte persone hanno notato la loro disapprovazione per l' colorsalterazione del prototipo String . Se preferisci che i tuoi prototipi vengano lasciati soli, utilizza invece il codice seguente:

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

Se vuoi cambiare i colori direttamente da solo senza un modulo, prova

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

Innanzitutto \x1b[36mper cambiare i colori 36e poi tornare al colore terminale 0.

Ecco un elenco di codici colore ANSI

per colorare il tuo output Puoi usare esempi da lì:
https://help.ubuntu.com/community/CustomizingBashPrompt

Anche un Gist per nodeJs

Ad esempio, se vuoi che parte del testo sia di colore rosso, esegui semplicemente console.log con:

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

Sulla base di questo ho creato l'estensione "colog" per Node.js. Puoi installarlo usando:

npm install colog

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

Questo è un elenco di colori disponibili (sfondo, primo piano) nella console con le azioni disponibili (ripristino, inversione, ...).

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

Usalo come segue:

 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

Puoi anche installare:

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

L'IT ti darà un output più vicino alla console del lato client:

Per questa documentazione , è possibile modificare i colori in base al tipo di dati dell'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 ] }

Questi sembrano essere codici di escape ANSI SGR, in cui il primo numero è il codice da emettere prima dell'output e il secondo numero è il codice da emettere dopo. Quindi, se guardiamo la tabella dei codici ANSI SGR su Wikipedia , vedrai che la maggior parte di questi inizia con un numero 30-37 per impostare il colore di primo piano e termina con 39 per ripristinare il colore di primo piano predefinito.

Quindi una cosa che non mi piace è quanto siano oscuri alcuni di questi. Soprattutto le date. Vai avanti e prova new Date()nella console. Il magenta scuro su nero è davvero difficile da leggere. Sostituiamolo invece con un magenta chiaro.

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

Adesso quando ci provi new Date() , l'output è molto più leggibile.

Se desideri impostare i colori automaticamente all'avvio del nodo, crea uno script che avvii il sostituto, in questo modo:

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

Salvare questo file (ad esempio, init.js), quindi eseguirenode.exe init.js . Imposta i colori e avvia il prompt dei comandi di node.js.

(Grazie a loganfsmyth in questa risposta per l'idea di sostituzione .)

Questa libreria di Sindre Sorhus è la migliore al momento:

gesso

• Altamente performante
• Non si estende String.prototype
• API espressiva
• Capacità di nidificare gli stili
• Pulito e concentrato
• Rileva automaticamente il supporto del colore
• Mantenuto attivamente
• Utilizzato da oltre 5500 moduli

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"

Ad esempio, se vuoi avere un testo fioco, rosso con sfondo blu, puoi farlo in Javascript in questo modo:

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

L'ordine dei colori e degli effetti sembra non essere così importante, ma ricorda sempre di ripristinare i colori e gli effetti alla fine.

Un pratico one-liner che ho scritto per gli script npm che non possono avere dipendenze:

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

Modifica: r,g,b,w,c,m,y,k sta per rosso, verde, blu, bianco, ciano, magenta, giallo e blac (k)

emoji

Puoi usare i colori per il testo come altri citati nelle loro risposte.

Puoi invece usare gli emoji ! ad esempio è possibile utilizzare È possibile utilizzare ⚠️per i messaggi di avviso e 🛑per i messaggi di errore.

O semplicemente usa questi taccuini come colore:

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

Bonus:

Questo metodo ti aiuta anche a scansionare e trovare rapidamente i log direttamente nel codice sorgente .

_{Ma il carattere emoji predefinito di Linux non è colorato per impostazione predefinita e potresti voler renderli colorati, prima.}

Per una popolare alternativa ai colori che non interferisce con i metodi integrati dell'oggetto String, ti consiglio di dare un'occhiata a cli-color .

Include sia colori che stili concatenabili come grassetto, corsivo e sottolineato.

Per un confronto di vari moduli in questa categoria, vedere qui .

Nessuna libreria, nessuna complicazione, semplicemente:

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

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

Esistono due modi per esaminare la modifica dei colori per una console Node.js oggi.

Uno è attraverso le librerie di uso generale che possono decorare una stringa di testo con tag di colore, che vengono quindi emessi attraverso lo standard console.log .

Le migliori librerie per questo oggi:

• gesso
• colori
• cli-color

E dall'altra parte: applicare patch ai metodi della console esistenti. Uno di questi biblioteca - manakin consente di impostare automaticamente i colori standard per tutti i vostri metodi di console ( log, warn, errore info).

Una differenza significativa rispetto alle librerie di colori generiche: può impostare i colori a livello globale o locale, mantenendo la sintassi e il formato di output coerenti per ogni metodo della console Node.js, che viene quindi utilizzato senza dover specificare i colori, poiché sono tutti impostati automaticamente .

Ho dovuto cambiare il colore di sfondo della console in bianco a causa di problemi agli occhi, ma il carattere è di colore grigio e rende i messaggi illeggibili. Come posso cambiarlo?

Specificamente per il tuo problema, ecco la soluzione più semplice:

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

Imposta il colore nero per ogni console.logchiamata nella tua applicazione. Vedi più codici colore .

Colori predefiniti utilizzati da manakin :

Ho sovraccaricato i metodi della 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");

L'output è.

Ho risposto a questa domanda e volevo usare alcuni colori su stdout senza dipendenze. Questo combina alcune delle altre grandi risposte qui.

Ecco cosa ho. (Richiede il nodo v4 o superiore)

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

Basta richiedere il file, quindi usarlo in questo modo:

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

I codici colore predefiniti sono disponibili qui

paint-console

Registro colorabile semplice. Supporto ispeziona oggetti e aggiornamento a riga singola Questo pacchetto ridisegna la console.

installare

npm install paint-console

uso

require('paint-console');

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

dimostrazione

Non voglio alcuna dipendenza per questo e solo questi hanno funzionato per me su OS X. Tutti gli altri esempi dalle risposte qui mi hanno dato Octal literalerrori.

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"

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

Ho trovato questa risposta sopra ( https://stackoverflow.com/a/41407246/4808079 ) molto utile, ma incompleta. Se hai mai desiderato colorare qualcosa una volta, credo che andrebbe bene, ma penso che condividerlo in una forma funzionale eseguibile sia molto più applicabile ai casi d'uso della vita reale.

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

Usalo in questo modo:

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

Quindi usalo come:

console.logBgGreen(" grüner Hintergrund ")

Questo dipende in qualche modo dalla piattaforma su cui ti trovi. Il modo più comune per farlo è stampare le sequenze di escape ANSI. Per un semplice esempio, ecco un po 'di codice Python dagli script di build di 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'
}

Per usare un codice come questo, puoi fare qualcosa del genere

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

Puoi anche usare colorworks .

Uso:

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

Per semplificare la vita, puoi anche fare una funzione con essa.

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

Ora puoi fare:

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

Coolors

È abbastanza buono per l'uso o l'estensione. Puoi usare semplicemente:

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

O con la configurazione:

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

E sembra davvero divertente estendere:

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

Visualizza il modulo Coolors

Ho creato il mio modulo, StyleMe . L'ho fatto in modo da poter fare molto con una piccola digitazione. Esempio:

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.

Può anche essere nidificato:

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

In alternativa, se non si desidera estendere il prototipo di stringa, è possibile utilizzare solo una delle altre 3 opzioni:

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

In Ubuntu puoi semplicemente usare i codici colore:

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

nodo Colorazione

Fornisce funzioni per stampare testi a colori e anche per formattare testi come grassetto, lampeggio, ecc.

Mi è piaciuta molto la risposta di Daniel, ma le funzioni console.log {color} non hanno funzionato allo stesso modo della console.log normale. Ho apportato alcune modifiche e ora tutti i parametri delle nuove funzioni verranno passati a console.log (così come i codici colore).

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:

Modo semplice, aggiungendo il colore dell'ora al messaggio, non è necessario modificare il codice, utilizzare keep console.log ('msg') o console.err ('errore')

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

Se si utilizza Windows CMD, andare al terminale Proprietà / Colori (CMD in alto a sinistra) e quindi ridefinire il valore RGB del colore offensivo. Nel mio caso credo che sia il quinto quadrato di colore da sinistra, che ho cambiato in (222.222.222). Non importa se il pulsante di opzione attualmente selezionato mostra Testo dello schermo o Sfondo dello schermo mentre si ridefinisce il colore specifico del "sistema". Una volta modificato il colore, non dimenticare di selezionare nuovamente il colore preferito per lo sfondo o il testo prima di fare clic su OK.

Dopo la modifica, tutti questi messaggi rossastri da Nodo (Ember nel mio caso) sono chiaramente visibili.

Questo è un approccio per Windows 10 (forse per 7) e cambia la combinazione di colori (tema) per cmd, il terminale npm stesso, non solo l'output della console per una particolare app.

Ho trovato il plug-in di Windows funzionante - Color Tool , che è presumibilmente sviluppato sotto l'ombrello di Windows. Una descrizione è disponibile al link .

Ho aggiunto la directory colortool nella variabile di percorso dell'ambiente di sistema e ora è disponibile ogni volta che avvio terminal (prompt dei comandi di NodeJs, cmd).