node.js - index - console log color text



Como alterar a cor da fonte do console do node.js? (20)

Coolors

É muito bom para uso ou extensão. Você pode usar simplesmente:

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

Ou com config:

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

E parece muito engraçado estender:

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

Coolors

Eu tive que mudar a cor de fundo do console para branco por causa de problemas nos olhos, mas a fonte é cinza e torna as mensagens ilegíveis. Como posso mudá-lo?


paint-console

Log de cores simples. Suporte inspecionar objetos e atualização de linha única Este pacote repintar apenas o console.

instalar

npm install paint-console

uso

require('paint-console');

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

demo


Abaixo você pode encontrar a referência de cores do texto ao comando ao executar o aplicativo node.js:

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

Nota %s é onde a string (o segundo argumento) é injetada. \x1b[0m redefine a cor do terminal para que não continue a ser a cor escolhida após este ponto.

Referência de cores

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"

EDITAR:

Por exemplo, \x1b[31m é uma seqüência de escape que será interceptada pelo seu terminal e instrui a mudança para a cor vermelha. De fato, \x1b é o código para o escape caractere de controle não imprimível . As seqüências de escape que lidam apenas com cores e estilos são também conhecidas como código de escape ANSI e são padronizadas, portanto devem (devem) funcionar em qualquer plataforma.

A Wikipedia tem uma boa comparação de como diferentes terminais exibem cores https://en.wikipedia.org/wiki/ANSI_escape_code#Colors


Antes de instalar qualquer pacote de vulnerabilidades npm como a resposta acima que se refere a instalar pakage como 'giz' etc eu também estava procurando mudar a cor do console e eu encontrei pacote de giz de primeira resposta assim quando eu instalar giz npm me avisar o pacote i instalar encontrado 3 vulnerabilidades (1 baixo, 1 moderado, 1 alto)


Esta é uma abordagem para o Windows 10 (talvez para 7) e altera o esquema de cores (tema) para cmd, o próprio terminal npm, não apenas a saída do console para um aplicativo específico.

Eu encontrei o plugin de trabalho do Windows - Color Tool , que é presumivelmente desenvolvido sob o guarda-chuva do Windows. Uma descrição está disponível no link .

Eu adicionei o diretório do colortool na variável do caminho do ambiente do sistema e agora ele está disponível sempre que eu inicio o terminal (prompt de comando do NodeJs, cmd).


Esta é uma lista de cores disponíveis (plano de fundo, primeiro plano) no console com ações disponíveis (redefinir, inverter, ...).

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-o da seguinte forma:

 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

Você também pode instalar:

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

TI lhe dará uma saída mais próxima do console do lado do cliente:


Eu criei meu próprio módulo, StyleMe . Eu fiz isso para que eu possa fazer muito com pouca digitação. Exemplo:

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.

Também pode ser aninhado:

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

Ou, se você não quer estender o protótipo de string, você pode apenas qualquer uma das três outras opções:

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

Eu não quero nenhuma dependência para isso e só isso funcionou para mim no OS X. Todos os outros exemplos de respostas aqui me deram erros Octal literal .

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


Eu sobrecarreguei os métodos do 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");

A saída é.


Existem vários pacotes disponíveis para formatar o texto do console no Node.js. Os mais populares são:

Uso:

GIZ:

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

CORES:

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

Muitas pessoas notaram sua desaprovação de colors alterando o protótipo de String . Se você preferir que seus protótipos sejam deixados em paz, use o seguinte código:

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

Nenhuma biblioteca sem complicações apenas simples:

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

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

No Ubuntu você pode simplesmente usar códigos de cores:

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

Por esta documentação , você pode alterar as cores com base no tipo de dados da saída:

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

Estes parecem ser códigos de escape ANSI SGR, em que o primeiro número é o código a emitir antes da saída e o segundo número é o código que emite depois. Portanto, se observarmos o gráfico dos códigos ANSI SGR na Wikipedia , você verá que a maioria deles começa com um número 30-37 para definir a cor de primeiro plano e termina em 39 para redefinir a cor de primeiro plano padrão.

Então, uma coisa que eu não gosto é como alguns desses são sombrios. Especialmente datas. Vá em frente e tente new Date() no console. O magenta escuro no preto é realmente difícil de ler. Vamos mudar isso para um magenta claro.

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

Agora quando você tenta new Date() , a saída é muito mais legível.

Se você quiser definir cores automaticamente ao iniciar o nó, crie um script que lance a replicação, desta forma:

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

Salve este arquivo (por exemplo, init.js ) e execute node.exe init.js Ele irá definir as cores e iniciar o prompt de comando node.js.

(Obrigado ao loganfsmyth nesta resposta para a ideia de replicação.)


Se você estiver usando o Windows CMD, vá para o terminal Propriedades / Cores (CMD superior esquerdo) e redefina o valor RGB da cor ofensiva. No meu caso, acredito que seja o quinto quadrado de cores da esquerda, para o qual mudei (222.222.222). Não importa se o botão de opção selecionado atualmente exibe texto de tela ou fundo de tela, pois você apenas redefine essa cor de "sistema" específica. Depois de alterar a cor, não esqueça de selecionar a cor preferida para o plano de fundo ou o texto antes de clicar em OK.

Após a alteração, todas essas mensagens avermelhadas do Node (Ember no meu caso) são claramente visíveis.


Um útil liner que escrevi para scripts npm que não podem ter dependências:

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


Você também pode usar colorworks .

Uso:

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

Para tornar a vida mais fácil, você também pode fazer uma função com ela.

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

Agora você pode fazer como

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


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"

Por exemplo, se você quiser ter um texto Dim, vermelho com fundo azul, você pode fazê-lo em Javascript assim:

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

A ordem das cores e dos efeitos parece não ser tão importante, mas lembre-se sempre de redefinir as cores e os efeitos no final.


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

var to_rgb = function (_text, _r, _g, _b) {
    return "\x1b[38;2;" + _r + ";" + _g + ";" + _b + "m" + _text + "\x1b[0m";
};

este código ajuda a definir a cor do primeiro plano: \ x1b [38; 2; R; G; Bm

isso pode não funcionar em algum lugar





console