如何更改 node.js 的控制台字体颜色？

我发现上面的这个答案（https://stackoverflow.com/a/41407246/4808079）非常有用，但不完整。如果你只想给某样东西上色一次，我想它会很好，但我认为以可运行的函数形式共享它更适用于现实生活中的用例。

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 colorLog(color, ...args) {
  console.log(...args.map(
   (it) => typeof it === "string" ? colorString(color, string) : it
  ));
}

像这样使用它：

colorLog(Color.FgYellow, "Some Yellow text to console log", { someObj: true });

console.log([
  colorString(Color.FgRed, "red"),
  colorString(Color.FgGreen, "green"),
  colorString(Color.FgBlue, "blue"),
].join(", "));

Sindre Sorhus 的这个图书馆是目前最好的：

粉笔

高性能

不扩展 String.prototype

富有表现力的 API

嵌套样式的能力

干净而专注

自动检测颜色支持

积极维护

被 5500 多个模块使用

如果您想保持简单而不使用任何外部模块/学习新的 API/破解核心 console 函数：

const LCERROR = '\x1b[31m%s\x1b[0m'; //red
const LCWARN = '\x1b[33m%s\x1b[0m'; //yellow
const LCINFO = '\x1b[36m%s\x1b[0m'; //cyan
const LCSUCCESS = '\x1b[32m%s\x1b[0m'; //green

const logger = class {
  static error(message, ...optionalParams) { console.error(LCERROR, message, ...optionalParams) }
  static warn(message, ...optionalParams) { console.warn(LCWARN, message, ...optionalParams) }
  static info(message, ...optionalParams) { console.info(LCINFO, message, ...optionalParams) }
  static success(message, ...optionalParams) { console.info(LCSUCCESS, message, ...optionalParams) }
}

// then instead (as presented in the accepted answer)
// console.error(LCERROR, 'Error message in red.');
// you write:

logger.error('Error message in red.');

// or with multiple parameters (only the message will be red):

logger.error('Error message in red.', 1, false, null, {someKey: 'whatever'});

// or use backticks (template literal) instead multiple params:

logger.error(`This will be red as ${foo} and ${bar} too.`);

现在您可以像使用 console 一样使用您的 logger。没有要记住的新 API... 通常您会将其放入模块 (logger.js) 中并导出 class 以便能够在您的应用程序中的任何地方使用它作为 const logger = require('./logger');

对于不与 String 对象的内置方法混淆的 colors 的流行替代方案，我建议查看 cli-color。

包括颜色和可链接的样式，例如粗体、斜体和下划线。

有关此类别中各种模块的比较，请参阅 here。

没有库，没有复杂性，很简单：

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

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

我重载了控制台方法。

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

输出是。

https://i.stack.imgur.com/JIYec.png

今天有两种方法可以查看更改 Node.js 控制台的颜色。

一种是通过通用库，它可以用颜色标签装饰文本字符串，然后通过标准 console.log 输出。

今天的顶级库：

粉笔

颜色

cli颜色

另一种方式 - 修补现有的控制台方法。一个这样的库 - manakin 允许您为所有控制台方法（log、warn、error 和 info）自动设置标准颜色。

与通用颜色库的一个显着区别 - 它可以在全局或本地设置颜色，同时为每个 Node.js 控制台方法保持一致的语法和输出格式，然后您无需指定颜色即可使用，因为它们都是自动设置的.

由于眼睛问题，我不得不将控制台背景颜色更改为白色，但字体是灰色的，这使得消息无法阅读。我怎样才能改变它？

专门针对您的问题，这是最简单的解决方案：

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

它将为您的应用程序中的每个 console.log 调用设置黑色。请参阅more color codes。

manakin 使用的默认颜色：

https://i.stack.imgur.com/z00iQ.jpg

油漆控制台

简单的可着色日志。支持检查对象和单行更新这个包只是重绘控制台。

安装

npm install paint-console

用法

require('paint-console');

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

demo

遇到这个问题，并想在标准输出上使用一些颜色而没有任何依赖。这结合了这里的其他一些很好的答案。

这就是我所拥有的。 （需要节点 v4 或更高版本）

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

只需要文件，然后像这样使用它：

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

预定义的颜色代码可用here

我不希望对此有任何依赖，只有这些在 OS X 上对我有用。此处答案中的所有其他示例都给了我 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"

来源：https://coderwall.com/p/yphywg/printing-colorful-text-in-terminal-when-run-node-js-script

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

记录器/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');
        }
    });
}

应用程序.js

require('./logger')();

然后像这样使用它：

console.logBgGreen(" grüner Hintergrund ")

