ansis
v3.4.0
Eine kleine und schnelle Node.js -Bibliothek zum Auftragen von ANSI -Farben und -Istilen in der Terminalausgabe.
ANSIS bietet alle Funktionen, die Sie benötigen. Sie können mit ähnlichen Bibliotheken vergleichen.
ANSIS ist schneller als Kreide und Pikokolor (in einigen Anwendungsfällen), siehe Benchmarks.
import ansis , { red , green , cyan , black , ansi256 , hex } from 'ansis' ;
ansis . blueBright ( 'file.txt' )
green `Succeful!`
red `Error: ${ cyan ( file ) } not found!`
black . bgYellow `Warning!`
ansi256 ( 214 ) `Orange`
hex ( '#E0115F' ) . bold . underline ( 'Truecolor!' ) Die beliebtesten Node.js -Bibliotheken ähnlich wie ANSIS:
Kreide, Pikokolors, Colorette, Kleur, Ansi-Colors, Kolorist, Cli-Color, Colors-Cli, Colors.js
✅ Funktionen vergleichen? Vergleichen Sie Paketgrößen Benchmarks
chalk colorette picocolors ansi-colorsimport ansis, { red, bold, ansi256, hex } from 'ansis'red.bold.underline('text')red`Error: ${blue`file.js`} not found!`italic dim bold underline strikethroughred`Error!` redBright`Error!` bgRed`Error!` bgRedBright`Error!`fg(56)`violet` bg(208)`orange`rgb(224, 17, 95)`Ruby` hex('#96C')`Amethyst`open und close Eigenschaften `foo ${red.open}red{red.close} bar`ansis.strip()NO_COLOR FORCE_COLOR und FLAGS --no-color --colorend of line wenn n in der Zeichenfolge verwendet wirdString.prototype nichtNestjs, Facebook/Stylex, Folge, Salesforce, OCLIF, Webpackbar
Wenn Sie einen Fehler entdeckt haben oder einen Feature -Vorschlag haben, können Sie ein Problem auf GitHub erstellen.
Heute sind die beiden kleinsten und schnellsten Bibliotheken ansis und picocolors . Beide werden von der ES Tooling -Community als der beste Ersatz für ältere, sperrigere Bibliotheken empfohlen.
picocolors : 6,4 KB - Eine Mikrobibliothek mit nur grundlegenden Funktionen.аnsis : 7,4 KB - Eine leistungsstarke Bibliothek mit allen Funktionen, die Sie benötigen.chalk : 44,2 kb - bietet ANSIS ähnliche Funktionen, ist jedoch größer.picocolors : am schnellsten beim Auftragen eines einzelnen Stils (z. B. nur red ).аnsis : am schnellsten bei der Anwendung von zwei oder mehr Stilen (z. B. red + bgWhite ).chalk : In allen Anwendungsfällen langsamer als Ansis und Picocolors . Im Gegensatz zu vielen anderen Bibliotheken werden nur ansis , chalk und picocolors aktiv aufrechterhalten:
colorette : Zuletzt vor 2 Jahren aktualisiertansi-colors : Zuletzt aktualisiert vor 3 Jahrenkleur : Zuletzt aktualisiert vor 2 Jahrencli-color : Zuletzt aktualisiert ~ 1 Jahrcolors-cli : Zuletzt aktualisiert vor 1 Jahrcolors.js : Zuletzt aktualisiert vor 5 Jahren Wenn Sie nur einen einzelnen Stil wie red('foo') verwenden, ist Picocolors die beste Lösung.
Wenn Sie jedoch mehr benötigen, wie das Kombinieren mehrerer Stile (z. B. red + bold + bgWhite ),
ANSI256 Farben, Truecolor oder Unterstützung für eine Vielzahl von Umgebungen, dann ist ANSIS die bessere Wahl.
Entdecken Sie die Liste der Funktionen, Paketgrößen und Benchmarks im Vergleich zu ähnlichen Bibliotheken.
Tipp
Verwenden Sie die von Bibliotheken wie ansis und chalk bereitgestellte Kettensyntax.
Vermeiden Sie verschachtelte Anrufe, da sie viel langsamer und weniger lesbar sind als die verkettete Syntax.
Halten Sie Ihren Code sauber und lesbar!
red . bold . bgWhite `Error` ✅ ansis: faster , shorter , readable
pico . red ( pico . bold ( pico . bgWhite ( 'Error' ) ) ) picocolor: slower , longer , unreadable
red `Error: ${ cyan . underline ( file ) } not found!` ✅ ansis ?
pico . red ( `Error: ${ pico . cyan ( pico . underline ( file ) ) } not found!` ) picocolor ? chalk ersetzencolorette ersetzenpicocolors ersetzenansi-colors ersetzenkleur ersetzencli-color ersetzen npm install ansisSie können das Standardmodul oder die genannten Farben mit ESM- oder CommonJS -Syntax importieren.
// ESM default import
import ansis from 'ansis' ;
// ESM named import
import { red , green , blue } from 'ansis' ;oder
// CommonJS default import
const ansis = require ( 'ansis' ) ;
// CommonJS named import
const { red , green , blue } = require ( 'ansis' ) ;Siehe die Liste der ANSI -Farben und -stile.
console . log ( ansis . green ( 'Success!' ) ) ;
console . log ( green ( 'Success!' ) ) ;
// template string
console . log ( green `Success!` ) ;
// chained syntax
console . log ( green . bold `Success!` ) ;
// nested syntax
console . log ( red `The ${ blue . underline `file.js` } not found!` ) ; Grundlegende Beispiel Hello World! :
import { red , black , inverse , reset } from 'ansis' ;
console . log ( green `Hello ${ inverse `ANSI` } World!
${ black . bgYellow `Warning:` } ${ cyan `/path/to/file.js` } ${ red `not found!` } ` ) ; Ausgabe: 
Die ansis unterstützt sowohl den default import als auch named import .
// default import
import ansis from 'ansis' ;
ansis . red . bold ( 'text' ) ; Sie können benannte Farben, Stile und Funktionen importieren. Alle importierten Farben und Stile sind chainable .
// named import
import { red , hex , italic } from 'ansis' ;
red . bold ( 'text' ) ;Der Standardimport und der benannte Import können kombiniert werden.
// default and named import
import ansis , { red } from 'ansis' ;
const redText = red ( 'text' ) ; // colorized ANSI string
const text = ansis . strip ( redText ) ; // pure string without ANSI codes Die ansis unterstützt sowohl die Funktionssyntax red('error') als auch die Template Literals red`error` .
Mit den template literals können Sie eine komplexe Vorlage lesbarer und kürzer machen.
Die function syntax kann verwendet werden, um eine Variable zu fördern.
import { red } from 'ansis' ;
let message = 'error' ;
red ( message ) ;
red `text` ;
red `text ${ message } text` ; Alle Farben, Stile und Funktionen sind kettig. Jede Farbe oder jeder Stil kann in beliebiger Reihenfolge kombiniert werden.
import { red , bold , italic , hex } from 'ansis' ;
red . bold `text` ;
hex ( '#FF75D1' ) . bgCyan . bold `text` ;
bold . bgHex ( '#FF75D1' ) . cyan `text` ;
italic . bold . yellow . bgMagentaBright `text` ; Sie können Funktionen und Vorlagenzeichenfolgen ineinander nisten. Keine der anderen Bibliotheken (Kreide, Kleur, Colorette, Colors.js usw.) unterstützt verschachtelte Vorlagenzeichenfolgen.
Verschachtelte Vorlagenzeichenfolgen:
import { red , green } from 'ansis' ;
red `red ${ green `green` } red` ;Tiefe verschachtelte Kettenstile:
import { red , green , cyan , magenta , yellow , italic , underline } from 'ansis' ;
red ( `red ${ italic ( `red italic ${ underline ( `red italic underline` ) } ` ) } red` ) ;
// deep nested chained styles
green (
`green ${ yellow (
`yellow ${ magenta (
`magenta ${ cyan (
`cyan ${ red . italic . underline `red italic underline` } cyan` ,
) } magenta` ,
) } yellow` ,
) } green` ,
) ; Ausgabe: 
Multiline verschachtelte Vorlagenzeichenfolgen:
import { red , green , hex , visible , inverse } from 'ansis' ;
// defined a Truecolor as the constant
const orange = hex ( '#FFAB40' ) ;
let cpu = 33 ;
let ram = 44 ;
let disk = 55 ;
// normal colors
visible `
CPU: ${ red ` ${ cpu } %` }
RAM: ${ green ` ${ ram } %` }
DISK: ${ orange ` ${ disk } %` }
` ;
// inversed colors
inverse `
CPU: ${ red ` ${ cpu } %` }
RAM: ${ green ` ${ ram } %` }
DISK: ${ orange ` ${ disk } %` }
` ; Ausgabe: 
Farben und Stile haben Standardnamen, die von vielen beliebten Bibliotheken wie Kreide, Colorette, Picocolors, Kleur verwendet werden.
| Vordergrundfarben | Hintergrundfarben | Stile |
|---|---|---|
black | bgBlack | dim |
red | bgRed | bold |
green | bgGreen | italic |
yellow | bgYellow | underline |
blue | bgBlue | strikethroughstrike ) |
magenta | bgMagenta | inverse |
cyan | bgCyan | visible |
white | bgWhite | hidden |
blackBrightAliase: greygray uns Rechtschreibung | bgBlackBrightAliase: bgGreybgGray US -Rechtschreibung | reset |
redBright | bgRedBright | |
greenBright | bgGreenBright | |
yellowBright | bgYellowBright | |
blueBright | bgBlueBright | |
magentaBright | bgMagentaBright | |
cyanBright | bgCyanBright | |
whiteBright | bgWhiteBright |
Die Standardeinstellung enthält die importierte ansis -Instanz. So erweitern Sie die Grundfarben mit benutzerdefinierten Farbnamen für TrueColor -Methode ansis.extend() .
import ansis from 'ansis' ;
// extend base colors
ansis . extend ( {
pink : '#FF75D1' ,
orange : '#FFAB40' ,
} ) ;
// the custom colors are available under namespace `ansis`
ansis . pink ( 'text' ) ;
ansis . orange ( 'text' ) ;Verwendungsbeispiel mit TypeScript:
import ansis , { AnsiColorsExtend } from 'ansis' ;
// extend base colors
ansis . extend ( {
pink : '#FF75D1' ,
orange : '#FFAB40' ,
} ) ;
const write = ( style : AnsiColorsExtend < 'pink' | 'orange' > , message : string ) => {
console . log ( ansis [ style ] ( message ) ) ;
}
write ( 'red' , 'message' ) ; // base color OK
write ( 'pink' , 'message' ) ; // extended color OK
write ( 'orange' , 'message' ) ; // extended color OK
write ( 'unknown' , 'message' ) ; // TypeScript Error Der vordefinierte Satz von 256 Farben.
| Codebereich | Beschreibung |
|---|---|
| 0 - 7 | Standardfarben |
| 8 - 15 | leuchtende Farben |
| 16 - 231 | 6 × 6 × 6 Würfel (216 Farben) |
| 232 - 255 | Graustufen von Schwarz bis Weiß in 24 Schritten |
Vordergrundfunktion: ansi256(code) hat einen kurzen Alias fg(code)
Hintergrundfunktion: bgAnsi256(code) hat einen kurzen Alias bg(code)
Die Methoden
ansi256()undbgAnsi256()werden zur Kompatibilität mit derchalk-API implementiert.
Siehe ANSI -Farbcodes.
Wenn ein Terminal nur 16 Farben unterstützt, werden ANSI 256 -Farben in die Basis 16 Farben interpoliert.
import { bold , ansi256 , fg , bgAnsi256 , bg } from 'ansis' ;
// foreground color
ansi256 ( 96 ) `Bright Cyan` ;
fg ( 96 ) `Bright Cyan` ; // alias for ansi256
// background color
bgAnsi256 ( 105 ) `Bright Magenta` ;
bg ( 105 ) `Bright Magenta` ; // alias for bgAnsi256
// function is chainable
ansi256 ( 96 ) . bold `bold Bright Cyan` ;
// function is avaliable in each style
bold . ansi256 ( 96 ) . underline `bold underline Bright Cyan` ;
// you can combine the functions and styles in any order
bgAnsi256 ( 105 ) . ansi256 ( 96 ) `cyan text on magenta background`
bg ( 105 ) . fg ( 96 ) `cyan text on magenta background` Sie können das hex oder rgb -Format verwenden.
Vordergrundfunktion: hex() rgb()
Hintergrundfunktion: bgHex() bgRgb()
import { bold , hex , rgb , bgHex , bgRgb } from 'ansis' ;
// foreground color
hex ( '#E0115F' ) . bold `bold Ruby` ;
hex ( '#96C' ) `Amethyst` ;
rgb ( 224 , 17 , 95 ) . italic `italic Ruby` ;
// background color
bgHex ( '#E0115F' ) `Ruby` ;
bgHex ( '#96C' ) `Amethyst` ;
bgRgb ( 224 , 17 , 95 ) `Ruby` ;
// you can combine the functions and styles in any order
bold . hex ( '#E0115F' ) . bgHex ( '#96C' ) `ruby bold text on amethyst background` Die ansis unterstützt den Fallback im unterstützten Farbton.
Truecolor —> 256 colors —> 16 colors —> no colors (black & white)
Wenn Sie die Funktionen hex() , rgb() oder ansis256() in einem Terminal nicht unterstützt.
Sie können die ANSI -Escape -Codes mit open und close Eigenschaften für jeden Stil verwenden.
import { red , bold } from 'ansis' ;
// each style has `open` and `close` properties
console . log ( `Hello ${ red . open } ANSI ${ red . close } World!` ) ;
// you can defiene own style which will have the `open` and `close` properties
const myStyle = bold . italic . black . bgHex ( '#E0115F' ) ;
console . log ( `Hello ${ myStyle . open } ANSI ${ myStyle . close } World!` ) ; Die ANSIS -Klasse enthält die Methode strip() um alle ANSI -Codes aus String zu entfernen.
import ansis from 'ansis' ;
const ansiString = ansis . green `Hello World!` ;
const string = ansis . strip ( ansiString ) ; Die variable string enthält die reine Zeichenfolge ohne ANSI -Codes.
Unterstützt den richtigen Stilpause am end of line .
import { bgGreen } from 'ansis' ;
console . log ( bgGreen `nAnsisnNew LinenNext New Linen` ) ; 
Definieren Sie Ihre eigenen Themen:
import ansis from 'ansis' ;
const theme = {
info : ansis . cyan . italic ,
warn : ansis . black . bgYellowBright ,
error : ansis . red . bold ,
ruby : ansis . hex ( '#E0115F' ) ,
} ;
theme . info ( 'info' ) ;
theme . warn ( 'warning' ) ;
theme . error ( 'error' ) ;
theme . ruby ( 'Ruby color' ) ; Standardmäßig ist die Ausgabe in der Terminalkonsole gefärbt und die Ausgabe in einer Datei nicht.
Um die Umgebungsvariablen FORCE_COLOR NO_COLOR
Die NO_COLOR -Variable sollte mit keinem leeren Wert vorgestellt werden. Der Wert ist nicht wichtig, z. NO_COLOR=1 NO_COLOR=true deaktivierte Farben.
Siehe Standardbeschreibung von NO_COLOR.
Die Variable FORCE_COLOR sollte mit einem der Werte vorgestellt werden:
FORCE_COLOR=0 Kraft deaktivieren Farben
FORCE_COLOR=1 cross Enable Farben
Siehe Standardbeschreibung mit Force_Color.
Zum Beispiel App.js :
import { red } from 'ansis' ;
console . log ( red `red color` ) ;Führen Sie das Skript in einem Terminal aus:
$ node app.js # colored output in terminal
$ node app.js > log.txt # output in file without ANSI codes
$ NO_COLOR=1 node app.js # force disable colors, non colored output in terminal
$ FORCE_COLOR=0 node app.js # force disable colors, non colored output in terminal
$ FORCE_COLOR=1 node app.js > log.txt # force enable colors, output in file with ANSI codes
COLORTERM Die COLORTERM wird von terminalen Emulatoren verwendet, um die Unterstützung für Farben anzuzeigen. Sein Wert kann je nach dem Terminalemulator und der Bereitstellung von Farbunterstützung variieren.
Die häufig verwendeten Werte, die von ansis gestützt werden:
truecolor oder 24bit - 16 Millionen Farbenansi256 - ANSI 256 Farbenansi - Basic ANSI 16 FarbenSie können die Variable in CMD festlegen, bevor Sie das Knotenskript ausführen:
COLORTERM=truecolor node script.js # force use truecolor
COLORTERM=ansi256 node script.js # force use 256 colors
COLORTERM=ansi node script.js # force use 16 olors
Um die Farbstufe in einem Skript festzulegen, erstellen Sie eine JS -Datei, in der Sie die Variable COLORTERM mit dem erforderlichen Wert definieren, und importieren Sie diese Datei vor ansis .
Dies kann beispielsweise nützlich sein, um Ihre CLI -Anwendung zu testen, um sicherzustellen, dass die Testergebnisse unabhängig von der unterstützten Farbebene in verschiedenen Umgebungen und Klemmen gleich sind.
Level-Truecolor.js
process . env . COLORTERM = 'truecolor' ;Ihre Skriptdatei:
import './level-truecolor' ; // <= force use truecolor
import { red , ansi256 , hex } from 'ansis' ;
console . log ( hex ( '#FFAB40' ) ( 'orange' ) ) ; // native ANSI RGB color value
console . log ( ansi256 ( 200 ) ( 'pink' ) ) ; // native ANSI 256 color value
console . log ( red ( 'red' ) ) ; // native ANSI 16 color value Level-256Colors.js
process . env . COLORTERM = 'ansi256' ;Ihre Skriptdatei:
import './level-256colors' ; // <= force use 256 colors
import { red , ansi256 , hex } from 'ansis' ;
console . log ( hex ( '#FFAB40' ) ( 'orange' ) ) ; // fallback to ANSI 256 color value
console . log ( ansi256 ( 200 ) ( 'pink' ) ) ; // native ANSI 256 color value
console . log ( red ( 'red' ) ) ; // native ANSI 16 color value Level-16Colors.js
process . env . COLORTERM = 'ansi' ;Ihre Skriptdatei:
import './level-16colors' ; // <= force use 16 olors
import { red , ansi256 , hex } from 'ansis' ;
console . log ( hex ( '#FFAB40' ) ( 'orange' ) ) ; // fallback to ANSI 16 color value - `bright red`
console . log ( ansi256 ( 200 ) ( 'pink' ) ) ; // fallback to ANSI 16 color value - `bright magenta`
console . log ( red ( 'red' ) ) ; // native ANSI 16 color value Verwenden Sie CMD-Argumente --no-color oder --color=false um Farben zu deaktivieren, und --color um die zu aktivieren.
Zum Beispiel ein ausführbares Skript app.js :
#!/usr/bin/env node
import { red } from 'ansis' ;
console . log ( red `red color` ) ;Führen Sie das Skript in einem Terminal aus:
$ ./app.js # colored output in terminal
$ ./app.js --no-color # non colored output in terminal
$ ./app.js --color=false # non colored output in terminal
$ ./app.js > log.txt # output in file without ANSI codes
$ ./app.js --color > log.txt # output in file with ANSI codes
$ ./app.js --color=true > log.txt # output in file with ANSI codes
Warnung
Die Befehlszeilenargumente haben eine höhere Priorität als Umgebungsvariable.
ANSIS erkennt automatisch den unterstützten Farbraum:
ANSIS hat die Methode isSupported() die einen boolean Wert zurückgibt, ob die Ausgabe die ANSI -Farbe und -stile unterstützt.
import ansis from 'ansis' ;
console . log ( 'Color output: ' , ansis . isSupported ( ) ) ; Es gibt keine Standardmethode, um festzustellen, welcher Farbraum unterstützt wird. Der häufigste Weg, um die Farbunterstützung zu erkennen, besteht darin, den TERM und COLORTERM zu überprüfen. CI -Systeme können durch Überprüfung auf das Vorhandensein des CI und anderer spezifischer Umgebungsvariablen erkannt werden. Kombinieren Sie das mit dem Wissen darüber, welches Betriebssystem das Programm betreibt, und wir haben eine anständige Möglichkeit, Farben zu erkennen.
| Terminal | Ansi 16 Farben | ANSI 256 Farben | WAHR Farbe | env. BEGRIFF | env. Farbzeit | Speziell Env -Variablen |
|---|---|---|---|---|---|---|
| Azure CI | ✅ | dumm | Tf_build Agent_Name | |||
| Github CI | ✅ | ✅ | ✅ | dumm | CI, Github_actions | |
| Gittuea CI | ✅ | ✅ | ✅ | dumm | CI, Gitea_actions | |
| Gitlab CI | ✅ | dumm | CI, Gitlab_ci | |||
| Travis CI | ✅ | dumm | Travis | |||
| PM2 nicht istty | ✅ 1 | ✅ 1 | ✅ 1 | dumm | PM2_HOME PM_ID | |
| Jetbrains Teamcity > = 2020.1.1 | ✅ | ✅ | TeamCity_version | |||
| Jetbrains Idee | ✅ | ✅ | ✅ | Xterm-256Color | Enderinal_emulator = 'jetbrains-jediterm' | |
| Vs Code | ✅ | ✅ | ✅ | Xterm-256Color | Truecolor | |
| Fenster Terminal | ✅ | ✅ | ✅ 2 | |||
| Fenster Powershell | ✅ | ✅ | ✅ 2 | |||
| MacOS -Terminal | ✅ | ✅ | Xterm-256Color | |||
| ITERM | ✅ | ✅ | ✅ | Xterm-256Color | Truecolor | |
| Terminalemulator Kitty | ✅ | ✅ | ✅ | Xterm-Kitty | ||
| Terminalemulator Kde Konsole | ✅ | ✅ | ✅ | Xterm-Direct |
Siehe auch:
Führen Sie den Befehl aus, um die Unterstützung einiger Funktionen verschiedener Bibliotheken zu sehen:
npm run compare
| Bibliothek ________________ - Named Import - Farben benennen | Ansi 16 Farben | ANSI 256 Farben | WAHR Farbe | Angekettet Syntax | Verschachtelt Vorlagenzeichenfolgen | Neu Linie | Fallback in Farben | Unterstützung Env vars CLI -Flaggen |
|---|---|---|---|---|---|---|---|---|
ansis✅ named import✅ standard | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | → 256 → 16 → b & w | NO_COLORFORCE_COLOR--no-color--color |
chalknamed import✅ standard | ✅ | ✅ | ✅ | ✅ | ✅ | → 256 → 16 → b & w | NO_COLORFORCE_COLOR--no-color--color | |
kolorist✅ named importstandard | ✅ | ✅ | ✅ | → 256 → b & w | NO_COLORFORCE_COLOR | |||
cli-colornamed import✅ standard | ✅ | ✅ | ✅ | → 16 → b & w | NO_COLOR | |||
colors-clinamed importstandard | ✅ | ✅ | ✅ | ✅ | → b & w | --no-color--color | ||
colors.jsnamed importstandard | ✅ | ✅ | ✅ | → b & w | FORCE_COLOR--no-color--color | |||
ansi-colorsnamed import✅ standard | ✅ | ✅ | ✅ | FORCE_COLOR | ||||
colorette✅ named import✅ standard | ✅ | → b & w | NO_COLORFORCE_COLOR--no-color--color | |||||
picocolorsnamed import✅ standard | ✅ Da v1.1.0 | → b & w | NO_COLORFORCE_COLOR--no-color--color | |||||
kleur✅ named import✅ standard | 8 Farben | ✅ | → b & w | NO_COLORFORCE_COLOR |
Notiz
Named Import
ESM
import { red, green, blue } from 'lib';
CJS
const { red, green, blue } = require('lib');Namensfarben
- Standard: Farben haben Standardnamen, z.
red,redBright,bgRed,bgRedBright- Nicht standardmäßig : Farben haben lib-
red_bNamenbgBrightRedred_bttbrightRedANSI 256 Farben
Die Methodamen:
colors-cli:x<n>cli-color:xterm(n)chalk:ansi256(n)bgAnsi256(n)ansis:ansi256(n)bgAnsi256(n)fg(n)bg(n)Truecolor
Die Methodamen:
chalk:hex()rgb()ansis:hex()rgb()Gekettete Syntax
lib.red.bold('text')Verschachtelte Vorlagenzeichenfolgen
lib.red`text ${lib.cyan`nested`} text`Neue Linie
Richtige Bruchstile amend-of-line.lib.bgGreen(`First Line Next Line`);
| NPM -Paket | Laden Sie die Tarballgröße herunter | Ausgepackte Größe | Codegröße |
|---|---|---|---|
picocolors | 2,6 kb | 6,4 kb | 2,6 kb |
ansis | 3,8 kb | 7,4 kb | 3,4 kb |
colorette | 4,9 kb | 17.0 kb | 3,4 kb |
kleur | 6,0 kb | 20,3 kb | 2,7 kb |
ansi-colors | 8,5 kb | 26.1 kb | 5,8 kb |
kolorist | 8,7 kb | 51,0 kb | 6,8 kb |
colors.js | 11.0 kb | 39,5 kb | 18.1 KB |
chalk | 13.1 kb | 43,7 kb | 16,4 kb |
cli-color | 13,8 (216 KB) | 39,6 (754 kb) | 12.1 kb |
colors-cli | 361,7 kb | 511.0 kb | 8,7 kb |
Download -Größe: Die GZIP -Größe des NPM -Pakets.
Auspackte Größe: Die Größe des NPM -Pakets im node_modules/ Verzeichnis (incl. dependencies) .
Codegröße : Die Größe des verteilten Codes, der über require geladen oder in Ihre App import .
Siehe auch:
git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run demoZur Messung der Leistung wird Benchmark.js verwendet.
Warnung
Der vitest benchmark erzeugt falsche/ unwirkliche Ergebnisse.
Zum Beispiel die Ergebnisse der einfachen Bank:
chalk.red('foo') - 7.000.000 ops/sec
ansis.red('foo') - 23.000.000 ops/sec (x3 faster is WRONG result)
Die tatsächlichen Leistungsergebnisse von Kreide und ANSIS in diesem Test sind sehr ähnlich.
git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run build
npm run benchGetestet auf
MacBook Pro 16 "M1 Max 64 GB
MacOS Sequoia 15.1
Node.js v22.11.0
TerminaliTerm2V3.5.0
Notiz
In den Tests verwendet jede Bibliothek die schnellste Styling -Methode, um die absolute Leistung jeder Bibliothek zu vergleichen.
In der realen Praxis würde niemand die langsamste Methode (z. B. verschachtelte Anrufe) verwenden, um eine Zeichenfolge zu stylen, wenn die Bibliothek eine schnellere und eine kürzere Kettenmethode bietet.
Zum Beispiel:
lib . red . bold . bgWhite ( ' ERROR ' ) // ✅ faster, shorter, readable
lib . red ( lib . bold ( lib . bgWhite ( ' ERROR ' ) ) ) // slower, longer, unreadable Der einfache Test verwendet nur einen einzelnen Stil. Picocolors, Colorette und Kleur unterstützen keine Kettensyntax oder korrekte Stilunterbrechung (verwendet `n` in einer Saite), sodass sie in diesem einfachen Anwendungsfall am schnellsten sind. Keine Funktion, keine Leistungsaufwand .
ansis . red ( 'foo' )
chalk . red ( 'foo' )
picocolors . red ( 'foo' )
. . . + [email protected] 109.212.939 ops/sec
[email protected] 108.044.800 ops/sec
[email protected] 87.800.739 ops/sec
- > [email protected] 60.606.043 ops/sec -44.5%
- [email protected] 55.702.479 ops/sec -48.9%
[email protected] 37.069.069 ops/sec
[email protected] 14.364.378 ops/sec
[email protected] 7.060.583 ops/sec
[email protected] 2.753.751 ops/sec
[email protected] 897.746 ops/secMit nur 2 Stilen ist Picocolors bereits etwas langsamer, da die Verwendung der geketteten Syntax schneller ist als verschachtelte Anrufe.
ansis . red . bold ( 'foo' )
chalk . red . bold ( 'foo' )
picocolors . red ( picocolors . bold ( 'foo' ) ) // chained syntax is not supported
. . . + [email protected] 60.468.181 ops/sec
- [email protected] 58.777.183 ops/sec -2.8%
- [email protected] 47.789.020 ops/sec -21.5%
[email protected] 33.387.988 ops/sec
[email protected] 13.420.047 ops/sec
[email protected] 5.972.681 ops/sec
[email protected] 4.086.412 ops/sec
[email protected] 3.018.244 ops/sec
[email protected] 1.817.039 ops/sec
[email protected] 695.601 ops/secMit 3 Stilen ist Picocolors 2x langsamer als Ansis.
ansis . red . bold . bgWhite ( 'foo' )
chalk . red . bold . bgWhite ( 'foo' )
picocolors . red ( picocolors . bold ( picocolors . bgWhite ( 'foo' ) ) ) // chained syntax is not supported
. . . + [email protected] 59.463.640 ops/sec
- [email protected] 42.166.783 ops/sec -29.0%
- [email protected] 32.434.017 ops/sec -45.5% (~2x slower than Ansis)
[email protected] 13.008.117 ops/sec
[email protected] 5.608.244 ops/sec
[email protected] 5.268.630 ops/sec
[email protected] 2.145.517 ops/sec
[email protected] 1.686.728 ops/sec
[email protected] 1.453.611 ops/sec
[email protected] 590.467 ops/secIn seltenen Fällen wird Pikokolor bei der Verwendung von 4 Stilen 3,4x langsamer als Ansis.
ansis . red . bold . underline . bgWhite ( 'foo' )
chalk . red . bold . underline . bgWhite ( 'foo' )
picocolors . red ( picocolors . bold ( picocolors . underline ( picocolors . bgWhite ( 'foo' ) ) ) ) // chained syntax is not supported
. . . + [email protected] 59.104.535 ops/sec
- [email protected] 36.147.547 ops/sec -38.8%
- [email protected] 17.581.709 ops/sec -70.2% (~3x slower than Ansis)
[email protected] 7.981.171 ops/sec
[email protected] 4.825.665 ops/sec
[email protected] 3.729.880 ops/sec
[email protected] 1.514.053 ops/sec
[email protected] 1.229.999 ops/sec
[email protected] 1.210.931 ops/sec
[email protected] 481.073 ops/secDer komplexe Test mit tief verschachtelten Einzelstilen.
c . green (
`green ${ c . cyan (
`cyan ${ c . red (
`red ${ c . yellow (
`yellow ${ c . blue (
`blue ${ c . magenta ( `magenta ${ c . underline ( `underline ${ c . italic ( `italic` ) } underline` ) } magenta` ) } blue` ,
) } yellow` ,
) } red` ,
) } cyan` ,
) } green` ,
) + [email protected] 1.110.056 ops/sec
- [email protected] 1.073.299 ops/sec
- > [email protected] 847.246 ops/sec -23.7%
[email protected] 847.110 ops/sec
- [email protected] 573.942 ops/sec -48.3%
[email protected] 471.285 ops/sec
[email protected] 439.588 ops/sec
[email protected] 382.862 ops/sec
[email protected] 213.351 ops/sec
[email protected] 41.097 ops/sec Der in colorette für einzelne Stile verwendete Benchmark.
c . red ( ` ${ c . bold ( ` ${ c . cyan ( ` ${ c . yellow ( 'yellow' ) } cyan` ) } ` ) } red` ) + [email protected] 3.861.384 ops/sec
[email protected] 3.815.039 ops/sec
- > [email protected] 2.918.269 ops/sec -24.4%
[email protected] 2.548.564 ops/sec
- [email protected] 2.502.850 ops/sec -35.2%
[email protected] 2.229.023 ops/sec
[email protected] 1.426.279 ops/sec
[email protected] 1.123.139 ops/sec
[email protected] 481.708 ops/sec
[email protected] 114.570 ops/sec Der picocolors -Benchmark, leicht modifiziert. Ein bisschen mehr Komplexität hinzugefügt, indem zwei Stile auf das farbige Wort anstelle eines angewendet wurden.
let index = 1e8 ;
c . red ( '.' ) +
c . yellow ( '.' ) +
c . green ( '.' ) +
c . red . bold ( ' ERROR ' ) +
c . red ( 'Add plugin ' + c . cyan . underline ( 'name' ) + ' to use time limit with ' + c . cyan ( ++ index ) ) ; + [email protected] 2.601.559 ops/sec
- > [email protected] 2.501.227 ops/sec -3.8%
[email protected] 2.326.491 ops/sec
- [email protected] 2.129.106 ops/sec -18.1%
[email protected] 1.780.496 ops/sec
[email protected] 1.685.703 ops/sec
[email protected] 838.542 ops/sec
[email protected] 533.362 ops/sec
[email protected] 287.558 ops/sec
[email protected] 97.463 ops/secNotiz
In diesem Test, der näher am praktischen Gebrauch liegt, verwendet jede Bibliothek die schnellste verfügbare Styling -Methode.
Also, chalk , ansis , ansi-colors , cli-color , colors-cli und colors verwenden eine Kettenmethode, z. B. c.red.bold(' ERROR ') . Während picocolors , colorette und kolorist verschachtelte Anrufe verwenden, z. c.red(c.bold(' ERROR ')) , da die verkettete Syntax nicht unterstützt.
ANSIS ist ein leistungsstarker, kleiner und schneller Ersatz, der für viele ähnliche Bibliotheken keine Codemigration erfordert.
Ersetzen Sie einfach Ihren import ... from ... oder require(...) durch ansis .
- import chalk from 'chalk';
+ import chalk from 'ansis';ANSIS unterstützt die Kreidesyntax und ist kompatibel* mit Stilen und Farbnamen, sodass Sie den ursprünglichen Code nicht ändern müssen:
chalk . red . bold ( 'Error!' ) ;
// colorize "Error: file not found!"
chalk . red ( `Error: ${ chalk . cyan . bold ( 'file' ) } not found!` ) ;
// ANSI 256 colors
chalk . ansi256 ( 93 ) ( 'Violet color' ) ;
chalk . bgAnsi256 ( 194 ) ( 'Honeydew, more or less' ) ;
// truecolor
chalk . hex ( '#FFA500' ) . bold ( 'Bold orange color' ) ;
chalk . rgb ( 123 , 45 , 67 ) . underline ( 'Underlined reddish color' ) ;
chalk . bgHex ( '#E0115F' ) ( 'Ruby' ) ;
chalk . bgHex ( '#96C' ) ( 'Amethyst' ) ; Warnung
Ansis unterstützt den overline nicht, da er nicht weit verbreitet ist und niemand ihn benutzt.
Überprüfen Sie den Code und entfernen Sie den overline :
- chalk.red.overline('text');
+ chalk.red('text');Optional können Sie den gleichen Code umschreiben, um ihn noch kürzer und sauberer zu machen:
import { red , cyan , ansi256 , bgAnsi256 , fg , bg , hex , rgb , bgHex , bgRgb } from 'ansis' ;
red . bold ( 'Error!' ) ; // using parentheses
red . bold `Error!` ; // using template string
// colorize "Error: file not found!"
red `Error: ${ cyan . bold `file` } not found!` ;
// ANSI 256 colors
ansi256 ( 93 ) `Violet color` ;
bgAnsi256 ( 194 ) `Honeydew, more or less` ;
fg ( 93 ) `Violet color` ; // alias for ansi256
bg ( 194 ) `Honeydew, more or less` ; // alias for bgAnsi256
// truecolor
hex ( '#FFA500' ) . bold `Bold orange color` ;
rgb ( 123 , 45 , 67 ) . underline `Underlined reddish color` ;
bgHex ( '#E0115F' ) `Ruby` ;
bgHex ( '#96C' ) `Amethyst` ; - import { red, bold, underline } from 'colorette';
+ import { red, bold, underline } from 'ansis'; ANSIS ist vollständig kompatibel mit colorette -Stilen und Farbnamen, sodass Sie den Originalcode nicht ändern müssen:
red . bold ( 'Error!' ) ;
bold ( `I'm ${ red ( `da ba ${ underline ( "dee" ) } da ba` ) } daa` ) ;Optional können Sie den gleichen Code umschreiben, um ihn noch kürzer und sauberer zu machen:
red . bold `Error!` ;
bold `I'm ${ red `da ba ${ underline `dee` } da ba` } daa` ; - import pico from 'picocolors';
+ import pico from 'ansis'; ANSIS ist vollständig kompatibel mit picocolors -Stilen und Farbnamen, sodass Sie den ursprünglichen Code nicht ändern müssen:
pico . red ( pico . bold ( 'text' ) ) ;
pico . red ( pico . bold ( variable ) ) ;
// colorize "Error: file not found!"
pico . red ( 'Error: ' + pico . cyan ( pico . bold ( 'file' ) ) + ' not found!' ) ;Optional können Sie den gleichen Code umschreiben, um ihn noch kürzer und sauberer zu machen:
import { red , cyan } from 'ansis' ;
red . bold `text` ;
red . bold ( variable ) ;
// colorize "Error: file not found!"
red `Error: ${ cyan . bold `file` } not found!` - const c = require('ansi-colors');
+ const c = require('ansis'); ANSIS ist vollständig kompatibel mit ansi-color und Farbnamen, sodass Sie den ursprünglichen Code nicht ändern müssen:
c . red . bold ( 'Error!' ) ;
// colorize "Error: file not found!"
c . red ( `Error: ${ c . cyan . bold ( 'file' ) } not found!` ) ;Optional können Sie den gleichen Code umschreiben, um ihn noch kürzer und sauberer zu machen:
import { red , cyan } from 'ansis' ;
red . bold ( 'Error!' ) ; // using parentheses
red . bold `Error!` ; // using template string
// colorize "Error: file not found!"
red `Error: ${ cyan . bold `file` } not found!` ; - import { red, green, yellow, cyan } from 'kleur';
+ import { red, green, yellow, cyan } from 'ansis'; ANSIS ist voll kompatibel mit kleur -Stilen und Farbnamen, aber Kleur v3.0 verwendet keine Syntax im Kreidestil (Magical Getter):
green ( ) . bold ( ) . underline ( 'this is a bold green underlined message' ) ;
yellow ( `foo ${ red ( ) . bold ( 'red' ) } bar ${ cyan ( 'cyan' ) } baz` ) ; Wenn Sie verkettete Methoden verwenden, erfordert es eine einfache Codeänderung. Einfach ersetzen (). mit . :
green . bold . underline ( 'this is a bold green underlined message' ) ;
yellow ( `foo ${ red . bold ( 'red' ) } bar ${ cyan ( 'cyan' ) } baz` ) ;Optional können Sie den gleichen Code umschreiben, um ihn noch kürzer und sauberer zu machen:
yellow `foo ${ red . bold `red` } bar ${ cyan `cyan` } baz` ; - const clc = require('cli-color');
+ const clc = require('ansis'); ANSIS ist kompatibel* mit cli-color -Stilen und Farbnamen:
clc . red . bold ( 'Error!' ) ;
// colorize "Error: file not found!"
clc . red ( `Error: ${ c . cyan . bold ( 'file' ) } not found!` ) ; Warnung
Ansis unterstützt den blink -Stil nicht, da er nicht weit verbreitet ist und niemand ihn benutzt.
Überprüfen Sie den Code und entfernen Sie den blink :
- clc.red.blink('text');
+ clc.red('text'); Wenn Sie ANSI 256 -Farbfunktionen xterm oder bgXterm verwenden, müssen diese durch ansi256 fn oder bgAnsi256 bg ersetzt werden:
- clc.xterm(202).bgXterm(236)('Orange text on dark gray background');
+ clc.ansi256(202).bgAnsi256(236)('Orange text on dark gray background');Optional können Sie den gleichen Code umschreiben, um ihn noch kürzer und sauberer zu machen:
import { red , cyan , fg , bg } from 'ansis' ;
red . bold `Error!` ;
// colorize "Error: file not found!"
red `Error: ${ cyan . bold `file` } not found!` ;
fg ( 202 ) . bg ( 236 ) `Orange text on dark gray background` ; npm run test führt die Einheiten- und Integrationstests aus.
npm run test:coverage führt die Tests mit Abdeckung durch.
ISC
Die unterstützten Farben hängen vom tatsächlichen Terminal ab. ↩ ↩ 2 ↩ 3
Das Windows-Terminal unterstützt die echte Farbe seit Windows 10 Revision 14931 (2016-09-21). ↩ ↩ 2
