Musiałem zmienić kolor tła konsoli na biały z powodu problemów z oczami, ale czcionka jest w kolorze szarym i sprawia, że ​​wiadomości są nieczytelne. Jak mogę to zmienić?

Poniżej znajduje się odniesienie kolorów tekstu do polecenia podczas uruchamiania aplikacji node.js:

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

Uwaga %sdotyczy miejsca, w które zostaje wstrzyknięty drugi argument. \x1b[0mresetuje kolor terminala, aby po tym momencie nie był już wybranym kolorem.

Kolory odniesienia

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"

EDYTOWAĆ:

Na przykład \x1b[31mjest sekwencją ucieczki, która zostanie przechwycona przez twój terminal i instruuje go, aby przełączył się na czerwony kolor. W rzeczywistości \x1bjest to kod kontrolnego niedrukowalnego znaku escape . Sekwencje specjalne dotyczące tylko kolorów i stylów są również znane jako kod specjalny ANSI i są znormalizowane, dlatego też powinny (powinny) działać na dowolnej platformie.

Wikipedia ma ładne porównanie tego, jak różne terminale wyświetlają kolory https://en.wikipedia.org/wiki/ANSI_escape_code#Colors

W Node.js. dostępnych jest wiele pakietów do formatowania tekstu konsoli. Najpopularniejsze to:

• chalk
• cli-color
• colors
  
  

Stosowanie:

KREDA:

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

ZABARWIENIE:

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

Wiele osób zauważyło swoją dezaprobatę dla colorszmiany prototypu String . Jeśli wolisz pozostawić swoje prototypy w spokoju, użyj następującego kodu:

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

Jeśli chcesz bezpośrednio zmienić kolory bez modułu, spróbuj

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

Najpierw \x1b[36mzmień kolory na, 36a następnie z powrotem na kolor terminala 0.

Oto lista kodów kolorów ANSI

pokolorować wydruk Możesz użyć przykładów stamtąd:
https://help.ubuntu.com/community/CustomizingBashPrompt

Również Gist dla nodeJs

Na przykład, jeśli chcesz część tekstu w kolorze czerwonym, po prostu wykonaj plik console.log z:

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

Na tej podstawie utworzyłem rozszerzenie „colog” dla Node.js. Możesz go zainstalować za pomocą:

npm install colog

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

To jest lista dostępnych kolorów (tło, pierwszy plan) w konsoli z dostępnymi akcjami (reset, odwrócenie, ...).

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

Użyj go w następujący sposób:

 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

Możesz także zainstalować:

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

IT da ci wyjście bliższe konsoli po stronie klienta:

W tej dokumentacji można zmieniać kolory w zależności od typu danych wyjściowych:

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

Wyglądają na kody ucieczki ANSI SGR, gdzie pierwsza liczba to kod, który należy wysłać przed wyjściem, a druga liczba to kod, który należy wysłać później. Więc jeśli spojrzymy na tabelę kodów ANSI SGR na Wikipedii , zobaczysz, że większość z nich zaczyna się od liczby 30-37, aby ustawić kolor pierwszego planu, a kończy 39, aby zresetować do domyślnego koloru pierwszego planu.

Jedną z rzeczy, których nie lubię, jest to, jak ciemne są niektóre z nich. Zwłaszcza daty. Śmiało i spróbuj new Date()w konsoli. Ciemna magenta na czerni jest naprawdę trudna do odczytania. Zamiast tego zmieńmy to na jasnopurpurowy.

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

Teraz, gdy spróbujesz new Date(), wynik jest znacznie bardziej czytelny.

Jeśli chcesz ustawić kolory automatycznie podczas uruchamiania węzła, utwórz skrypt uruchamiający replikę, w następujący sposób:

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

Zapisz ten plik (na przykład init.js), a następnie uruchom node.exe init.js. Ustawi kolory i uruchomi wiersz poleceń node.js.

(Dzięki loganfsmyth w tej odpowiedzi za pomysł na repl.)

Ta biblioteka Sindre Sorhus jest obecnie najlepsza:

kreda

• Wysoka wydajność
• Nie rozszerza się String.prototype
• Ekspresyjny interfejs API
• Możliwość zagnieżdżania stylów
• Czysty i skoncentrowany
• Automatyczne wykrywanie obsługi kolorów
• Aktywnie utrzymany
• Używany przez ponad 5500 modułów

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"

Na przykład, jeśli chcesz mieć przyciemniony, czerwony tekst z niebieskim tłem, możesz to zrobić w Javascript w następujący sposób:

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

Kolejność kolorów i efektów nie wydaje się tak ważna, ale zawsze pamiętaj, aby na końcu zresetować kolory i efekty.

Przydatny jednuliniowy skrypt napisany dla skryptów npm, które nie mogą mieć zależności:

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

Edycja: r,g,b,w,c,m,y,k oznacza czerwony, zielony, niebieski, biały, cyjan, magenta, żółty i blac (k)

Dla popularnej alternatywy dla kolorów, które nie zadzierają z wbudowanymi metodami obiektu String, polecam sprawdzenie cli-color .

Obejmuje zarówno kolory, jak i łańcuchowe style, takie jak pogrubienie, kursywa i podkreślenie.

Porównanie różnych modułów w tej kategorii znajduje się tutaj .

Bez bibliotek bez komplikacji po prostu proste:

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

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

Emoji

Możesz używać kolorów w tekście, jak inni wymienili w swoich odpowiedziach.

Ale zamiast tego możesz używać emoji ! na przykład możesz użyć Możesz użyć ⚠️do komunikatów ostrzegawczych i 🛑komunikatów o błędach.

Lub po prostu użyj tych notatników jako koloru:

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

Premia:

Ta metoda pomaga również szybko skanować i znajdować dzienniki bezpośrednio w kodzie źródłowym .

_{Ale domyślna czcionka emoji linuksa nie jest domyślnie kolorowa i możesz najpierw sprawić, by były kolorowe.}

Istnieją dziś dwa sposoby zmiany kolorów konsoli Node.js.

Jednym z nich są biblioteki ogólnego przeznaczenia, które mogą ozdobić ciąg tekstowy za pomocą znaczników kolorów, które następnie wyprowadza się przez standard console.log.

Najlepsze biblioteki do tego dzisiaj:

• kreda
• zabarwienie
• kolor cli

I w drugą stronę - załatanie istniejących metod konsoli. Jednym z takich biblioteka - Manakin pozwala automatycznie ustawić standardowe kolory dla wszystkich metod Console ( log, warn, errori info).

Jedna znacząca różnica w stosunku do ogólnych bibliotek kolorów - może ustawiać kolory globalnie lub lokalnie, zachowując spójną składnię i format wyjściowy dla każdej metody konsoli Node.js, której następnie używasz bez konieczności określania kolorów, ponieważ wszystkie są ustawiane automatycznie .

Musiałem zmienić kolor tła konsoli na biały z powodu problemów z oczami, ale czcionka jest w kolorze szarym i sprawia, że ​​wiadomości są nieczytelne. Jak mogę to zmienić?

Oto najprostsze rozwiązanie konkretnego problemu:

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

Ustawi kolor czarny dla każdego console.logpołączenia w aplikacji. Zobacz więcej kodów kolorów .

Domyślne kolory używane przez manakina :

Przeładowałem metody konsoli.

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

Dane wyjściowe to.

Przeszedłem przez to pytanie i chciałem użyć kilku kolorów na standardowym wyjściu bez żadnych zależności. Łączy to niektóre inne świetne odpowiedzi tutaj.

Oto co mam. (Wymaga węzła v4 lub nowszego)

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

Po prostu wymagaj pliku, a następnie użyj go w następujący sposób:

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

Wstępnie zdefiniowane kody kolorów są dostępne tutaj

konsola do malowania

Prosty, kolorowy dziennik. Wsparcie inspekcji obiektów i aktualizacja pojedynczej linii Ten pakiet po prostu odmalowuje konsolę.

zainstalować

npm install paint-console

stosowanie

require('paint-console');

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

próbny

Nie chcę żadnej zależności od tego i tylko te działały dla mnie na OS X. Wszystkie inne próbki z odpowiedzi tutaj dały mi Octal literalbłędy.

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"

źródło: https://coderwall.com/p/yphywg/printing-colorful-text-in-terminal-when-run-node-js-script

Uznałem tę odpowiedź powyżej ( https://stackoverflow.com/a/41407246/4808079 ) bardzo przydatną, ale niekompletną. Jeśli chciałbyś kiedyś pokolorować coś tylko raz, myślę, że byłoby dobrze, ale myślę, że udostępnienie go w funkcjonalnej formie funkcjonalnej jest o wiele bardziej przydatne w rzeczywistych przypadkach użycia.

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

Użyj tego w ten sposób:

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

Następnie użyj go w następujący sposób:

console.logBgGreen(" grüner Hintergrund ")

To nieco zależy od tego, na jakiej platformie jesteś. Najczęstszym sposobem na to jest wydrukowanie sekwencji ucieczki ANSI. Dla prostego przykładu oto kod Pythona ze skryptów kompilacji blendera:

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

Aby użyć takiego kodu, możesz zrobić coś takiego

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

Możesz także użyć kolorów .

Stosowanie:

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

Aby ułatwić życie, możesz także przy pomocy tej funkcji.

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

Teraz możesz zrobić:

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

Chłodnice

Jest całkiem dobry do użycia lub przedłużenia. Możesz użyć po prostu:

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

Lub z config:

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

Wydaje się to naprawdę zabawne, aby przedłużyć:

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

Zobacz moduł Coolors

Stworzyłem własny moduł StyleMe . Zrobiłem to, aby móc dużo pisać przy małym pisaniu. Przykład:

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.

Można go również zagnieżdżać:

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

Lub, jeśli nie chcesz rozszerzać prototypu łańcucha, możesz wybrać jedną z 3 innych opcji:

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

W ubuntu możesz po prostu użyć kodów kolorów:

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

węzeł-koloruj

Zapewnia funkcje drukowania tekstu w kolorze, a także formatowania tekstu, takie jak pogrubienie, miganie itp.

Naprawdę podobała mi się odpowiedź @ Daniela, ale funkcje console.log {color} nie działały tak samo, jak zwykłe console.log. Wprowadziłem kilka zmian, a teraz wszystkie parametry nowych funkcji zostaną przekazane do pliku console.log (a także kody kolorów).

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:

Prosty sposób, dodając kolor czasu do wiadomości, nie musisz zmieniać kodu, użyj keep. console („msg”) lub console.err („błąd”)

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

Jeśli używasz Windows CMD, przejdź do terminalu Właściwości / Kolory (CMD u góry po lewej), a następnie ponownie zdefiniuj wartość RGB ofensywnego koloru. W moim przypadku uważam, że jest to piąty kwadrat od lewej, który zmieniłem na (222 222 222). Nie ma znaczenia, czy aktualnie wybrany przycisk radiowy wyświetla tekst ekranu lub tło ekranu, ponieważ właśnie redefiniujesz ten konkretny „systemowy” kolor. Po zmianie koloru nie zapomnij wybrać preferowanego koloru tła lub tekstu przed kliknięciem OK.

Po zmianie wszystkie te czerwonawe wiadomości z Węzła (w moim przypadku Ember) są wyraźnie widoczne.

Jest to podejście do systemu Windows 10 (może 7) i zmienia schemat kolorów (motyw) dla samego cmd, samego terminala npm, nie tylko wyjścia konsoli dla konkretnej aplikacji.

Znalazłem działającą wtyczkę Windows - Color Tool , która jest prawdopodobnie opracowana pod parasolem Windows. Opis jest dostępny pod linkiem .

Dodałem katalog colortool do zmiennej systemowej ścieżki środowiska, a teraz jest on dostępny za każdym razem, gdy uruchamiam terminal (wiersz poleceń NodeJs, cmd).