Comment changer la couleur de la police de la console de node.js?
J'ai dû changer la couleur d'arrière-plan de la console en blanc à cause de problèmes de vision, mais la police est grise et rend les messages illisibles. Comment puis-je le changer?
Vous trouverez ci-dessous la référence des couleurs du texte à commander lors de l'exécution de l'application node.js:
console.log('\x1b[36m%s\x1b[0m', 'I am cyan'); //cyan
console.log('\x1b[33m%s\x1b[0m', stringToMakeYellow); //yellow
Note %s est où dans la chaîne (le deuxième argument) est injecté. \x1b[0m réinitialise la couleur du terminal afin qu'elle ne soit plus la couleur choisie après ce point.
Référence de couleurs
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"
MODIFIER:
Par exemple, \x1b[31m est une séquence d'échappement qui sera interceptée par votre terminal et lui demandera de passer à la couleur rouge. En fait, \x1b est le code du caractère de contrôle non imprimableescape. Les séquences d'échappement portant uniquement sur les couleurs et les styles sont également appelées code d'échappement ANSI et sont normalisées. Par conséquent, elles (devraient) fonctionner sur n'importe quelle plateforme.
Wikipedia propose une comparaison intéressante de l'affichage des couleurs entre différents terminaux https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
Il existe plusieurs packages disponibles pour formater le texte de la console dans Node.js. Les plus populaires sont:
Usage:
CRAIE:
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'));
COULEURS:
const colors = require('colors');
console.log('Text in red'.red);
De nombreuses personnes ont indiqué qu'elles désapprouvaient colors de modifier le prototype String. Si vous préférez laisser vos prototypes seuls, utilisez plutôt le code suivant:
const colors = require('colors/safe');
console.log(colors.red('Text in red'));
Si vous voulez changer les couleurs directement vous-même sans module, essayez
console.log('\x1b[36m', 'sometext' ,'\x1b[0m');
Tout d'abord '\ x1b [36m' pour changer les couleurs en "36" puis revenez à la couleur du terminal "0".
pour colorer votre sortie Vous pouvez utiliser des exemples à partir de là:
https://help.ubuntu.com/community/CustomizingBashPrompt
Aussi un Gist pour nodeJs
Par exemple, si vous voulez qu'une partie du texte soit en rouge, faites simplement console.log avec:
"\033[31m this will be red \033[91m and this will be normal"
Sur cette base, j'ai créé l'extension "colog" pour Node.js. Vous pouvez l'installer en utilisant:
npm install colog
Repo et npm: https://github.com/dariuszp/colog
Pour cette documentation , vous pouvez modifier les couleurs en fonction du type de données de la sortie:
// 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 ] }
Il s’agit apparemment de codes d’échappement ANSI SGR, le premier chiffre étant le code à émettre avant la sortie et le second le code à émettre. Donc, si nous regardons le tableau des codes SGR ANSI sur Wikipedia , vous verrez que la plupart d'entre eux commencent par un numéro 30-37 pour définir la couleur de premier plan et se terminent par 39 pour rétablir la couleur de premier plan par défaut. .
Donc, une chose que je n'aime pas, c'est la noirceur de certaines d'entre elles. Surtout les dates. Allez-y et essayez new Date() dans la console. Le magenta foncé sur le noir est vraiment difficile à lire. Changeons cela en magenta clair à la place.
// 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';
Maintenant, lorsque vous essayez new Date(), la sortie est beaucoup plus lisible.
Si vous souhaitez définir des couleurs automatiquement lors du lancement du noeud, créez un script qui lance la répl, comme ceci:
// 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({});
Enregistrez ce fichier (par exemple, init.js), puis exécutez node.exe init.js. Il définira les couleurs et lancera l'invite de commande node.js.
(Merci à loganfsmyth dans cette réponse pour l’idée de réplique.)
Ceci est une liste des couleurs disponibles (arrière-plan, avant-plan) dans la console avec les actions disponibles (réinitialisation, inversion, ...).
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"
}
};
Utilisez-le comme suit:
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
Vous pouvez également installer:
npm install console-info console-warn console-error --save-dev
Cela vous donnera une sortie plus proche de la console du côté client:
Cette bibliothèque de Sindre Sorhus est la meilleure du moment:
craie
- Très performant
- N'étend pas
String.prototype - API expressive
- Capacité à imbriquer les styles
- Propre et concentré
- Détecte automatiquement la prise en charge des couleurs
- Activement maintenu
- Utilisé par plus de 5500 modules
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"
Par exemple, si vous voulez un texte en rouge, rouge avec un fond bleu, vous pouvez le faire en Javascript comme ceci:
console.log("\x1b[2m", "\x1b[31m", "\x1b[44m", "Sample Text", "\x1b[0m");
L'ordre des couleurs et des effets ne semble pas être important, mais n'oubliez pas de réinitialiser les couleurs et les effets à la fin.
Pas de bibliothèques, pas de complications simples:
console.log(red('Error!'));
function red(s) {
return '\033[31m' + s;
}
Un one-liner pratique que j'ai écrit pour les scripts npm qui ne peuvent pas avoir de dépendances
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')}`)Il existe deux manières de modifier les couleurs d'une console Node.js aujourd'hui.
La première consiste à utiliser des bibliothèques générales pouvant décorer une chaîne de texte avec des balises de couleur, que vous pouvez ensuite exporter via le console.log standard.
Les meilleures bibliothèques pour cela aujourd'hui:
Et l’autre façon: appliquer les méthodes de console existantes. Une de ces bibliothèques - manakin vous permet de définir automatiquement les couleurs standard de toutes vos méthodes de console (log, warn, error et info).
Une différence significative par rapport aux bibliothèques de couleurs génériques: il peut définir les couleurs de manière globale ou locale, tout en conservant une syntaxe et un format de sortie cohérents pour chaque méthode de console Node.js, que vous utilisez ensuite sans avoir à spécifier les couleurs, car elles sont toutes définies automatiquement. .
J'ai dû modifier la couleur d'arrière-plan de la console en blanc à cause de problèmes de vision, mais la police est grise et rend les messages illisibles. Comment puis-je le changer?
Voici la solution la plus simple pour votre problème:
var con = require('manakin').global;
con.log.color = 30; // Use black color for console.log
Il définira la couleur noire pour chaque appel console.log dans votre application. Voir plus de codes de couleur .
Couleurs par défaut utilisées par manakin :
J'ai surchargé les méthodes de la 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");
La sortie est . 
Je ne veux pas de dépendance pour ceci et seulement ceux-ci ont fonctionné pour moi sur OS X. Tous les autres exemples de réponses ici m'ont donné des erreurs 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"
source: https://coderwall.com/p/yphywg/printing-colorful-text-in-terminal-when-run-node-js-script
Paint-console
Journal simple colorable. Supporte les objets inspectés et la mise à jour sur une seule ligne Ce paquet vient de repeindre la console.
install
npm install Paint-console
usage
require('Paint-console');
console.info('console.info();');
console.warn('console.warn();');
console.error('console.error();');
console.log('console.log();');
Vous pouvez également utiliser colorworks .
Usage:
var cw = require('colorworks').create();
console.info(cw.compile('[[red|Red message with a [[yellow|yellow]] Word.]]'));
Pour vous simplifier la vie, vous pouvez également en faire une fonction.
function say(msg) {
console.info(cw.compile(msg));
}
Maintenant tu peux faire comme
say(`[[yellow|Time spent: [[green|${time}]]ms.]]`);
Je suis tombé sur cette question et je voulais utiliser certaines couleurs sur stdout sans aucune dépendance. Ceci combine certaines des autres bonnes réponses ici.
Voici ce que j'ai. (Requiert le noeud v4 ou supérieur)
// 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()
Exigez juste le fichier, puis utilisez-le comme suit:
const colors = require('./colors')
console.log(colors.green("I'm green!"))
Les codes de couleur prédéfinis sont disponibles ici
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);
J'ai créé mon propre module, StyleMe . Je l'ai fait pour que je puisse faire beaucoup avec peu de frappe. Exemple:
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.
Il peut aussi être imbriqué:
console.log("This is normal red{this is red blu{this is blue} back to red}".styleMe())
Ou, si vous ne souhaitez pas étendre le prototype de chaîne, vous pouvez utiliser l’une des trois autres options:
console.log(styleme.red("a string"))
console.log("Hello, this is yellow text".yellow().end())
console.log(styleme.style("some text","red,bbl"))
J'ai trouvé cette réponse ci-dessus ( https://stackoverflow.com/a/41407246/4808079 ) très utile, mais incomplet. Si vous avez toujours voulu colorier une seule fois, j'imagine que tout irait bien, mais je pense que le partager sous une forme fonctionnelle pouvant être exécutée est beaucoup plus applicable aux cas d'utilisation réels.
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));
}
Utilisez-le comme ceci:
colorStringLog(Color.FgYellow, "Some Yellow text to console log");
console.log([
colorString(Color.FgRed, "red"),
colorString(Color.FgGreen, "green"),
colorString(Color.FgBlue, "blue"),
].join(", "));
Fournit des fonctions pour imprimer des textes en couleur et également pour mettre en forme des textes tels que gras, clignotement, etc.
Refroidisseurs
C'est plutôt bon à utiliser ou à prolonger. Vous pouvez utiliser simplement:
var coolors = require('coolors');
console.log(coolors('My cool console log', 'red'));
Ou avec config:
var coolors = require('coolors');
console.log(coolors('My cool console log', {
text: 'yellow',
background: 'red',
bold: true,
underline: true,
inverse: true,
strikethrough: true
}));
Et semble vraiment amusant d'étendre:
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'));
2017:
manière simple, en ajoutant du temps au message, vous n'avez pas besoin de changer votre code, utilisez 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)
);
};
});
Dans Ubuntu, vous pouvez simplement utiliser des codes de couleur:
var sys = require('sys');
process.stdout.write("x1B[31m" + your_message_in_red + "\x1B[0m\r\n");
J'ai bien aimé la réponse de @ Daniel, mais les fonctions console.log {color} ne fonctionnaient pas de la même manière que console.log classique. J'ai apporté quelques modifications et maintenant tous les paramètres des nouvelles fonctions seront passés à console.log (ainsi que les codes de couleur).
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);
}
});
}
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');
}
});
}
dans votre app.js
require('./logger')();
puis utilisez-le comme:
console.logBgGreen(" grüner Hintergrund ")
Si vous utilisez Windows CMD, accédez au terminal Propriétés/Couleurs (CMD en haut à gauche), puis redéfinissez la valeur RVB de la couleur offensive. Dans mon cas, je crois que c’est le cinquième carré de couleur à gauche, que j’ai changé en (222 222 222). Peu importe que le bouton radio actuellement sélectionné affiche le texte ou le fond d'écran lorsque vous redéfinissez cette couleur "système" spécifique. Une fois la couleur modifiée, n'oubliez pas de sélectionner la couleur préférée pour l'arrière-plan ou le texte avant de cliquer sur OK.
Après le changement, tous ces messages rouges de Node (Ember dans mon cas) sont clairement visibles.
Avant d'installer un paquet parmi les vulnérabilités npmComme la réponse ci-dessus, qui parle d'installer un paquetage comme 'craie', etc., je cherchais également à changer la couleur de la console et je trouvais le paquet craie de la première réponse, donc quand j'installe NPM m'avertit du paquet que j'installe trouvé 3 vulnérabilités (1 faible, 1 modérée, 1 élevée)
Il s’agit d’une approche pour Windows 10 (peut-être pour 7) qui modifie le schéma de couleurs (thème) de cmd, npm terminal lui-même, et pas seulement la sortie de la console pour une application particulière.
J'ai trouvé le plug-in Windows fonctionnel - Color Tool , qui est probablement développé sous Windows. Une description est disponible sur link .
J'ai ajouté le répertoire colortool dans la variable de chemin de l'environnement système et il est désormais disponible à chaque démarrage du terminal (commande NodeJs Prompt, cmd).