ansis
v3.4.0
Uma biblioteca pequena e rápida do Node.js para aplicar cores e estilos ANSI na saída do terminal.
A ANSIS fornece todos os recursos necessários, você pode comparar com bibliotecas semelhantes.
O ANSIS é mais rápido que o giz e o picocolors (em alguns casos de uso), consulte 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!' ) As bibliotecas Node.js mais populares semelhantes ao ANSIS:
giz, picocolors, colorette, kleur, Ansi-colors, kolorista, cor da cor, cores cli, colors.js
✅ Compare os recursos? Compare benchmarks de tamanhos de pacotes
chalk colorette picocolors ansi-colorsimport ansis, { red, bold, ansi256, hex } from 'ansis'red.bold.underline('text')red`Error: ${blue`file.js`} not found!`dim bold italic underline strikethroughred`Error!` redBright`Error!` bgRed`Error!` bgRedBright`Error!`fg(56)`violet` bg(208)`orange`rgb(224, 17, 95)`Ruby` hex('#96C')`Amethyst`open e close `foo ${red.open}red{red.close} bar`ansis.strip()NO_COLOR FORCE_COLOR e sinalizadores --no-color --colorend of line quando usado n em stringString.prototypeNestjs, Facebook/Stylex, Sequelizar, Salesforce, OCLIF, Webpackbar
Se você descobriu um bug ou tem uma sugestão de recursos, fique à vontade para criar um problema no Github.
Hoje, as duas bibliotecas menores e mais rápidas são ansis e picocolors . Ambos são recomendados pela comunidade de ferramentas ES como as melhores substituições para bibliotecas mais antigas e volumosas.
picocolors : 6,4 KB - Uma micro biblioteca com apenas recursos básicos.аnsis : 7,4 KB - Uma biblioteca poderosa que contém todos os recursos necessários.chalk : 44,2 KB - fornece funcionalidade semelhante ao ANSIS, mas é maior.picocolors : o mais rápido ao aplicar um único estilo (por exemplo, somente red ).аnsis : o mais rápido ao aplicar dois ou mais estilos (por exemplo, red + bgWhite ).chalk : mais lento que Ansis e Picocolors em todos os casos de uso. Apenas ansis , chalk e picocolors são mantidos ativamente, ao contrário de muitas outras bibliotecas:
colorette : Última atualização 2 anos atrásansi-colors : Última atualização 3 anos atráskleur : Última atualização 2 anos atráscli-color : Última atualização ~ 1 ano atráscolors-cli : Última atualização 1 ano atráscolors.js : Última atualização 5 anos atrás Se você usa apenas um único estilo, como red('foo') , o Picocolors é a melhor solução.
No entanto, se você precisar de mais, como combinar vários estilos (por exemplo, red + bold + bgWhite ),
Cores ANSI256, Truecolor ou suporte para uma ampla gama de ambientes, então ANSIS é a melhor escolha.
Explore a lista de recursos, tamanhos de pacotes e benchmarks em comparação com bibliotecas semelhantes.
Dica
Use a sintaxe encadeada fornecida por bibliotecas como ansis e chalk .
Evite chamadas aninhadas, pois são muito mais lentas e menos legíveis que a sintaxe encadeada.
Mantenha seu código limpo e legível!
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 ? chalkcolorettepicocolorsansi-colorskleurcli-color npm install ansisVocê pode importar módulo padrão ou cores nomeadas com sintaxe ESM ou CommonJS.
// ESM default import
import ansis from 'ansis' ;
// ESM named import
import { red , green , blue } from 'ansis' ;ou
// CommonJS default import
const ansis = require ( 'ansis' ) ;
// CommonJS named import
const { red , green , blue } = require ( 'ansis' ) ;Veja a lista das cores e estilos ANSI.
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!` ) ; Exemplo básico 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!` } ` ) ; Saída: 
O ansis suporta a default import e named import .
// default import
import ansis from 'ansis' ;
ansis . red . bold ( 'text' ) ; Você pode importar cores, estilos e funções nomeadas. Todas as cores e estilos importados são chainable .
// named import
import { red , hex , italic } from 'ansis' ;
red . bold ( 'text' ) ;A importação padrão e a importação nomeada podem ser combinadas.
// 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 O ansis suporta a sintaxe da função red('error') e Modelo Literais red`error` .
Os template literals permitem que você faça um modelo complexo mais legível e mais curto.
A function syntax pode ser usada para colorizar uma variável.
import { red } from 'ansis' ;
let message = 'error' ;
red ( message ) ;
red `text` ;
red `text ${ message } text` ; Todas as cores, estilos e funções são encaderáveis. Cada cor ou estilo pode ser combinado em qualquer ordem.
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` ; Você pode aninhar as funções e as cordas de modelos umas sobre as outras. Nenhuma das outras bibliotecas (giz, kleur, colorette, colors.js etc.) suporta strings de modelo aninhados.
Strings de modelo aninhados:
import { red , green } from 'ansis' ;
red `red ${ green `green` } red` ;Estilos acorrentados aninhados profundos:
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` ,
) ; Saída: 
Strings de modelo aninhados multilinas:
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 } %` }
` ; Saída: 
Cores e estilos têm nomes padrão usados por muitas bibliotecas populares, como giz, colorette, picocolors, kleur.
| Cores de primeiro plano | Cores de fundo | Estilos |
|---|---|---|
black | bgBlack | dim |
red | bgRed | bold |
green | bgGreen | italic |
yellow | bgYellow | underline |
blue | bgBlue | strikethroughstrike ) |
magenta | bgMagenta | inverse |
cyan | bgCyan | visible |
white | bgWhite | hidden |
blackBrightAliases: greyOrtografia gray dos EUA | bgBlackBrightAliases: bgGreybgGray US SPLINCE | reset |
redBright | bgRedBright | |
greenBright | bgGreenBright | |
yellowBright | bgYellowBright | |
blueBright | bgBlueBright | |
magentaBright | bgMagentaBright | |
cyanBright | bgCyanBright | |
whiteBright | bgWhiteBright |
Padrões, a instância ansis importado contém estilos e cores base. Para estender as cores base com nomes de cores personalizados para Truecolor, use o método 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' ) ;Exemplo de uso com o 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 O conjunto predefinido de 256 cores.
| Intervalo de código | Descrição |
|---|---|
| 0 - 7 | cores padrão |
| 8 - 15 | cores brilhantes |
| 16 - 231 | Cubo 6 × 6 × 6 (216 cores) |
| 232 - 255 | escala de cinza de preto e branco em 24 etapas |
Função em primeiro plano: ansi256(code) possui um alias curto fg(code)
Função de fundo: bgAnsi256(code) possui alias curtas bg(code)
Os métodos
ansi256()ebgAnsi256()são implementados para compatibilidade com a APIchalk.
Veja os códigos de cores ANSI.
Se um terminal suportar apenas 16 cores, as cores ANSI 256 serão interpoladas em Base 16 cores.
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` Você pode usar o formato hex ou rgb .
Função em primeiro plano: hex() rgb()
Função de fundo: 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` O ansis suporta fallback para o espaço de cores suportado.
Truecolor —> 256 colors —> 16 colors —> no colors (black & white)
Se você usar as funções hex() , rgb() ou ansis256() em um terminal não suportado Truecolor ou 256 cores, as cores serão interpoladas.
Você pode usar os códigos ANSI Escape com propriedades open e close para cada estilo.
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!` ) ; A classe ANSIS contém a strip() para remover todos os códigos ANSI da string.
import ansis from 'ansis' ;
const ansiString = ansis . green `Hello World!` ;
const string = ansis . strip ( ansiString ) ; A string variável conterá a sequência pura sem códigos ANSI.
Suporta a quebra de estilo correto no end of line .
import { bgGreen } from 'ansis' ;
console . log ( bgGreen `nAnsisnNew LinenNext New Linen` ) ; 
Defina seus próprios temas:
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' ) ; Padrões, a saída no console do terminal é colorida e a saída em um arquivo não é colorida.
Para forçar desativar ou ativar a saída colorida, use variáveis de ambiente NO_COLOR e FORCE_COLOR .
A variável NO_COLOR deve ser apresentada com qualquer valor não vazio. O valor não é importante, por exemplo, NO_COLOR=1 NO_COLOR=true Desative Colors.
Consulte Descrição padrão por NO_COLOR.
A variável FORCE_COLOR deve ser apresentada com um dos valores:
FORCE_COLOR=0 Força Desativar as cores
FORCE_COLOR=1 Força Ativar cores
Veja a descrição padrão por force_color.
Por exemplo, App.js :
import { red } from 'ansis' ;
console . log ( red `red color` ) ;Execute o script em um terminal:
$ 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 A variável de ambiente COLORTERM é usada pelos emuladores do terminal para indicar suporte para cores. Seu valor pode variar dependendo do emulador de terminal e do nível de suporte de cores fornecido.
Os valores comumente usados suportados pelo ansis :
truecolor ou 24bit - 16 milhões de coresansi256 - ANSI 256 coresansi - ANSI BASIC 16 CORESVocê pode definir a variável no CMD antes de executar o script do nó:
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
Para definir o nível de cor em um script, crie um arquivo JS no qual você define a variável de ambiente COLORTERM com o valor necessário e importe esse arquivo antes ansis .
Isso pode ser útil, por exemplo, para testar seu aplicativo CLI para garantir que os resultados do teste sejam os mesmos, independentemente do nível de cor suportado em diferentes ambientes e terminais.
nível-truecolor.js
process . env . COLORTERM = 'truecolor' ;Seu arquivo de script:
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 nível 256Colors.JS
process . env . COLORTERM = 'ansi256' ;Seu arquivo de script:
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 Nível-16Colors.js
process . env . COLORTERM = 'ansi' ;Seu arquivo de script:
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 Use argumentos de CMD --no-color ou --color=false para desativar cores e --color para ativar as.
Por exemplo, um script executável app.js :
#!/usr/bin/env node
import { red } from 'ansis' ;
console . log ( red `red color` ) ;Execute o script em um terminal:
$ ./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
Aviso
Os argumentos da linha de comando têm uma prioridade mais alta que a variável do ambiente.
Ansis detecta automaticamente o espaço de cores suportado:
A ANSIS possui o método isSupported() que retorna um valor boolean se a saída suporta a ANSI cor e os estilos.
import ansis from 'ansis' ;
console . log ( 'Color output: ' , ansis . isSupported ( ) ) ; Não existe uma maneira padrão de detectar qual espaço de cor é suportado. A maneira mais comum de detectar o suporte a cores é verificar o TERM e as variáveis de ambiente COLORTERM . Os sistemas de IC podem ser detectados verificando a existência do CI e outras variáveis especificamente de ambiente. Combine isso com o conhecimento sobre qual sistema operacional o programa está em execução e temos uma maneira decente o suficiente para detectar cores.
| terminal | ANSI 16 cores | ANSI 256 cores | Verdadeiro Cor | Env. PRAZO | Env. Colorterm | Variáveis especificamente ENV |
|---|---|---|---|---|---|---|
| Azure CI | ✅ | burro | Tf_build Agente_name | |||
| Github CI | ✅ | ✅ | ✅ | burro | CI, Github_Actions | |
| Gittea CI | ✅ | ✅ | ✅ | burro | CI, Gitea_Actions | |
| Gitlab CI | ✅ | burro | CI, gitlab_ci | |||
| Travis CI | ✅ | burro | Travis | |||
| PM2 não é Istty | ✅ 1 | ✅ 1 | ✅ 1 | burro | Pm2_home pm_id | |
| JetBrains Teamcity > = 2020.1.1 | ✅ | ✅ | Teamcity_version | |||
| Ideia de jetbrains | ✅ | ✅ | ✅ | Xterm-256Color | Terminal_emulator = 'jetbrains-jediterm' | |
| Vs código | ✅ | ✅ | ✅ | Xterm-256Color | Truecolor | |
| Windows terminal | ✅ | ✅ | ✅ 2 | |||
| Windows Powershell | ✅ | ✅ | ✅ 2 | |||
| Terminal MacOS | ✅ | ✅ | Xterm-256Color | |||
| ITERM | ✅ | ✅ | ✅ | Xterm-256Color | Truecolor | |
| Emulador de terminal Kitty | ✅ | ✅ | ✅ | Xterm-Kitty | ||
| Emulador de terminal Kde Konsole | ✅ | ✅ | ✅ | Xterm-direte |
Veja também:
Execute o comando para ver o suporte de alguns recursos de várias bibliotecas:
npm run compare
| Biblioteca ____________________ - Nomeado importação - Nomeação de cores | ANSI 16 cores | ANSI 256 cores | Verdadeiro Cor | Acorrentado sintaxe | Aninhado Strings de modelo | Novo Linha | Fallback das cores | Suportes Env vars Bandeiras da CLI |
|---|---|---|---|---|---|---|---|---|
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 | ✅ Desde v1.1.0 | → B&W | NO_COLORFORCE_COLOR--no-color--color | |||||
kleur✅ named import✅ standard | 8 cores | ✅ | → B&W | NO_COLORFORCE_COLOR |
Observação
Nomeado importação
Esm
import { red, green, blue } from 'lib';
CJS
const { red, green, blue } = require('lib');Nomeação de cores
- Padrão: as cores têm nomes padrão, por exemplo:
red,redBright,bgRed,bgRedBright- Não-padrão : as cores têm nomes específicos para lib, por exemplo:
brightRed,bgBrightRed,red_b,red_bttANSI 256 cores
Os nomes dos métodos:
colors-cli:x<n>cli-color:xterm(n)chalk:ansi256(n)bgAnsi256(n)ansis:ansi256(n)bgAnsi256(n)fg(n)bg(n)Truecolor
Os nomes dos métodos:
chalk:hex()rgb()ansis:hex()rgb()Sintaxe acorrentada
lib.red.bold('text')Strings de modelo aninhados
lib.red`text ${lib.cyan`nested`} text`Nova linha
Estilos de interrupção corretos noend-of-line.lib.bgGreen(`First Line Next Line`);
| Pacote npm | Baixe o tamanho do tarball | Tamanho não embalado | Tamanho do código |
|---|---|---|---|
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 |
Tamanho do download: o tamanho gzipped do pacote NPM.
Tamanho descompactado: o tamanho do pacote NPM no node_modules/ Diretório, (incl. dependencies) .
Tamanho do código : o tamanho do código distribuído que será carregado via require ou import para o seu aplicativo.
Veja também:
git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run demoPara medir o desempenho, é usado benchmark.js.
Aviso
O vitest benchmark gera resultados falsos/ irreais .
Por exemplo, os resultados do banco simples:
chalk.red('foo') - 7.000.000 ops/sec
ansis.red('foo') - 23.000.000 ops/sec (x3 faster is WRONG result)
Os resultados reais de desempenho de giz e ANSIS neste teste são muito semelhantes.
git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run build
npm run benchTestado em
MacBook Pro 16 "M1 MAX 64GB
MacOS Sequoia 15.1
Node.js v22.11.0
TerminaliTerm2v3.5.0
Observação
Nos testes, cada biblioteca usa o método de estilo mais rápido disponível para comparar o desempenho absoluto de cada biblioteca.
Na prática real, ninguém usaria o método mais lento (como chamadas aninhadas) para estilizar uma string quando a biblioteca fornece um método mais rápido e mais curto .
Por exemplo:
lib . red . bold . bgWhite ( ' ERROR ' ) // ✅ faster, shorter, readable
lib . red ( lib . bold ( lib . bgWhite ( ' ERROR ' ) ) ) // slower, longer, unreadable O teste simples usa apenas um estilo único. Picocolors, Colorette e Kleur não suportam sintaxe encadeada ou quebra de estilo correto (Wenn usou `n` em uma string), então eles são os mais rápidos neste caso de uso simples. Sem função, sem sobrecarga de desempenho .
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/secUsando apenas 2 estilos, o Picocolors já é um pouco mais lento, porque o uso da sintaxe encadeado é mais rápido que as chamadas aninhadas.
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/secUsando 3 estilos, o Picocolors é 2x mais lento que o 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/secEm casos raros, ao usar 4 estilos, o Picocolors se torna 3,4x mais lento que o 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/secO teste complexo com estilos únicos profundamente aninhados.
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 A referência usada em colorette para estilos únicos.
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 A referência picocolors , ligeiramente modificada. Adicionado um pouco mais de complexidade aplicando dois estilos à palavra colorida em vez de um.
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/secObservação
Neste teste, que está mais próximo do uso prático, cada biblioteca usa o método de estilo mais rápido disponível.
Então, chalk , ansis , ansi-colors , cli-color , colors-cli e colors usa método encadeado, por exemplo, c.red.bold(' ERROR ') . Enquanto picocolors , colorette e kolorist usa chamadas aninhadas, por exemplo, c.red(c.bold(' ERROR ')) , porque não suporta a sintaxe encadeada.
A ANSIS é uma substituição poderosa, pequena e rápida que não requer migração de código para muitas bibliotecas semelhantes.
Basta substituir sua import ... from ... ou require(...) à ansis .
- import chalk from 'chalk';
+ import chalk from 'ansis';O ANSIS suporta a sintaxe do giz e é compatível* com estilos e nomes de cores, para que você não precise modificar o código original:
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' ) ; Aviso
O ANSIS não suporta o estilo overline , porque não é amplamente suportado e ninguém o usa.
Verifique seu codificador e remova o estilo overline :
- chalk.red.overline('text');
+ chalk.red('text');Opcionalmente, você pode reescrever o mesmo código para torná -lo ainda mais curto e limpo:
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'; A ANSIS é totalmente compatível com estilos colorette e nomes de cores, para que você não precise modificar o código original:
red . bold ( 'Error!' ) ;
bold ( `I'm ${ red ( `da ba ${ underline ( "dee" ) } da ba` ) } daa` ) ;Opcionalmente, você pode reescrever o mesmo código para torná -lo ainda mais curto e limpo:
red . bold `Error!` ;
bold `I'm ${ red `da ba ${ underline `dee` } da ba` } daa` ; - import pico from 'picocolors';
+ import pico from 'ansis'; ANSIS é totalmente compatível com estilos e nomes de cores picocolors , para que você não precise modificar o código original:
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!' ) ;Opcionalmente, você pode reescrever o mesmo código para torná -lo ainda mais curto e limpo:
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'); O ANSIS é totalmente compatível com estilos ansi-color , para que você não precise modificar o código original:
c . red . bold ( 'Error!' ) ;
// colorize "Error: file not found!"
c . red ( `Error: ${ c . cyan . bold ( 'file' ) } not found!` ) ;Opcionalmente, você pode reescrever o mesmo código para torná -lo ainda mais curto e limpo:
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'; O ANSIS é totalmente compatível com estilos kleur e nomes de cores, mas o Kleur v3.0 não usa mais a sintaxe no estilo de giz (mágica getter):
green ( ) . bold ( ) . underline ( 'this is a bold green underlined message' ) ;
yellow ( `foo ${ red ( ) . bold ( 'red' ) } bar ${ cyan ( 'cyan' ) } baz` ) ; Se você usa métodos encadeados, ele requer uma modificação simples de código. Basta substituir (). com . :
green . bold . underline ( 'this is a bold green underlined message' ) ;
yellow ( `foo ${ red . bold ( 'red' ) } bar ${ cyan ( 'cyan' ) } baz` ) ;Opcionalmente, você pode reescrever o mesmo código para torná -lo ainda mais curto e limpo:
yellow `foo ${ red . bold `red` } bar ${ cyan `cyan` } baz` ; - const clc = require('cli-color');
+ const clc = require('ansis'); ANSIS é compatível* com estilos cli-color e nomes de cores:
clc . red . bold ( 'Error!' ) ;
// colorize "Error: file not found!"
clc . red ( `Error: ${ c . cyan . bold ( 'file' ) } not found!` ) ; Aviso
A ANSIS não suporta o estilo blink , porque não é amplamente suportado e ninguém o usa.
Verifique seu código e remova o estilo blink :
- clc.red.blink('text');
+ clc.red('text'); Se você usar as funções de cores ANSI 256 xterm ou bgXterm , elas devem ser substituídas por ansi256 fn ou bgAnsi256 bg :
- clc.xterm(202).bgXterm(236)('Orange text on dark gray background');
+ clc.ansi256(202).bgAnsi256(236)('Orange text on dark gray background');Opcionalmente, você pode reescrever o mesmo código para torná -lo ainda mais curto e limpo:
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 executará os testes de unidade e integração.
npm run test:coverage executará os testes com cobertura.
ISC
As cores suportadas depende do terminal real. ↩ ↩ 2 ↩ 3
O Terminal do Windows suporta a verdadeira cor desde o Windows 10 Revisão 14931 (2016-09-21). ↩ ↩ 2
