Ich musste die Hintergrundfarbe der Konsole aufgrund von Augenproblemen in Weiß ändern, aber die Schrift ist grau und macht die Nachrichten unlesbar. Wie kann ich das ändern?

Unten finden Sie die Farbreferenz des zu befehlenden Textes beim Ausführen der Anwendung node.js:

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

Beachten Sie, %swo in die Zeichenfolge (das zweite Argument) eingefügt wird. \x1b[0mSetzt die Terminalfarbe zurück, sodass sie nach diesem Zeitpunkt nicht mehr die gewählte Farbe ist.

Farbreferenz

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"

BEARBEITEN:

Dies ist beispielsweise \x1b[31meine Escape-Sequenz , die von Ihrem Terminal abgefangen wird und es anweist, auf die rote Farbe umzuschalten. In der Tat \x1bist der Code für das nicht druckbare Steuerzeichen escape . Escape-Sequenzen, die sich nur mit Farben und Stilen befassen, werden auch als ANSI-Escape-Code bezeichnet und sind standardisiert. Daher sollten (sollten) sie auf jeder Plattform funktionieren.

Wikipedia hat einen schönen Vergleich, wie verschiedene Terminals Farben anzeigen https://en.wikipedia.org/wiki/ANSI_escape_code#Colors

In Node.js stehen mehrere Pakete zum Formatieren von Konsolentext zur Verfügung. Die beliebtesten sind:

• chalk
• cli-color
• colors
  
  

Verwendungszweck:

KREIDE:

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

CLI-FARBE:

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

FARBEN:

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

Viele Leute haben ihre Ablehnung der colorsÄnderung des String-Prototyps bemerkt . Wenn Sie es vorziehen, Ihre Prototypen in Ruhe zu lassen, verwenden Sie stattdessen den folgenden Code:

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

Wenn Sie die Farben ohne Modul direkt selbst ändern möchten, versuchen Sie es

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

Zuerst \x1b[36mdie Farben zu ändern , 36und dann zurück zum Terminal Farbe 0.

Hier ist eine Liste der ANSI-Farbcodes

So färben Sie Ihre Ausgabe ein Von dort aus können Sie Beispiele verwenden:
https://help.ubuntu.com/community/CustomizingBashPrompt

Auch ein Gist für NodeJs

Wenn Sie beispielsweise einen Teil des Textes in roter Farbe wünschen, führen Sie einfach console.log aus mit:

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

Basierend darauf habe ich die Erweiterung "colog" für Node.js erstellt. Sie können es installieren mit:

npm install colog

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

Dies ist eine Liste der verfügbaren Farben (Hintergrund, Vordergrund) in der Konsole mit verfügbaren Aktionen (Zurücksetzen, Umkehren, ...).

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

Verwenden Sie es wie folgt:

 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

Sie können auch installieren:

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

Die IT gibt Ihnen eine Ausgabe, die näher an der Konsole der Client-Seite liegt:

Gemäß dieser Dokumentation können Sie die Farben basierend auf dem Datentyp der Ausgabe ändern:

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

Dies scheinen ANSI SGR-Escape-Codes zu sein, wobei die erste Nummer der Code ist, der vor der Ausgabe ausgegeben werden soll, und die zweite Nummer der Code ist, nach dem ausgegeben werden soll. Wenn wir uns also das Diagramm der ANSI-SGR-Codes auf Wikipedia ansehen , werden Sie feststellen, dass die meisten mit einer Zahl 30-37 beginnen, um die Vordergrundfarbe festzulegen, und mit 39 enden, um auf die Standardvordergrundfarbe zurückzusetzen.

Eine Sache, die ich nicht mag, ist, wie dunkel einige davon sind. Besonders Daten. Versuchen Sie es new Date()in der Konsole. Dunkles Magenta auf Schwarz ist wirklich schwer zu lesen. Lassen Sie uns das stattdessen in ein helles Magenta ändern.

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

Wenn Sie es jetzt versuchen new Date(), ist die Ausgabe viel besser lesbar.

Wenn Sie beim Starten des Knotens automatisch Farben festlegen möchten, erstellen Sie ein Skript, mit dem die Antwort wie folgt gestartet wird:

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

Speichern Sie diese Datei (zum Beispiel init.js) und führen Sie sie aus node.exe init.js. Dadurch werden die Farben festgelegt und die Eingabeaufforderung node.js gestartet.

(Danke an loganfsmyth in dieser Antwort für die Repl-Idee.)

Diese Bibliothek von Sindre Sorhus ist derzeit die beste:

Kreide

• Sehr performant
• Verlängert sich nicht String.prototype
• Expressive API
• Fähigkeit, Stile zu verschachteln
• Sauber und konzentriert
• Erkennt automatisch die Farbunterstützung
• Aktiv gepflegt
• Wird von über 5500 Modulen verwendet

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"

Wenn Sie beispielsweise einen dunklen, roten Text mit blauem Hintergrund haben möchten, können Sie dies in Javascript wie folgt tun:

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

Die Reihenfolge der Farben und Effekte scheint nicht so wichtig zu sein, aber denken Sie immer daran, die Farben und Effekte am Ende zurückzusetzen.

Ein praktischer Einzeiler, den ich für npm-Skripte geschrieben habe, die keine Abhängigkeiten haben können:

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

Bearbeiten: r,g,b,w,c,m,y,k steht für Rot, Grün, Blau, Weiß, Cyan, Magenta, Gelb und Schwarz (k)

Für eine beliebte Alternative zu Farben , die sich nicht auf die integrierten Methoden des String-Objekts auswirkt , empfehle ich, cli-color zu überprüfen .

Enthält sowohl Farben als auch verkettbare Stile wie Fett, Kursiv und Unterstrichen.

Einen Vergleich verschiedener Module in dieser Kategorie finden Sie hier .

Keine Bibliotheken, keine Komplikationen, einfach:

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

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

Emoji

Sie können Farben für Text verwenden, wie andere in ihren Antworten erwähnt.

Sie können aber stattdessen Emojis verwenden! Zum Beispiel können Sie verwenden Sie können ⚠️für Warnmeldungen und 🛑für Fehlermeldungen verwenden.

Oder verwenden Sie einfach diese Notizbücher als Farbe:

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

Bonus:

Mit dieser Methode können Sie auch Protokolle direkt im Quellcode schnell scannen und finden .

_{Die Standard-Emoji-Schriftart von Linux ist jedoch standardmäßig nicht farbenfroh, und Sie möchten sie möglicherweise zuerst farbig gestalten.}

Es gibt heute zwei Möglichkeiten, die Farbänderungen für eine Node.js-Konsole zu betrachten.

Eine davon sind Allzweckbibliotheken, die eine Textzeichenfolge mit Farbetiketten dekorieren können, die Sie dann über den Standard ausgeben console.log.

Die Top-Bibliotheken dafür heute:

• Kreide
• Farben
• Cli-Farbe

Und umgekehrt - Patchen der vorhandenen Konsolenmethoden. Eine solche Bibliothek - manakin können Sie automatisch Standardfarben für alle Konsole Methoden ( log, warn, errorund info).

Ein wesentlicher Unterschied zu den generischen Farbbibliotheken: Sie können Farben entweder global oder lokal festlegen und dabei die konsistente Syntax und das Ausgabeformat für jede Node.js-Konsolenmethode beibehalten, die Sie dann verwenden, ohne die Farben angeben zu müssen, da sie alle automatisch festgelegt werden .

Ich musste die Hintergrundfarbe der Konsole aufgrund von Augenproblemen in Weiß ändern, aber die Schrift ist grau und macht die Nachrichten unlesbar. Wie kann ich das ändern?

Speziell für Ihr Problem ist hier die einfachste Lösung:

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

Bei jedem console.logAnruf in Ihrer Anwendung wird die schwarze Farbe festgelegt . Siehe mehr Farbcodes .

Standardfarben, wie sie von manakin verwendet werden :

Ich habe die Konsolenmethoden überladen.

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

Die Ausgabe ist.

Kam über diese Frage und wollte einige Farben auf stdout ohne Abhängigkeiten verwenden. Dies kombiniert einige der anderen großartigen Antworten hier.

Folgendes habe ich. (Benötigt Knoten v4 oder höher)

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

Benötigen Sie einfach die Datei und verwenden Sie sie dann wie folgt:

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

Die vordefinierten Farbcodes finden Sie hier

Farbkonsole

Einfaches färbbares Protokoll. Support Inspect Objects und Single Line Update In diesem Paket wird die Konsole nur neu gestrichen.

Installieren

npm install paint-console

Verwendungszweck

require('paint-console');

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

Demo

Ich möchte keine Abhängigkeit dafür und nur diese funktionierten für mich unter OS X. Alle anderen Beispiele aus den Antworten hier gaben mir Octal literalFehler.

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"

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

Ich fand diese Antwort oben ( https://stackoverflow.com/a/41407246/4808079 ) sehr nützlich, aber unvollständig. Wenn Sie etwas nur einmal färben wollten, wäre es wahrscheinlich in Ordnung, aber ich denke, dass das Teilen in einer ausführbaren funktionalen Form viel besser auf reale Anwendungsfälle anwendbar ist.

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

Verwenden Sie es so:

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

Dann benutze es wie folgt:

console.logBgGreen(" grüner Hintergrund ")

Dies hängt etwas davon ab, auf welcher Plattform Sie sich befinden. Der häufigste Weg, dies zu tun, ist das Drucken von ANSI-Escape-Sequenzen. Als einfaches Beispiel finden Sie hier einige Python-Codes aus den Blender-Build-Skripten:

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

Um solchen Code zu verwenden, können Sie so etwas tun

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

Sie können auch Colorworks verwenden .

Verwendungszweck:

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

Um das Leben leichter zu machen, können Sie auch eine Funktion damit machen.

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

Jetzt können Sie Folgendes tun:

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

Kühler

Es ist ziemlich gut für die Verwendung oder Erweiterung. Sie können einfach verwenden:

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

Oder mit config:

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

Und scheint wirklich lustig zu erweitern:

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

Kühlermodul anzeigen

Ich habe mein eigenes Modul StyleMe erstellt . Ich habe es geschafft, damit ich mit wenig Tippen viel anfangen kann. Beispiel:

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.

Es kann auch verschachtelt werden:

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

Wenn Sie den String-Prototyp nicht erweitern möchten, können Sie auch eine der drei anderen Optionen auswählen:

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 können Sie einfach Farbcodes verwenden:

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

Node-Colorify

Bietet Funktionen zum Drucken von Texten in Farbe und zum Formatieren von Text wie Fettdruck, Blinken usw.

Die Antwort von @ Daniel hat mir sehr gut gefallen, aber die Funktionen console.log {color} funktionierten nicht auf die gleiche Weise wie reguläres console.log. Ich habe einige Änderungen vorgenommen und jetzt werden alle Parameter für die neuen Funktionen an console.log (sowie die Farbcodes) übergeben.

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:

Wenn Sie der Nachricht auf einfache Weise Zeitfarbe hinzufügen, müssen Sie Ihren Code nicht ändern. Verwenden Sie keep your console.log ('msg') oder 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)
    );
  };
});

