node.js - nodejs - node js require colors
¿Cómo cambiar el color de fuente de la consola de node.js? (28)
Tuve que cambiar el color de fondo de la consola a blanco debido a problemas oculares, pero la fuente es de color gris y hace que los mensajes sean ilegibles. ¿Cómo puedo cambiarlo?
Coolors
Es bastante bueno para usar o extender. Puede utilizar simplemente:
var coolors = require(''coolors'');
console.log(coolors(''My cool console log'', ''red''));
O con config:
var coolors = require(''coolors'');
console.log(coolors(''My cool console log'', {
text: ''yellow'',
background: ''red'',
bold: true,
underline: true,
inverse: true,
strikethrough: true
}));
Y parece muy divertido de extender:
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''));
paint-console
Registro simple coloreable. Soporte inspeccionar objetos y actualización de una sola línea Este paquete simplemente vuelve a pintar la consola.
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();'');
2017:
De manera simple, agregando tiempo al mensaje, no necesita cambiar su código, use keep console.log (''msg'') o 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)
);
};
});
A continuación puede encontrar la referencia de colores del texto a mandar cuando se ejecuta la aplicación node.js:
console.log(''/x1b[36m%s/x1b[0m'', ''I am cyan''); //cyan
console.log(''/x1b[33m%s/x1b[0m'', stringToMakeYellow); //yellow
La nota %s es donde se inyecta la cadena (el segundo argumento). /x1b[0m restablece el color del terminal para que no siga siendo el color elegido después de este punto.
Referencia de colores
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 ejemplo, /x1b[31m es una secuencia de escape que será interceptada por su terminal y le indica que cambie al color rojo. De hecho, /x1b es el código para el escape caracteres de control no imprimible . Las secuencias de escape que se ocupan solo de los colores y estilos también se conocen como código de escape ANSI y están estandarizadas, por lo que, por lo tanto, deben funcionar en cualquier plataforma.
Wikipedia tiene una buena comparación de cómo los diferentes terminales muestran colores https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
En ubuntu puedes simplemente usar códigos de color:
var sys = require(''sys'');
process.stdout.write("x1B[31m" + your_message_in_red + "/x1B[0m/r/n");
Encontré esta pregunta y quise usar algunos colores en la salida estándar sin dependencias. Esto combina algunas de las otras grandes respuestas aquí.
Esto es lo que tengo. (Requiere nodo v4 o mayor)
// 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()
Solo requiere el archivo, luego úselo así:
const colors = require(''./colors'')
console.log(colors.green("I''m green!"))
Los códigos de color predefinidos están disponibles here
Esta biblioteca de Sindre Sorhus es la mejor en este momento:
chalk
- De alto rendimiento
- No extiende
String.prototype - API expresiva
- Habilidad para anidar estilos.
- Limpio y enfocado
- Detecta automáticamente el soporte de color.
- Mantenido activamente
- Utilizado por más de 5500 módulos
Esta es una lista de colores disponibles (fondo, primer plano) en la consola con acciones disponibles (restablecer, revertir, ...).
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"
}
};
Úsalo como sigue:
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
También puede instalar:
npm install console-info console-warn console-error --save-dev
IT le dará una salida más cercana a la consola del lado del cliente:
Este es un enfoque para Windows 10 (quizás para 7) y cambia la combinación de colores (tema) para cmd, el terminal npm, no solo la salida de consola para una aplicación en particular.
Encontré el plugin de trabajo de Windows - Color Tool , que probablemente se desarrolla bajo el paraguas de Windows. Una descripción está disponible en el link .
Agregué el directorio colortool en la variable de ruta del entorno del sistema y ahora está disponible cada vez que inicio el terminal (símbolo del sistema de NodeJs, cmd).
Hay algunos módulos para cambiar el color de la fuente de la consola en Node.js, los más populares son:
- Tiza - https://github.com/chalk/chalk
- Colores - https://www.npmjs.org/package/colors
- Cli-color - https://www.npmjs.org/package/cli-color
uso de https://github.com/chalk/chalk
npm instalar tiza
var chalk = require(''chalk'');
console.log(chalk.red(''Text in red''));
uso de colors :
npm instala colores
var colors = require(''colors/safe''); // does not alter string prototype
console.log(colors.red(''This String Will Display RED''));
Hay algunos colores para elegir, así como el formato de texto como Negrita y Cursiva .
Muchas personas han notado su desaprobación en los Colores que alteran el prototipo de Cadena , si prefiere que sus prototipos queden solos, querrá usar cli-color o chalk
npm instalar cli-color
var clc = require(''cli-color'');
console.log(clc.red(''Text in red''));
Tanto el cli-color como la chalk requieren un poco más de escritura, pero obtienes resultados similares (a los colores) sin adiciones de prototipos de cuerdas. Ambos admiten una buena gama de colores, formatos (negrita / cursiva, etc.) y tienen pruebas unitarias .
Elige tu opción.
Hay dos formas de ver los colores cambiantes para una consola Node.js hoy.
Una es a través de bibliotecas de propósito general que pueden decorar una cadena de texto con etiquetas de color, que luego se imprime a través del console.log estándar.
Las mejores bibliotecas para eso hoy:
Y al revés: parchear los métodos de consola existentes. Una de estas bibliotecas: manakin permite establecer automáticamente colores estándar para todos sus métodos de consola ( log , warn , error e info ).
Una diferencia significativa con respecto a las bibliotecas de colores genéricas: puede configurar los colores de forma global o local, al tiempo que mantiene la sintaxis y el formato de salida para cada método de consola Node.js, que luego utiliza sin tener que especificar los colores, ya que se configuran automáticamente. .
Tuve que cambiar el color de fondo de la consola a blanco debido a problemas oculares, pero la fuente es de color gris y hace que los mensajes sean ilegibles. ¿Cómo puedo cambiarlo?
Específicamente para su problema, aquí está la solución más simple:
var con = require(''manakin'').global;
con.log.color = 30; // Use black color for console.log
Establecerá el color negro para cada llamada de console.log en su aplicación. Ver más códigos de color .
Los colores por defecto utilizados por manakin :
No hay bibliotecas sin complicaciones, simplemente simple:
console.log(red(''Error!''));
function red(s) {
return ''/033[31m'' + s;
}
No quiero ninguna dependencia para esto y solo estas me funcionaron en OS X. Todas las otras muestras de las respuestas aquí me dieron errores 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"
fuente: https://coderwall.com/p/yphywg/printing-colorful-text-in-terminal-when-run-node-js-script
Para colorear tu salida puedes usar ejemplos desde allí:
https://help.ubuntu.com/community/CustomizingBashPrompt
También una esencia para los nodos
Por ejemplo, si desea que parte del texto esté en color rojo, simplemente ejecute console.log con:
"/033[31m this will be red /033[91m and this will be normal"
Basado en eso he creado la extensión "colog" para Node.js. Puedes instalarlo usando:
npm install colog
Repo y npm: https://github.com/dariuszp/colog
Realmente me gustó la respuesta de @Daniel, pero las funciones console.log {color} no funcionaron de la misma manera que con console.log normal. He realizado algunos cambios y ahora todos los parámetros de las nuevas funciones se pasarán a console.log (así como a los códigos de color).
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);
}
});
}
Según esta documentación , puede cambiar los colores según el tipo de datos de la salida:
// 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 ] }
Estos parecen ser códigos de escape ANSI SGR, donde el primer número es el código a emitir antes de la salida, y el segundo número es el código a emitir después. Entonces, si observamos la tabla de códigos ANSI SGR en Wikipedia , veremos que la mayoría de estos comienzan con un número 30-37 para establecer el color de primer plano y terminan en 39 para restablecer el color de fondo predeterminado.
Así que una cosa que no me gusta es cuán oscuros son algunos de estos. Especialmente las fechas. Sigue adelante e intenta la new Date() en la consola. El magenta oscuro sobre negro es muy difícil de leer. Cambiemos eso a un magenta claro en su lugar.
// 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'';
Ahora, cuando prueba la new Date() , la salida es mucho más legible.
Si desea configurar los colores automáticamente al iniciar el nodo, cree un script que inicie la respuesta, como este:
// 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({});
Guarde este archivo (por ejemplo, init.js ), luego ejecute node.exe init.js Establecerá los colores y lanzará el símbolo del sistema node.js.
(Gracias a loganfsmyth en esta respuesta por la idea de respuesta ).
Si desea cambiar los colores directamente usted mismo sin un módulo, intente
console.log(''/x1b[36m'', ''sometext'' ,''/x1b[0m'');
Primero ''/ x1b [36m'' para cambiar los colores a "36" y luego a la terminal de color "0".
Si está utilizando Windows CMD, vaya a Propiedades / Colores del terminal (CMD superior izquierda) y luego redefina el valor RGB del color ofensivo. En mi caso, creo que es el quinto cuadrado de color de la izquierda, que cambié a (222,222,222). No importa si el botón de radio seleccionado actualmente muestra Texto de pantalla o Fondo de pantalla cuando solo redefine ese color específico del "sistema". Una vez que haya cambiado el color, no olvide volver a seleccionar el color preferido para el fondo o el texto antes de hacer clic en Aceptar.
Después del cambio, todos estos mensajes rojizos de Node (Ember en mi caso) son claramente visibles.
Sobrecargué los métodos de la consola.
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");
También puedes usar colorworks .
Uso:
var cw = require(''colorworks'').create();
console.info(cw.compile(''[[red|Red message with a [[yellow|yellow]] word.]]''));
Para hacer la vida más fácil, también puedes hacer una función con ella.
function say(msg) {
console.info(cw.compile(msg));
}
Ahora puedes hacer como
say(`[[yellow|Time spent: [[green|${time}]]ms.]]`);
Un práctico de una línea que escribí para scripts npm que no pueden tener dependencias:
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'')}`)
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'');
}
});
}
en tu app.js
require(''./logger'')();
entonces úsalo como:
console.logBgGreen(" grüner Hintergrund ")
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 ejemplo, si desea tener un texto rojo oscuro, con fondo azul, puede hacerlo en Javascript de esta manera:
console.log("/x1b[2m", "/x1b[31m", "/x1b[44m", "Sample Text", "/x1b[0m");
El orden de los colores y efectos no parece ser tan importante, pero siempre recuerde restablecer los colores y efectos al final.
StyleMe mi propio módulo, StyleMe . Lo hice así que puedo hacer mucho con poco escribiendo. Ejemplo:
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.
También se puede anidar:
console.log("This is normal red{this is red blu{this is blue} back to red}".styleMe())
O, si no desea extender el prototipo de cadena, puede elegir cualquiera de las otras 3 opciones:
console.log(styleme.red("a string"))
console.log("Hello, this is yellow text".yellow().end())
console.log(styleme.style("some text","red,bbl"))
Proporciona funciones para imprimir textos en color y también para hacer formatos de texto como negrita, parpadear, etc.
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 ayuda a establecer el color de primer plano: / x1b [38; 2; R; G; Bm
esto puede no funcionar en alguna parte