这在某种程度上取决于您所在的平台。最常见的方法是打印 ANSI 转义序列。举个简单的例子，这里有一些来自 blender 构建脚本的 python 代码：

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

要使用这样的代码，您可以执行以下操作

console.log(`${bColors.WARNING} My name is sami ${bColors.ENDC}`)

冷却器

它非常适合使用或扩展。您可以简单地使用：

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

或使用配置：

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

扩展起来真的很有趣：

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

View Coolors module

我创建了自己的模块 StyleMe。我做到了，所以我可以用很少的打字做很多事情。例子：

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.

它也可以嵌套：

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

或者，如果您不想扩展字符串原型，则可以使用其他 3 个选项中的任何一个：

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

您也可以使用 colorworks。

用法：

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

为了让生活更轻松，您还可以使用它创建一个函数。

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

现在你可以这样做：

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

我在我的片段目录中创建了一个名为 styles.js 的文件，我认为它可能对任何想要导入单个文件的人有所帮助。

这是对 styles.js file of color.js 的一个小修改，对我帮助很大。

这是文件的内容：

// Original: https://github.com/Marak/colors.js/blob/master/lib/styles.js

const styleCodes = {
    // Reset all styles.
    reset: [0, 0],
    
    // Text styles.
    bold: [1, 22],
    dim: [2, 22],
    italic: [3, 23],
    underline: [4, 24],
    inverse: [7, 27],
    hidden: [8, 28],
    strikethrough: [9, 29],
    
    // Foregound classic colours.
    fgBlack: [30, 39],
    fgRed: [31, 39],
    fgGreen: [32, 39],
    fgYellow: [33, 39],
    fgBlue: [34, 39],
    fgMagenta: [35, 39],
    fgCyan: [36, 39],
    fgWhite: [37, 39],
    fgGray: [90, 39],
    
    // Foreground bright colours.
    fgBrightRed: [91, 39],
    fgBrightGreen: [92, 39],
    fgBrightYellow: [93, 39],
    fgBrightBlue: [94, 39],
    fgBrightMagenta: [95, 39],
    fgBrightCyan: [96, 39],
    fgBrightWhite: [97, 39],

    // Background basic colours.
    bgBlack: [40, 49],
    bgRed: [41, 49],
    bgGreen: [42, 49],
    bgYellow: [43, 49],
    bgBlue: [44, 49],
    bgMagenta: [45, 49],
    bgCyan: [46, 49],
    bgWhite: [47, 49],
    bgGray: [100, 49],
    bgGrey: [100, 49],
    
    // Background bright colours.
    bgBrightRed: [101, 49],
    bgBrightGreen: [102, 49],
    bgBrightYellow: [103, 49],
    bgBrightBlue: [104, 49],
    bgBrightMagenta: [105, 49],
    bgBrightCyan: [106, 49],
    bgBrightWhite: [107, 49],
};

// This object will contain the string representation for all style codes.
const styles = {};

// Loop over all the style codes and assign them to the `styles` object.
// 
// The a `styleCode` in the `styleCodes` object consists of two numbers:
// Index 0: The opening style code (In HTML this can be the opening <b> tag).
// Index 1: The closing style code (In HTML this can be the closing </b> tag).
for (let styleCode of Object.keys(styleCodes)) {
    styles[styleCode] = {
        open: `\x1B[${styleCodes[styleCode][0]}m`,
        close: `\x1B[${styleCodes[styleCode][1]}m`,
    };
}

module.exports = styles;

它实际上很容易使用。

const styles = require("/path/to/styles.js");

// Let's say we've got an error:
const errorOpen = styles.bold.open + styles.bgRed.open + styles.fgWhite.open;
const errorClose = styles.reset.close; // Close everything
console.log(errorOpen, "ERROR", errorClose, ": Missing semicolon at line 9.");

2017 年：

简单的方法，为消息添加时间颜色，您无需更改代码，使用保留您的 console.log('msg') 或 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)
    );
  };
});

https://i.stack.imgur.com/IFaBj.png

如果您使用的是 Windows CMD，请转到终端属性/颜色（CMD 左上角），然后重新定义攻击性颜色的 RGB 值。在我的例子中，我相信它是左起第五个颜色方块，我将其更改为 (222,222,222)。当前选择的单选按钮是否显示屏幕文本或屏幕背景并不重要，因为您只需重新定义该特定的“系统”颜色。更改颜色后，请不要忘记在单击“确定”之前为背景或文本选择首选颜色。

更改后，来自 Node（在我的情况下为 Ember）的所有这些微红色消息都清晰可见。

在 ubuntu 中，您可以简单地使用颜色代码：

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

node-colorify

提供以彩色打印文本以及进行文本格式化（例如粗体、闪烁等）的功能。