Téléchargement ansis - Téléchargement du code source ansis

Styles ANSI

Une bibliothèque Node.js petite et rapide pour appliquer les couleurs et les styles ANSI dans la sortie du terminal.
ANSIS fournit toutes les fonctionnalités dont vous avez besoin, vous pouvez comparer avec des bibliothèques similaires.
ANSIS est plus rapide que la craie et les picoolors (dans certains cas d'utilisation), voir les repères.

Installer et démarrer rapidement pourquoi passer à ANSIS

Usage

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

⚖️ Libraries similaires

Les bibliothèques Node.js les plus populaires similaires à ANSIS:

Craie, Picocolors, colorette, Kleur, ANSI-Colors, Kolorist, Cli-Color, Colors-Cli, Colors.js

✅ Comparez les fonctionnalités? Comparez les tailles de package.

Points forts

Prend en charge ESM , CommonJS , TypeScript
Prend en charge Bun , Deno , Next.js Runtime
Remplacement de chalk picocolors colorette ansi-colors
Par défaut et nommé Import import ansis, { red, bold, ansi256, hex } from 'ansis'
Syntaxe chaîné red.bold.underline('text')
Chaînes de modèle imbriquées red`Error: ${blue`file.js`} not found!`
ANSI Styles dim bold italic underline ~~strikethrough~~
ANSI 16 couleurs red`Error!` redBright`Error!` bgRed`Error!` bgRedBright`Error!`
ANSI 256 COLLES fg(56)`violet` bg(208)`orange`
TrueColor ( RGB , Hex ) rgb(224, 17, 95)`Ruby` hex('#96C')`Amethyst`
Fallback à l'espace colorimétrique pris en charge: truecolor → 256 couleurs → 16 couleurs → pas de couleurs
Extension des couleurs de base avec TrueColor nommé
Codes RAW ANSI comme propriétés open et close `foo ${red.open}red{red.close} bar`
Méthode des codes ANSI Strip ansis.strip()
Détecte automatiquement le support des couleurs dans une large gamme d'environnements
Prend en charge les variables d'environnement NO_COLOR FORCE_COLOR et drapeaux --no-color --color
Définissez la variable ColorTerm pour tester les applications avec 16, 256 ou vraie couleur
Correcte de style à la end of line lorsqu'il est utilisé n en chaîne
Ne prolonge pas String.prototype
Zéro dépendances
Test de la couverture à 100%. Entretien à long terme.

? Utilisé par

NESTJS, Facebook / Stylex, Sequelize, Salesforce, Oclif, WebPackbar

❓quois / demande de fonctionnalité / bug

Si vous avez découvert un bug ou avez une suggestion de fonctionnalités, n'hésitez pas à créer un problème sur GitHub.

Pourquoi passer à ANSIS

Aujourd'hui, les deux bibliothèques les plus petites et les plus rapides sont ansis et picocolors . Les deux sont recommandés par la communauté des outils ES comme les meilleurs remplacements pour les bibliothèques plus anciennes et plus volumineuses.

? Taille déballée

picocolors : 6,4 Ko - Une micro-bibliothèque avec seulement des fonctionnalités de base.
аnsis : 7,4 Ko - Une bibliothèque puissante contenant toutes les fonctionnalités dont vous avez besoin.
chalk : 44,2 Ko - offre des fonctionnalités similaires à ANSIS mais est plus grande.

⚡ Performance

picocolors : le plus rapide lors de l'application d'un seul style (par exemple, red uniquement).
аnsis : le plus rapide lors de l'application de deux styles ou plus (par exemple, red + bgWhite ).
chalk : plus lente qu'ANSIS et Picocolors dans tous les cas d'utilisation.

? Entretien

Seuls ansis , chalk et picocolors sont activement maintenus, contrairement à de nombreuses autres bibliothèques:

colorette : Dernière mise à jour il y a 2 ans
ansi-colors : Dernière mise à jour il y a 3 ans
kleur : Dernière mise à jour il y a 2 ans
cli-color : Dernière mise à jour il y a ~ 1 an
colors-cli : Dernière mise à jour il y a 1 an
colors.js : Dernière mise à jour il y a 5 ans

? Lequel devez-vous utiliser?

Si vous n'utilisez qu'un seul style, comme red('foo') , Picocolors est la meilleure solution.
Cependant, si vous avez besoin de plus, comme combiner plusieurs styles (par exemple, red + bold + bgWhite ),
Couleurs ANSI256, truecolor ou support pour une large gamme d'environnements, alors ANSIS est le meilleur choix.

Explorez la liste des fonctionnalités, des tailles de packages et des repères par rapport aux bibliothèques similaires.

Conseil

Utilisez la syntaxe enchaînée fournie par des bibliothèques comme ansis et chalk .
Évitez les appels imbriqués, car ils sont beaucoup plus lents et moins lisibles que la syntaxe enchaînée.
Gardez votre code propre et lisible!

 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 ?

Comment passer à ANSIS

Remplacement chalk
Remplacement de colorette
Remplacement picocolors
Remplacement ansi-colors
Remplacement kleur
Remplacement cli-color

↑ Top

Installer et démarrer rapidement

npm install ansis

Vous pouvez importer un module par défaut ou des couleurs nommées avec la syntaxe ESM ou CommonJS.

 // ESM default import
import ansis from 'ansis' ;
// ESM named import
import { red , green , blue } from 'ansis' ;

 // CommonJS default import
const ansis = require ( 'ansis' ) ;
// CommonJS named import
const { red , green , blue } = require ( 'ansis' ) ;

Voir la liste des couleurs et styles 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!` ) ;

Exemple de base 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!` } ` ) ;

Sortir:
Capture d'écran "Hello ANSI World!"

↑ Top

Importation nommée

L' ansis prend en charge à la fois l' default import et named import .

 // default import
import ansis from 'ansis' ;

ansis . red . bold ( 'text' ) ;

Vous pouvez importer des couleurs, des styles et des fonctions nommés. Toutes les couleurs et styles importés sont chainable .

 // named import
import { red , hex , italic } from 'ansis' ;

red . bold ( 'text' ) ;

L'importation par défaut et l'importation nommée peuvent être combinées.

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

Modèle littéraux

L' ansis prend en charge à la fois la syntaxe de fonction red('error') et le modèle littérales red`error` .

Le template literals vous permettent de rendre un modèle complexe plus lisible et plus court.
La function syntax peut être utilisée pour colorer une variable.

 import { red } from 'ansis' ;

let message = 'error' ;

red ( message ) ;
red `text` ;
red `text ${ message } text` ;

Syntaxe enchaînée

Toutes les couleurs, styles et fonctions sont chaînables. Chaque couleur ou style peut être combiné dans n'importe quel ordre.

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

↑ Top

Syntaxe imbriquée

Vous pouvez nidiquer les fonctions et les chaînes de modèle les unes dans les autres. Aucune des autres bibliothèques (craie, kleur, colorette, couleurs.js etc.) ne prend en charge les chaînes de modèle imbriquées.

Chaînes de modèle imbriquées:

 import { red , green } from 'ansis' ;

red `red ${ green `green` } red` ;

Styles enchaînés profonds:

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

Sortir:
Capture d'écran Styles imbriqués

Chaînes de modèles imbriquées multilines:

 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 } %` }
