Eu tive que mudar a cor de fundo do console para branco devido a problemas nos olhos, mas a fonte é cinza e torna as mensagens ilegíveis. Como posso mudá-lo?
Eu tive que mudar a cor de fundo do console para branco devido a problemas nos olhos, mas a fonte é cinza e torna as mensagens ilegíveis. Como posso mudá-lo?
Respostas:
Abaixo, você pode encontrar uma referência de cores do texto a ser comandada 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 mais a cor escolhida após esse 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 sequência de escape que será interceptada pelo seu terminal e instrui-o a mudar para a cor vermelha. De fato, \x1b
é o código para o caractere de controle não imprimível escape
. As seqüências de escape que lidam apenas com cores e estilos também são conhecidas como código de escape ANSI e são padronizadas; portanto, elas devem funcionar em qualquer plataforma.
A Wikipedia tem uma boa comparação de como os diferentes terminais exibem as cores https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
1;
para cores brilhantes, ou seja, "\ X1B [1; 34m" == azul claro ...
Existem vários pacotes disponíveis para formatar o texto do console no Node.js. Os mais populares são:
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
alterar o protótipo 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'));
var colors = require('colors/safe');
e depois usecolors.red('left string all alone')
Se você quiser alterar as cores diretamente sem um módulo, tente
console.log('\x1b[36m', 'sometext' ,'\x1b[0m');
Primeiro, \x1b[36m
altere as cores para 36
e depois volte para a cor do terminal 0
.
para colorir sua saída Você pode usar exemplos de lá:
https://help.ubuntu.com/community/CustomizingBashPrompt
Também um Gist para nodeJs
Por exemplo, se você quiser parte do texto em vermelho, basta fazer o console.log com:
"\033[31m this will be red \033[91m and this will be normal"
Com base nisso, criei a extensão "colog" para o Node.js. Você pode instalá-lo usando:
npm install colog
Repo e npm: https://github.com/dariuszp/colog
\033[31m
funciona mas \033[91m
não funciona . Para o Ubuntu Terminal deveria ser \033[0m
.
error: octal escape sequences "\033[31mServer ready @ #{app.get('port')}\033[91m" are not allowed
\033[0m
deve ser usado para ligar a para trás o texto ao normal, não\033[91m
Esta é uma lista de cores disponíveis (plano de fundo, primeiro plano) no console com ações disponíveis (redefinir, reverter, ...).
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
A TI fornecerá uma saída mais próxima do console do lado do cliente:
De acordo com 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 ] }
Esses parecem ser códigos de escape ANSI SGR, onde o primeiro número é o código a ser emitido antes da saída e o segundo número é o código a ser emitido depois. Então, se olharmos para o gráfico de códigos ANSI SGR na Wikipedia , você verá que muitos deles começam com um número 30-37 para definir a cor do primeiro plano e terminam em 39 para redefinir a cor do primeiro plano padrão.
Então, uma coisa que eu não gosto é como algumas delas são escuras. Especialmente datas. Vá em frente e tente new Date()
no console. Magenta escura sobre preto é realmente difícil de ler. Vamos mudar isso para uma magenta clara.
// 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ê deseja definir cores automaticamente ao iniciar o nó, crie um script que inicie a repl, assim:
// 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 executenode.exe init.js
. Ele definirá as cores e ativará o prompt de comando node.js.
(Agradecemos a loganfsmyth nesta resposta pela ideia de repl.)
Esta biblioteca de Sindre Sorhus é a melhor no momento:
String.prototype
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, Red com fundo azul, poderá fazê-lo em Javascript como este:
console.log("\x1b[2m", "\x1b[31m", "\x1b[44m", "Sample Text", "\x1b[0m");
A ordem das cores e efeitos parece não ser tão importante, mas lembre-se sempre de redefinir as cores e os efeitos no final.
Um one-liner útil 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')}`)
Editar: r,g,b,w,c,m,y,k
significa vermelho, verde, azul, branco, ciano, magenta, amarelo e blac (k)
Sem bibliotecas, sem complicações, simples:
console.log(red('Error!'));
function red(s) {
return '\033[31m' + s;
}
Você pode usar cores para o texto como outros mencionados em suas respostas.
Mas você pode usar emojis ! por exemplo, você pode usar Você pode usar ⚠️
para mensagens de aviso e🛑
de erro.
Ou simplesmente use estes cadernos como uma cor:
📕: error message
📙: warning message
📗: ok status message
📘: action message
📓: canceled status message
📔: Or anything you like and want to recognize immediately by color
Esse método também ajuda a verificar rapidamente e localizar logs diretamente no código-fonte .
Mas a fonte emoji padrão do linux não é colorida por padrão e você pode querer torná-las coloridas primeiro.
Hoje existem duas maneiras de alterar as cores de um console do Node.js.
Uma é através de bibliotecas de uso geral que podem decorar uma sequência de texto com tags coloridas, que você envia através do padrão console.log
.
As principais bibliotecas para isso hoje:
E a outra maneira - corrigindo os métodos de console existentes. Uma tal biblioteca - manakin permite definir automaticamente as cores padrão para todos os seus métodos de console ( log
, warn
, error
einfo
).
Uma diferença significativa das bibliotecas de cores genéricas - ele pode definir cores globalmente ou localmente, mantendo a sintaxe e o formato de saída consistentes para todos os métodos de console do Node.j, que você usa sem precisar especificar as cores, pois todas são definidas automaticamente .
Eu tive que mudar a cor de fundo do console para branco devido a problemas nos olhos, mas a fonte é cinza e torna as mensagens ilegíveis. Como posso mudá-lo?
Especificamente para o seu problema, aqui está a solução mais simples:
var con = require('manakin').global;
con.log.color = 30; // Use black color for console.log
Ele definirá a cor preta para todas as console.log
chamadas em seu aplicativo. Veja mais códigos de cores .
Cores padrão usadas pelo manakin :
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 é.
console.info('Hello %s', 'World!')
deve exibir Hello World!
, e não Hello %s World!
.
Me deparei com essa pergunta e queria usar algumas cores no stdout sem nenhuma dependência. Isso combina algumas das outras ótimas respostas aqui.
Aqui está o que eu tenho. (Requer o nó v4 ou superior)
// 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()
Apenas exija o arquivo e use-o da seguinte forma:
const colors = require('./colors')
console.log(colors.green("I'm green!"))
Os códigos de cores predefinidos estão disponíveis aqui
Log colorido simples. Suporte para inspeção de objetos e atualização de linha única Este pacote repintou 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();');
Não quero nenhuma dependência disso e apenas esses funcionaram para mim no OS X. Todos os outros exemplos de respostas aqui me deram Octal literal
erros.
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
Encontrei esta resposta acima ( https://stackoverflow.com/a/41407246/4808079 ) muito útil, mas incompleta. Se você sempre quis colorir algo uma vez, acho que seria bom, mas acho que compartilhá-lo em uma forma funcional executável é muito mais aplicável aos casos de uso da vida real.
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));
}
Use-o assim:
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')();
Em seguida, use-o como:
console.logBgGreen(" grüner Hintergrund ")
Isso depende um pouco da plataforma em que você está. A maneira mais comum de fazer isso é imprimindo seqüências de escape ANSI. Para um exemplo simples, aqui está um código python dos scripts de compilação do 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'
}
Para usar código como este, você pode fazer algo como
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);
Você também pode usar o colorworks .
Uso:
var cw = require('colorworks').create();
console.info(cw.compile('[[red|Red message with a [[yellow|yellow]] word.]]'));
Para facilitar a vida, você também pode fazer uma função com ela.
function say(msg) {
console.info(cw.compile(msg));
}
Agora você pode fazer:
say(`[[yellow|Time spent: [[green|${time}]]ms.]]`);
É muito bom para usar ou estender. Você pode usar simplesmente:
var coolors = require('coolors');
console.log(coolors('My cool console log', 'red'));
Ou com a configuração:
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 realmente 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'));
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 deseja estender o protótipo de string, pode escolher qualquer uma das 3 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"))
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");
require
?
sys
estivesse sendo usado em qualquer lugar. Na verdade, não é necessário hoje em dia!
Fornece funções para imprimir textos em cores e também para formatar textos como negrito, intermitente, etc.
Gostei muito da resposta de @ Daniel, mas as funções console.log {color} não funcionaram da mesma maneira que o console.log comum. Fiz algumas alterações e agora todos os parâmetros para as novas funções serão passados para console.log (assim como os códigos de cores).
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 maneira simples, adicionando cor de hora à mensagem, você não precisa alterar seu código, use 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)
);
};
});
Se você estiver usando o Windows CMD, vá para o terminal Properties / Colors (CMD no canto superior esquerdo) e redefina o valor RGB da cor ofensiva. No meu caso, acredito que seja o quinto quadrado de cor da esquerda, que mudei para (222.222.222). Não importa se o botão de opção selecionado no momento mostra Texto da tela ou Fundo da tela, pois você redefine a cor específica do "sistema". Depois de alterar a cor, não se esqueça de selecionar novamente a cor preferida para o plano de fundo ou 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.
Essa é uma abordagem para o Windows 10 (talvez para 7) e altera o esquema de cores (tema) para o próprio terminal cmd, npm, não apenas a saída do console para um aplicativo específico.
Encontrei o plug-in do Windows em funcionamento - Color Tool , que provavelmente é desenvolvido sob o guarda-chuva do Windows. Uma descrição está disponível no link .
Adicionei o diretório colortool à variável de caminho do ambiente do sistema e agora está disponível sempre que inicio o terminal (prompt de comando do NodeJs, cmd).