Wenn Sie Windows CMD verwenden, gehen Sie zu den Eigenschaften / Farben des Terminals (CMD oben links) und definieren Sie den RGB-Wert der anstößigen Farbe neu. In meinem Fall glaube ich, dass es das fünfte Farbquadrat von links ist, das ich in (222,222,222) geändert habe. Es spielt keine Rolle, ob das aktuell ausgewählte Optionsfeld Bildschirmtext oder Bildschirmhintergrund anzeigt, wenn Sie nur diese bestimmte "System" -Farbe neu definieren. Wenn Sie die Farbe geändert haben, vergessen Sie nicht, die bevorzugte Farbe für den Hintergrund oder Text auszuwählen, bevor Sie auf OK klicken.

Nach der Änderung sind alle diese rötlichen Nachrichten von Node (in meinem Fall Ember) deutlich sichtbar.

Dies ist ein Ansatz für Windows 10 (möglicherweise für 7) und ändert das Farbschema (Thema) für cmd, npm terminal selbst und nicht nur die Konsolenausgabe für eine bestimmte App.

Ich habe das funktionierende Windows-Plugin - Color Tool gefunden , das vermutlich unter dem Dach von Windows entwickelt wurde. Eine Beschreibung finden Sie unter dem Link .

Ich habe das Verzeichnis colortool zur Pfadvariablen der Systemumgebung hinzugefügt und es ist jetzt verfügbar, wenn ich das Terminal starte (NodeJs-Eingabeaufforderung, cmd).