` ;

Sortir:
Capture d'écran Multiline Nested

↑ Top

Base ANSI 16 couleurs et styles

Les couleurs et les styles ont des noms standard utilisés par de nombreuses bibliothèques populaires, telles que la craie, la colorette, les picocoles, le kleur.

Couleurs de premier plan	Couleurs de fond	Styles
`black`	`bgBlack`	`dim`
`red`	`bgRed`	`bold`
`green`	`bgGreen`	`italic`
`yellow`	`bgYellow`	`underline`
`blue`	`bgBlue`	~~`strikethrough`~~ (Alias `strike` )
`magenta`	`bgMagenta`	`inverse`
`cyan`	`bgCyan`	`visible`
`white`	`bgWhite`	`hidden`
`blackBright` Alias: `grey` orthographe `gray` américaine	`bgBlackBright` Alias: `bgGrey` `bgGray` Us Spelling	`reset`
`redBright`	`bgRedBright`
`greenBright`	`bgGreenBright`
`yellowBright`	`bgYellowBright`
`blueBright`	`bgBlueBright`
`magentaBright`	`bgMagentaBright`
`cyanBright`	`bgCyanBright`
`whiteBright`	`bgWhiteBright`

Étendre les couleurs de base

Par défaut, l'instance ansis importée contient des styles et des couleurs de base. Pour étendre les couleurs de base avec des noms de couleurs personnalisés pour TrueColor, utilisez la méthode 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' ) ;

Exemple d'utilisation avec 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

↑ Top

ANSI 256 couleurs

L'ensemble prédéfini de 256 couleurs.

Plage de codes	Description
0 - 7	Couleurs standard
8 - 15	couleurs vives
16 - 231	Cube 6 × 6 × 6 (216 couleurs)
232 - 255	niveaux de gris du noir au blanc en 24 étapes

Fonction de premier plan: ansi256(code) a un alias fg(code)
Fonction d'arrière-plan: bgAnsi256(code) a un alias bg(code)

Les méthodes ansi256() et bgAnsi256() sont implémentées pour la compatibilité avec l'API chalk .

Voir les codes couleur ANSI.

Retomber

Si un terminal ne prend en charge que 16 couleurs, les couleurs ANSI 256 seront interpolées dans les couleurs de base 16.

Fallback ANSI 256 couleurs à 16 couleurs

Exemple d'utilisation

 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`

Truecolor

Vous pouvez utiliser le format hex ou rgb .

Fonction de premier plan: hex() rgb()
Fonction de fond: 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`

↑ Top

Retomber

L' ansis prend en charge le secours à l'espace colorimétrique pris en charge.

 Truecolor —> 256 colors —> 16 colors —> no colors (black & white)

Si vous utilisez les fonctions hex() , rgb() ou ansis256() dans un terminal non pris en charge TrueColor ou 256 couleurs, les couleurs seront interpolées.

output

↑ Top

Utiliser les codes ANSI

Vous pouvez utiliser les codes d'échappement ANSI avec des propriétés open et close pour chaque style.

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

Codes ANSI

La classe ANSIS contient la strip() pour supprimer tous les codes ANSI de la chaîne.

 import ansis from 'ansis' ;

const ansiString = ansis . green `Hello World!` ;
const string = ansis . strip ( ansiString ) ;

La string variable contiendra la chaîne pure sans codes ANSI.

↑ Top

Nouvelles lignes

Prend en charge la rupture de style correct à la end of line .

 import { bgGreen } from 'ansis' ;

console . log ( bgGreen `nAnsisnNew LinenNext New Linen` ) ;

output

Raccourcis / thèmes

Définissez vos propres thèmes:

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

↑ Top

Variables de l'environnement CLI

Par défaut, la sortie dans la console de terminal est colorée et la sortie dans un fichier n'est pas colorée.

Pour forcer la désactivation ou l'activation de la sortie colorée, utilisez des variables d'environnement NO_COLOR et FORCE_COLOR .

La variable NO_COLOR doit être présente avec une valeur non vide. La valeur n'est pas importante, par exemple, NO_COLOR=1 NO_COLOR=true couleurs de désactivation.
Voir Description standard par no_color.

La variable FORCE_COLOR doit être présente avec l'une des valeurs:
FORCE_COLOR=0 Force Désactiver les couleurs
FORCE_COLOR=1 Force Activer les couleurs
Voir Description standard par force_color.

Par exemple, app.js :

 import { red } from 'ansis' ;

console . log ( red `red color` ) ;

Exécutez le script dans un 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

Utilisation `COLORTERM`

La variable d'environnement COLORTERM est utilisée par les émulateurs terminaux pour indiquer le support des couleurs. Sa valeur peut varier en fonction de l'émulateur de terminal et du niveau de support des couleurs fourni.

Les valeurs couramment utilisées soutenues par ansis :

truecolor ou 24bit - 16 millions de couleurs
ansi256 - Couleurs ANSI 256
ansi - Couleurs de base ANSI 16

Vous pouvez définir la variable dans CMD avant d'exécuter le script de nœud:

 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

Pour définir le niveau de couleur dans un script, créez un fichier JS dans lequel vous définissez la variable d'environnement COLORTERM avec la valeur nécessaire et importez ce fichier avant ansis .

Cela peut être utile, par exemple, pour tester votre application CLI afin de garantir que les résultats du test seront les mêmes quel que soit le niveau de couleur pris en charge dans différents environnements et terminaux.

Force Utiliser TrueColor

niveau-truecolor.js

 process . env . COLORTERM = 'truecolor' ;

Votre fichier 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

Force Utiliser 256 couleurs

niveau-256Colors.js

 process . env . COLORTERM = 'ansi256' ;

Votre fichier 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

Force Utiliser la base 16 couleurs

niveau-16Colors.js

 process . env . COLORTERM = 'ansi' ;

Votre fichier 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

↑ Top

Arguments de la CLI

Utilisez des arguments CMD --no-color ou --color=false pour désactiver les couleurs et --color pour activer ceux.

Par exemple, un script exécutable app.js :

#!/usr/bin/env node
import { red } from 'ansis' ;

console . log ( red `red color` ) ;

Exécutez le script dans un 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

Avertissement
Les arguments de ligne de commande ont une priorité plus élevée que la variable d'environnement.

↑ Top

Support des couleurs

ANSIS détecte automatiquement l'espace colorimétrique pris en charge:

Truecolor
ANSI 256 couleurs
ANSI 16 couleurs
noir et blanc (pas de couleurs)

ANSIS a la méthode isSupported() qui renvoie une valeur boolean si la sortie prend en charge la couleur et les styles ANSI.

 import ansis from 'ansis' ;

console . log ( 'Color output: ' , ansis . isSupported ( ) ) ;

Il n'y a aucun moyen standard de détecter quel espace colorimétrique est pris en charge. La façon la plus courante de détecter le support des couleurs est de vérifier les variables d'environnement TERM et COLORTERM . Les systèmes CI peuvent être détectés en vérifiant l'existence de l' CI et d'autres variables spécifiquement environnementales. Combinez cela avec les connaissances sur le système d'exploitation sur lequel le programme fonctionne, et nous avons un moyen suffisamment décent de détecter les couleurs.

Terminal	ANSI 16 couleurs	ANSI 256 couleurs	Vrai Couleur	env. TERME	env. Term	Spécifiquement des variables env
Azure CI	✅			idiot		Tf_build Agent_name
Github CI	✅	✅	✅	idiot		CI, github_actions
Gittea CI	✅	✅	✅	idiot		CI, Gitea_actions
Gitlab ci	✅			idiot		CI, Gitlab_ci
Travis CI	✅			idiot		Travis
PM2 pas istty	✅ ¹	✅ ¹	✅ ¹	idiot		PM2_HOME pm_id
JetBrains TeamCity > = 2020.1.1	✅	✅				TeamCity_version
Jet-Brains Idea	✅	✅	✅	xterm-256color		Terminal_emulator = 'jetbrains-jediterm'
VS Code	✅	✅	✅	xterm-256color	truecolor
Fenêtre Terminal	✅	✅	✅ ²
Fenêtre Powershell	✅	✅	✅ ²
terminal macOS	✅	✅		xterm-256color
iter	✅	✅	✅	xterm-256color	truecolor
Émulateur de terminal Kitty	✅	✅	✅	xterm-kitty
Émulateur de terminal KDE Konsole	✅	✅	✅	x final

Voir aussi:

Prise en charge TrueColor dans les dispositifs de sortie.
Vous voulez donc rendre les couleurs dans votre terminal.

↑ Top

Comparez les fonctionnalités des bibliothèques les plus populaires

Exécutez la commande pour voir la prise en charge de certaines fonctionnalités de diverses bibliothèques:

 npm run compare

Bibliothèque ________________ - Importation nommée - Couleurs de dénomination	ANSI 16 couleurs	ANSI 256 couleurs	Vrai Couleur	Enchaîné syntaxe	Imbriqué chaînes de modèle	Nouveau Doubler	Fallback aux couleurs	Soutien Env Vars Drapeaux de CLI
`ansis` `✅ named import` `✅ standard`	✅	✅	✅	✅	✅	✅	→ 256 → 16 → B&W	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`chalk` `named import` `✅ standard`	✅	✅	✅	✅		✅	→ 256 → 16 → B&W	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`kolorist` `✅ named import` `standard`	✅	✅	✅				→ 256 → B&W	`NO_COLOR` `FORCE_COLOR`
`cli-color` `named import` `✅ standard`	✅	✅		✅			→ 16 → B&W	`NO_COLOR`
`colors-cli` `named import` `standard`	✅	✅		✅		✅	→ B&W	`--no-color` `--color`
`colors.js` `named import` `standard`	✅			✅		✅	→ B&W	`FORCE_COLOR` `--no-color` `--color`
`ansi-colors` `named import` `✅ standard`	✅			✅		✅		`FORCE_COLOR`
`colorette` `✅ named import` `✅ standard`	✅						→ B&W	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`picocolors` `named import` `✅ standard`	✅ Depuis V1.1.0						→ B&W	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`kleur` `✅ named import` `✅ standard`	`8` couleurs			✅			→ B&W	`NO_COLOR` `FORCE_COLOR`

Note
Importation nommée
ESM
import { red, green, blue } from 'lib';
Cjs
const { red, green, blue } = require('lib');
Nommer les couleurs
Standard: les couleurs ont des noms standard, par exemple: red , redBright , bgRed , bgRedBright
Non-standard : Les couleurs ont des noms spécifiques à Lib, par exemple: brightRed , bgBrightRed , red_b , red_btt
ANSI 256 couleurs
Les noms de méthode:
colors-cli : x<n>
cli-color : xterm(n)
chalk : ansi256(n) bgAnsi256(n)
ansis : ansi256(n) bgAnsi256(n) fg(n) bg(n)
Truecolor
Les noms de méthode:
chalk : hex() rgb()
ansis : hex() rgb()
Syntaxe enchaînée
lib.red.bold('text')
Chaînes de modèle imbriquées
lib.red`text ${lib.cyan`nested`} text`
Nouvelle ligne
Correction des styles de rupture à end-of-line .
 lib.bgGreen(`First Line
Next Line`);

↑ Top

Comparez la taille des packages les plus populaires

Package NPM	Télécharger la taille du tarball	Taille déballée	Taille du code
`picocolors`	2,6 Ko	6,4 kb	2,6 Ko
`ansis`	3,8 Ko	7,4 Ko	3,4 Ko
`colorette`	4,9 Ko	17,0 kb	3,4 Ko
`kleur`	6,0 kb	20,3 Ko	2,7 Ko
`ansi-colors`	8,5 ko	26.1 Ko	5,8 Ko
`kolorist`	8,7 Ko	51,0 Ko	6,8 Ko
`colors.js`	11.0 Ko	39,5 Ko	18,1 Ko
`chalk`	13.1 Ko	43,7 Ko	16,4 Ko
`cli-color`	13.8 (216 Ko)	39,6 (754 Ko)	12.1 Ko
`colors-cli`	361,7 Ko	511,0 Ko	8,7 Ko

Taille de téléchargement: la taille gzipied du package NPM.
Taille déballée: la taille du package NPM dans le répertoire node_modules/ / (incl. dependencies) .
Taille du code : la taille du code distribué qui sera chargé via require ou import dans votre application.

Voir aussi:

NPMJS - Afficher la taille d'installation du package publié, sans dépendances
PackagePhobia - Afficher la taille totale de l'installation, incl. dépendances
Taille de téléchargement NPM - Afficher le tarball et la taille du téléchargement total
Ballephobie - inutile, ne montre pas la vraie taille de tarball du package NPM téléchargé

↑ Top

Montrer la démo ANSI

git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run demo

Repères

Pour mesurer les performances est utilisée Benchmark.js.

Avertissement

‼ ️ Ne faites pas confiance aux autres résultats des tests à l'aide de la référence les plus vitreuse.

La vitest benchmark génère des résultats faux / irréels .
Par exemple, les résultats du banc simple:

 chalk.red('foo') -  7.000.000 ops/sec
ansis.red('foo') - 23.000.000 ops/sec (x3 faster is WRONG result)

Les résultats réels des performances de la craie et de l'ANSIS dans ce test sont très similaires.

Faire des références

git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run build
npm run bench

Testé sur
MacBook Pro 16 "M1 max 64 Go
macOS Sequoia 15.1
Node.js v22.11.0
Terminal iTerm2 v3.5.0

Note

Dans les tests, chaque bibliothèque utilise la méthode de style la plus rapide disponible pour comparer les performances absolues de chaque bibliothèque.

Dans la pratique réelle, personne n'utiliserait la méthode la plus lente (telle que les appels imbriqués) pour styliser une chaîne lorsque la bibliothèque fournit une méthode enchaînée plus rapide et plus courte .

Par exemple:

 lib . red . bold . bgWhite ( ' ERROR ' )           // ✅ faster, shorter, readable
lib . red ( lib . bold ( lib . bgWhite ( ' ERROR ' ) ) ) //  slower, longer, unreadable

Banc simple

Le test simple utilise uniquement un style unique. Picocolors, colorette et kleur ne prennent pas en charge la syntaxe chaînée ou la pause de style correct (Wenn a utilisé `n` dans une chaîne), ils sont donc les plus rapides dans ce simple cas d'utilisation. Aucune fonction, pas de surcharge de performance .

 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/sec

Utilisation de 2 styles

En utilisant seulement 2 styles, Picocolors est déjà un peu plus lent, car l'utilisation de la syntaxe enchaînée est plus rapide que les appels imbriqués.

 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/sec

En utilisant 3 styles

En utilisant 3 styles, Picocolors est 2x plus lent qu'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/sec

En utilisant 4 styles

Dans de rares cas, lors de l'utilisation de 4 styles, le picoolor devient 3,4x plus lent qu'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/sec

Styles profondément imbriqués

Le test complexe avec des styles uniques profondément imbriqués.

 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

Banc colorette

La référence utilisée dans colorette pour les styles uniques.

 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

Banc complexe de Picocolors

La référence picocolors , légèrement modifiée. Ajout d'un peu plus de complexité en appliquant deux styles au mot coloré au lieu d'un.

 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/sec

Note

Dans ce test, qui est plus proche d'une utilisation pratique, chaque bibliothèque utilise la méthode de style la plus rapide disponible.

Ainsi, chalk , ansis , ansi-colors , cli-color , colors-cli et colors utilisent la méthode chaînée, par exemple c.red.bold(' ERROR ') . Alors que picocolors , colorette et kolorist utilisent des appels imbriqués, par exemple c.red(c.bold(' ERROR ')) , car ne prend pas en charge la syntaxe enchaînée.

↑ Top

Comment passer à ANSIS

ANSIS est un remplacement puissant, petit et rapide qui ne nécessite aucune migration de code pour de nombreuses bibliothèques similaires.
Remplacez simplement votre import ... from ... ou require(...) à ansis .

Remplacement de la craie, aucune migration requise

 - import chalk from 'chalk';
+ import chalk from 'ansis';

ANSIS prend en charge la syntaxe de la craie et est compatible * avec les styles et les noms de couleurs, vous n'avez donc pas besoin de modifier le code d'origine:

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

Avertissement

ANSIS ne prend pas en charge le style overline , car il n'est pas largement pris en charge et personne ne l'utilise.
Vérifiez votre code et supprimez le style overline :

 - chalk.red.overline('text');
+ chalk.red('text');

Facultativement, vous pouvez réécrire le même code pour le rendre encore plus court et plus propre:

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

↑ Top

Remplacement de rendez-vous pour colorette, aucune migration requise

 - import { red, bold, underline } from 'colorette';
+ import { red, bold, underline } from 'ansis';

ANSIS est entièrement compatible avec les styles colorette et les noms de couleurs, vous n'avez donc pas besoin de modifier le code d'origine:

 red . bold ( 'Error!' ) ;
bold ( `I'm ${ red ( `da ba ${ underline ( "dee" ) } da ba` ) } daa` ) ;

Facultativement, vous pouvez réécrire le même code pour le rendre encore plus court et plus propre:

 red . bold `Error!` ;
bold `I'm ${ red `da ba ${ underline `dee` } da ba` } daa` ;

↑ Top

Remplacement de rendez-vous pour les picoolors, aucune migration requise

 - import pico from 'picocolors';
+ import pico from 'ansis';

ANSIS est entièrement compatible avec les styles picocolors et les noms de couleurs, vous n'avez donc pas besoin de modifier le code d'origine:

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

Facultativement, vous pouvez réécrire le même code pour le rendre encore plus court et plus propre:

 import { red , cyan } from 'ansis' ;

red . bold `text` ;
red . bold ( variable ) ;

// colorize "Error: file not found!"
red `Error: ${ cyan . bold `file` } not found!`

↑ Top

Remplacement de rendez-vous pour les couleurs ANSI, aucune migration requise

 - const c = require('ansi-colors');
+ const c = require('ansis');

ANSIS est entièrement compatible avec les styles et noms de ansi-color Color, vous n'avez donc pas besoin de modifier le code d'origine:

 c . red . bold ( 'Error!' ) ;

// colorize "Error: file not found!"
c . red ( `Error: ${ c . cyan . bold ( 'file' ) } not found!` ) ;

Facultativement, vous pouvez réécrire le même code pour le rendre encore plus court et plus propre:

 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!` ;

↑ Top

Migration de kleur

 - import { red, green, yellow, cyan } from 'kleur';
+ import { red, green, yellow, cyan } from 'ansis';

ANSIS est entièrement compatible avec les styles kleur et les noms de couleurs, mais Kleur v3.0 n'utilise plus de syntaxe de style craie (Getter magique):

 green ( ) . bold ( ) . underline ( 'this is a bold green underlined message' ) ;
yellow ( `foo ${ red ( ) . bold ( 'red' ) } bar ${ cyan ( 'cyan' ) } baz` ) ;

Si vous utilisez des méthodes chaînées, il nécessite une modification simple de code. Il suffit de remplacer (). avec . :

 green . bold . underline ( 'this is a bold green underlined message' ) ;
yellow ( `foo ${ red . bold ( 'red' ) } bar ${ cyan ( 'cyan' ) } baz` ) ;

Facultativement, vous pouvez réécrire le même code pour le rendre encore plus court et plus propre:

 yellow `foo ${ red . bold `red` } bar ${ cyan `cyan` } baz` ;

↑ Top

Migration à partir de clinor

 - const clc = require('cli-color');
+ const clc = require('ansis');

ANSIS est compatible * avec les styles cli-color et les noms de couleurs:

 clc . red . bold ( 'Error!' ) ;

// colorize "Error: file not found!"
clc . red ( `Error: ${ c . cyan . bold ( 'file' ) } not found!` ) ;

Avertissement

ANSIS ne prend pas en charge le style blink , car il n'est pas largement pris en charge et personne ne l'utilise.
Vérifiez votre code et supprimez le style de blink :

 - clc.red.blink('text');
+ clc.red('text');

Si vous utilisez des fonctions de couleur ANSI 256 xterm ou bgXterm , celles-ci doivent être remplacées par 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');

Facultativement, vous pouvez réécrire le même code pour le rendre encore plus court et plus propre:

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

↑ Top

Essai

npm run test exécutera l'unité et les tests d'intégration.
npm run test:coverage exécutera les tests avec la couverture.

↑ Top

Licence

Isc

Les couleurs prises en charge dépendent du terminal réel. ↩ ↩ ² ↩ ³
Le terminal Windows prend en charge la vraie couleur depuis la révision de Windows 10 14931 (2016-09-21). ↩ ↩ ²

Développer

ansis

Styles ANSI

Installer et démarrer rapidement pourquoi passer à ANSIS

Usage

⚖️ Libraries similaires

Points forts

? Utilisé par

❓quois / demande de fonctionnalité / bug

Pourquoi passer à ANSIS

? Taille déballée

⚡ Performance

? Entretien

? Lequel devez-vous utiliser?

Comment passer à ANSIS

↑ Top

Installer et démarrer rapidement

↑ Top

Importation nommée

Modèle littéraux

Syntaxe enchaînée

↑ Top

Syntaxe imbriquée

↑ Top

Base ANSI 16 couleurs et styles

Étendre les couleurs de base

↑ Top

ANSI 256 couleurs

Retomber

Exemple d'utilisation

Truecolor

↑ Top

Retomber

↑ Top

Utiliser les codes ANSI

Codes ANSI

↑ Top

Nouvelles lignes

Raccourcis / thèmes

↑ Top

Variables de l'environnement CLI

Utilisation COLORTERM

Force Utiliser TrueColor

Force Utiliser 256 couleurs

Force Utiliser la base 16 couleurs

↑ Top

Arguments de la CLI

↑ Top

Support des couleurs

↑ Top

Comparez les fonctionnalités des bibliothèques les plus populaires

↑ Top

Comparez la taille des packages les plus populaires

↑ Top

Montrer la démo ANSI

Repères

Faire des références

Testé sur

Banc simple

Utilisation de 2 styles

En utilisant 3 styles

En utilisant 4 styles

Styles profondément imbriqués

Banc colorette

Banc complexe de Picocolors

↑ Top

Comment passer à ANSIS

Remplacement de la craie, aucune migration requise

↑ Top

Remplacement de rendez-vous pour colorette, aucune migration requise

↑ Top

Remplacement de rendez-vous pour les picoolors, aucune migration requise

↑ Top

Remplacement de rendez-vous pour les couleurs ANSI, aucune migration requise

↑ Top

Migration de kleur

↑ Top

Migration à partir de clinor

↑ Top

Essai

↑ Top

Utilisation `COLORTERM`