Comment changer la couleur de sortie de l'écho sous Linux

Réponses:

2296

Vous pouvez utiliser ces codes d'échappement ANSI :

Black        0;30     Dark Gray     1;30
Red          0;31     Light Red     1;31
Green        0;32     Light Green   1;32
Brown/Orange 0;33     Yellow        1;33
Blue         0;34     Light Blue    1;34
Purple       0;35     Light Purple  1;35
Cyan         0;36     Light Cyan    1;36
Light Gray   0;37     White         1;37

Et puis utilisez-les comme ceci dans votre script:

#    .---------- constant part!
#    vvvv vvvv-- the code from above
RED='\033[0;31m'
NC='\033[0m' # No Color
printf "I ${RED}love${NC} Stack Overflow\n"

qui imprime loveen rouge.

D'après le commentaire de @ james-lim, si vous utilisez la echocommande, assurez-vous d'utiliser l'indicateur -e pour autoriser les échappements de barre oblique inverse .

# Continued from above example
echo -e "I ${RED}love${NC} Stack Overflow"

(ne pas ajouter "\n"lors de l'utilisation d'écho, sauf si vous souhaitez ajouter une ligne vide supplémentaire)

Tobias
la source
11
Ne fonctionne pas pour moi - sortie:\e[0;31mHello Stackoverflow\e[0m
Ben Harold
172
L'avez-vous essayé avec "-e"? Il indique echod'activer les échappements antislash.
James Lim
142
Sous MacOSX, utilisez \x1Bau lieu de \e. \033serait ok pour toutes les plateformes.
Xiao
4
Dans un fichier de propriétés ant, utilisez unicode pour l'esacpe, par exemple red = \ u001b [0; 31m
shonky linux user
20
Comme msanford fait pour tput, voici le "ANSI-Rainbow"for (( i = 30; i < 38; i++ )); do echo -e "\033[0;"$i"m Normal: (0;$i); \033[1;"$i"m Light: (1;$i)"; done
everyman
971

Vous pouvez utiliser le génial tput commande (suggérée dans la réponse d'Ignacio ) pour produire des codes de contrôle de terminal pour toutes sortes de choses.


Usage

Des tputsous-commandes spécifiques sont discutées plus loin.

Direct

Appelez tputdans le cadre d'une séquence de commandes:

tput setaf 1; echo "this is red text"

Utiliser ;au lieu de&& si en cas d' tputerreurs le texte s'affiche toujours.

Variables shell

Une autre option consiste à utiliser des variables shell:

red=`tput setaf 1`
green=`tput setaf 2`
reset=`tput sgr0`
echo "${red}red text ${green}green text${reset}"

tputproduit des séquences de caractères qui sont interprétées par le terminal comme ayant une signification particulière. Ils ne seront pas affichés eux-mêmes. Notez qu'ils peuvent toujours être enregistrés dans des fichiers ou traités en entrée par des programmes autres que le terminal.

Substitution de commandes

Il peut être plus pratique d'insérer tputla sortie de directement dans vos echochaînes en utilisant la substitution de commande :

echo "$(tput setaf 1)Red text $(tput setab 7)and white background$(tput sgr 0)"

Exemple

La commande ci-dessus produit ceci sur Ubuntu:

Capture d'écran du texte du terminal couleur


Commandes de couleur de premier plan et d'arrière-plan

tput setab [1-7] # Set the background colour using ANSI escape
tput setaf [1-7] # Set the foreground colour using ANSI escape

Les couleurs sont les suivantes:

Num  Colour    #define         R G B

0    black     COLOR_BLACK     0,0,0
1    red       COLOR_RED       1,0,0
2    green     COLOR_GREEN     0,1,0
3    yellow    COLOR_YELLOW    1,1,0
4    blue      COLOR_BLUE      0,0,1
5    magenta   COLOR_MAGENTA   1,0,1
6    cyan      COLOR_CYAN      0,1,1
7    white     COLOR_WHITE     1,1,1

Il existe également des versions non ANSI des fonctions de réglage des couleurs ( setbau lieu de setabet setfau lieu de setaf) qui utilisent des nombres différents, non donnés ici.

Commandes en mode texte

tput bold    # Select bold mode
tput dim     # Select dim (half-bright) mode
tput smul    # Enable underline mode
tput rmul    # Disable underline mode
tput rev     # Turn on reverse video mode
tput smso    # Enter standout (bold) mode
tput rmso    # Exit standout mode

Commandes de déplacement du curseur

tput cup Y X # Move cursor to screen postion X,Y (top left is 0,0)
tput cuf N   # Move N characters forward (right)
tput cub N   # Move N characters back (left)
tput cuu N   # Move N lines up
tput ll      # Move to last line, first column (if no cup)
tput sc      # Save the cursor position
tput rc      # Restore the cursor position
tput lines   # Output the number of lines of the terminal
tput cols    # Output the number of columns of the terminal

Effacer et insérer des commandes

tput ech N   # Erase N characters
tput clear   # Clear screen and move the cursor to 0,0
tput el 1    # Clear to beginning of line
tput el      # Clear to end of line
tput ed      # Clear to end of screen
tput ich N   # Insert N characters (moves rest of line forward!)
tput il N    # Insert N lines

Autres commandes

tput sgr0    # Reset text format to the terminal's default
tput bel     # Play a bell

Avec les fenêtres tremblantes compiz , la belcommande fait osciller le terminal pendant une seconde pour attirer l'attention de l'utilisateur.


Scripts

tputaccepte les scripts contenant une commande par ligne, qui sont exécutés dans l'ordre avant de tputquitter.

Évitez les fichiers temporaires en faisant écho à une chaîne multiligne et en la canalisant:

echo -e "setf 7\nsetb 1" | tput -S  # set fg white and bg red

Voir également

  • Voir man 1 tput
  • Voir man 5 terminfopour la liste complète des commandes et plus de détails sur ces options. (La tputcommande correspondante est répertoriée dans la Cap-namecolonne de l'énorme tableau qui commence à la ligne 81.)
Drew Noakes
la source
13
Très bonne réponse. C'est celui qui m'a le plus aidé. Pour toute autre personne qui se demandait ce que je me demandais, $()c'est une substitution de commande . Il tput af 1suffit de générer la chaîne de code couleur, mais les codes ne sont pas des caractères imprimables, donc la saisie tput af 1seule produira une ligne de sortie vierge.
Chris Middleton
5
Remarque: si vous utilisez CygWin et n'avez pas d'installation de tputncurses
Enrico
3
tput fonctionne également à l'intérieur de sed pour analyser cruft en cruft lisible et coloré: gist.github.com/nickboldt/fab71da10bd5169ffdfa
nickboldt
1
Pour une liste complète des tputcouleurs, consultez cette réponse sur Unix StackExchange
Andrew
Je pense que ça reset=`tput sgr0`devrait être reset=`tput sgr 0`, avec un espace.
monkeypants
836

quelques variables que vous pouvez utiliser:

# Reset
Color_Off='\033[0m'       # Text Reset

# Regular Colors
Black='\033[0;30m'        # Black
Red='\033[0;31m'          # Red
Green='\033[0;32m'        # Green
Yellow='\033[0;33m'       # Yellow
Blue='\033[0;34m'         # Blue
Purple='\033[0;35m'       # Purple
Cyan='\033[0;36m'         # Cyan
White='\033[0;37m'        # White

# Bold
BBlack='\033[1;30m'       # Black
BRed='\033[1;31m'         # Red
BGreen='\033[1;32m'       # Green
BYellow='\033[1;33m'      # Yellow
BBlue='\033[1;34m'        # Blue
BPurple='\033[1;35m'      # Purple
BCyan='\033[1;36m'        # Cyan
BWhite='\033[1;37m'       # White

# Underline
UBlack='\033[4;30m'       # Black
URed='\033[4;31m'         # Red
UGreen='\033[4;32m'       # Green
UYellow='\033[4;33m'      # Yellow
UBlue='\033[4;34m'        # Blue
UPurple='\033[4;35m'      # Purple
UCyan='\033[4;36m'        # Cyan
UWhite='\033[4;37m'       # White

# Background
On_Black='\033[40m'       # Black
On_Red='\033[41m'         # Red
On_Green='\033[42m'       # Green
On_Yellow='\033[43m'      # Yellow
On_Blue='\033[44m'        # Blue
On_Purple='\033[45m'      # Purple
On_Cyan='\033[46m'        # Cyan
On_White='\033[47m'       # White

# High Intensity
IBlack='\033[0;90m'       # Black
IRed='\033[0;91m'         # Red
IGreen='\033[0;92m'       # Green
IYellow='\033[0;93m'      # Yellow
IBlue='\033[0;94m'        # Blue
IPurple='\033[0;95m'      # Purple
ICyan='\033[0;96m'        # Cyan
IWhite='\033[0;97m'       # White

# Bold High Intensity
BIBlack='\033[1;90m'      # Black
BIRed='\033[1;91m'        # Red
BIGreen='\033[1;92m'      # Green
BIYellow='\033[1;93m'     # Yellow
BIBlue='\033[1;94m'       # Blue
BIPurple='\033[1;95m'     # Purple
BICyan='\033[1;96m'       # Cyan
BIWhite='\033[1;97m'      # White

# High Intensity backgrounds
On_IBlack='\033[0;100m'   # Black
On_IRed='\033[0;101m'     # Red
On_IGreen='\033[0;102m'   # Green
On_IYellow='\033[0;103m'  # Yellow
On_IBlue='\033[0;104m'    # Blue
On_IPurple='\033[0;105m'  # Purple
On_ICyan='\033[0;106m'    # Cyan
On_IWhite='\033[0;107m'   # White

le caractère d'échappement en bash , hex et octal respectivement:

|       | bash  | hex    | octal   | NOTE                         |
|-------+-------+--------+---------+------------------------------|
| start | \e    | \x1b   | \033    |                              |
| start | \E    | \x1B   | -       | x cannot be capital          |
| end   | \e[0m | \x1m0m | \033[0m |                              |
| end   | \e[m  | \x1b[m | \033[m  | 0 is appended if you omit it |
|       |       |        |         |                              |

court exemple:

| color       | bash         | hex            | octal          | NOTE                                  |
|-------------+--------------+----------------+----------------+---------------------------------------|
| start green | \e[32m<text> | \x1b[32m<text> | \033[32m<text> | m is NOT optional                     |
| reset       | <text>\e[0m  | <text>\1xb[0m  | <text>\033[om  | o is optional (do it as best practice |
|             |              |                |                |                                       |

exception bash:

Si vous allez utiliser ces codes dans vos variables bash spéciales

  • PS0
  • PS1
  • PS2 (= c'est pour demander)
  • PS4

vous devez ajouter des caractères d'échappement supplémentaires afin que peut les interpréter correctement. Sans cela, l'ajout de caractères d'échappement supplémentaires fonctionne, mais vous rencontrerez des problèmes lorsque vous utilisez Ctrl + rpour la recherche dans votre historique.

règle d'exception pour bash

Vous devez ajouter \[avant tout code ANSI de départ et ajouter \]après tous les codes de fin.
Exemple:
en utilisation régulière: \033[32mThis is in green\033[0m
pour PS0 / 1/2/4: \[\033[32m\]This is in green\[\033[m\]

\[est pour le démarrage d'une séquence de non-imprimables caractères
\]est à la fin d'une séquence de non-imprimables caractères

Astuce: pour le mémoriser, vous pouvez d'abord ajouter \[\]puis mettre votre code ANSI entre eux:
- \[start-ANSI-code\]
-\[end-ANSI-code\]

type de séquence de couleurs:

  1. 3/4 bit
  2. 8 bits
  3. 24 bits

Avant de plonger dans ces couleurs, vous devez connaître 4 modes avec ces codes:

1. mode couleur

Il modifie le style de couleur PAS le texte. Par exemple, rendez la couleur claire ou plus foncée.

  • 0 réinitialiser
  • 1; plus léger que la normale
  • 2; plus sombre que la normale

Ce mode n'est pas largement pris en charge. Il est entièrement pris en charge sur Gnome-Terminal.

2. mode texte

Ce mode sert à modifier le style du texte et NON la couleur.

  • 3; italique
  • 4; souligner
  • 5; clignotant (lent)
  • 6; clignotant (rapide)
  • 7; inverser
  • 8; cacher
  • 9; barrer

et sont presque pris en charge.
Par exemple, KDE-Konsole prend en charge 5;mais pas Gnome-Terminal et Gnome prend en charge 8;mais pas KDE.

3. mode premier plan

Ce mode sert à coloriser le premier plan.

4. mode fond

Ce mode sert à coloriser l'arrière-plan.

Le tableau ci-dessous présente un résumé de la version 3/4 bits de la couleur ANSI

|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
| color-mode | octal    | hex     | bash  | description      | example (= in octal)         | NOTE                                 |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|          0 | \033[0m  | \x1b[0m | \e[0m | reset any affect | echo -e "\033[0m"            | 0m equals to m                       |
|          1 | \033[1m  |         |       | light (= bright) | echo -e "\033[1m####\033[m"  | -                                    |
|          2 | \033[2m  |         |       | dark (= fade)    | echo -e "\033[2m####\033[m"  | -                                    |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|  text-mode | ~        |         |       | ~                | ~                            | ~                                    |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|          3 | \033[3m  |         |       | italic           | echo -e "\033[3m####\033[m"  |                                      |
|          4 | \033[4m  |         |       | underline        | echo -e "\033[4m####\033[m"  |                                      |
|          5 | \033[5m  |         |       | blink (slow)     | echo -e "\033[3m####\033[m"  |                                      |
|          6 | \033[6m  |         |       | blink (fast)     | ?                            | not wildly support                   |
|          7 | \003[7m  |         |       | reverse          | echo -e "\033[7m####\033[m"  | it affects the background/foreground |
|          8 | \033[8m  |         |       | hide             | echo -e "\033[8m####\033[m"  | it affects the background/foreground |
|          9 | \033[9m  |         |       | cross            | echo -e "\033[9m####\033[m"  |                                      |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
| foreground | ~        |         |       | ~                | ~                            | ~                                    |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|         30 | \033[30m |         |       | black            | echo -e "\033[30m####\033[m" |                                      |
|         31 | \033[31m |         |       | red              | echo -e "\033[31m####\033[m" |                                      |
|         32 | \033[32m |         |       | green            | echo -e "\033[32m####\033[m" |                                      |
|         33 | \033[33m |         |       | yellow           | echo -e "\033[33m####\033[m" |                                      |
|         34 | \033[34m |         |       | blue             | echo -e "\033[34m####\033[m" |                                      |
|         35 | \033[35m |         |       | purple           | echo -e "\033[35m####\033[m" | real name: magenta = reddish-purple  |
|         36 | \033[36m |         |       | cyan             | echo -e "\033[36m####\033[m" |                                      |
|         37 | \033[37m |         |       | white            | echo -e "\033[37m####\033[m" |                                      |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|         38 | 8/24     |                    This is for special use of 8-bit or 24-bit                                            |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
| background | ~        |         |       | ~                | ~                            | ~                                    |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|         40 | \033[40m |         |       | black            | echo -e "\033[40m####\033[m" |                                      |
|         41 | \033[41m |         |       | red              | echo -e "\033[41m####\033[m" |                                      |
|         42 | \033[42m |         |       | green            | echo -e "\033[42m####\033[m" |                                      |
|         43 | \033[43m |         |       | yellow           | echo -e "\033[43m####\033[m" |                                      |
|         44 | \033[44m |         |       | blue             | echo -e "\033[44m####\033[m" |                                      |
|         45 | \033[45m |         |       | purple           | echo -e "\033[45m####\033[m" | real name: magenta = reddish-purple  |
|         46 | \033[46m |         |       | cyan             | echo -e "\033[46m####\033[m" |                                      |
|         47 | \033[47m |         |       | white            | echo -e "\033[47m####\033[m" |                                      |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|         48 | 8/24     |                    This is for special use of 8-bit or 24-bit                                            |                                                                                       |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|

Le tableau ci-dessous présente un résumé des version 8 bits de la couleur ANSI

|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
| foreground | octal     | hex       | bash    | description      | example                            | NOTE                    |
|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
|        0-7 | \033[38;5 | \x1b[38;5 | \e[38;5 | standard. normal | echo -e '\033[38;5;1m####\033[m'   |                         |
|       8-15 |           |           |         | standard. light  | echo -e '\033[38;5;9m####\033[m'   |                         |
|     16-231 |           |           |         | more resolution  | echo -e '\033[38;5;45m####\033[m'  | has no specific pattern |
|    232-255 |           |           |         |                  | echo -e '\033[38;5;242m####\033[m' | from black to white     |
|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
| foreground | octal     | hex       | bash    | description      | example                            | NOTE                    |
|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
|        0-7 |           |           |         | standard. normal | echo -e '\033[48;5;1m####\033[m'   |                         |
|       8-15 |           |           |         | standard. light  | echo -e '\033[48;5;9m####\033[m'   |                         |
|     16-231 |           |           |         | more resolution  | echo -e '\033[48;5;45m####\033[m'  |                         |
|    232-255 |           |           |         |                  | echo -e '\033[48;5;242m####\033[m' | from black to white     |
|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|

Le test rapide 8 bits:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

Le tableau ci-dessous présente un résumé de la version 24 bits de la couleur ANSI

|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
| foreground | octal     | hex       | bash    | description | example                                  | NOTE            |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
|      0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | R = red     | echo -e '\033[38;2;255;0;02m####\033[m'  | R=255, G=0, B=0 |
|      0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | G = green   | echo -e '\033[38;2;;0;255;02m####\033[m' | R=0, G=255, B=0 |
|      0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | B = blue    | echo -e '\033[38;2;0;0;2552m####\033[m'  | R=0, G=0, B=255 |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
| background | octal     | hex       | bash    | description | example                                  | NOTE            |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
|      0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | R = red     | echo -e '\033[48;2;255;0;02m####\033[m'  | R=255, G=0, B=0 |
|      0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | G = green   | echo -e '\033[48;2;;0;255;02m####\033[m' | R=0, G=255, B=0 |
|      0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | B = blue    | echo -e '\033[48;2;0;0;2552m####\033[m'  | R=0, G=0, B=255 |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|

quelques captures d'écran

premier plan résumé 8 bits dans un .gif

foreground.gif

résumé de fond 8 bits dans un .gif

background.gif

résumé des couleurs avec leurs valeurs

entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici

blinking sur KDE-Terminal

KDE clignote

un Ccode simple qui vous en montre plus

cecho_screenshot

un outil plus avancé que j'ai développé pour faire face à ces couleurs:

bline


prise de vue en mode couleur

fondu-normal-brillant

prise de vue en mode texte

mode texte uniquement

la combinaison est OK

combiner

plus de coups


Trucs et astuces pour les utilisateurs avancés et les programmeurs:

Pouvons-nous utiliser ces codes dans un langage de programmation?

Oui, vous pouvez. J'ai vécu dans, , , ,

Ralentissent-ils la vitesse d'un programme?

Je pense que non.

Pouvons-nous les utiliser sous Windows?

3/4 bits Oui, si vous compilez le code avec gcc
quelques captures d'écran sur Win-7

Comment calculer la longueur du code?

\033[ = 2, autres parties 1

Où pouvons-nous utiliser ces codes?

Partout qui a un ttyinterprète
xterm, gnome-terminal, kde-terminal, mysql-client-CLIet ainsi de suite.
Par exemple, si vous souhaitez coloriser votre sortie avec mysql, vous pouvez utiliserPerl

#!/usr/bin/perl -n
print "\033[1m\033[31m$1\033[36m$2\033[32m$3\033[33m$4\033[m" while /([|+-]+)|([0-9]+)|([a-zA-Z_]+)|([^\w])/g;

stockez ce code dans un nom de fichier: pcc(= Perl Colorize Character) puis mettez le fichier en valide PATHpuis utilisez-le où vous voulez.

ls | pcc
df | pcc

à l' intérieur d' mysqlabord l' enregistrer pour pagerpuis essayer:

[user2:db2] pager pcc
PAGER set to 'pcc'
[user2:db2] select * from table-name;

pcc

Il ne gère PAS Unicode.

Ces codes ne font-ils que coloriser?

Non, ils peuvent faire beaucoup de choses intéressantes. Essayer:

echo -e '\033[2K'  # clear the screen and do not move the position

ou:

echo -e '\033[2J\033[u' # clear the screen and reset the position

Il y a beaucoup de débutants qui veulent effacer l'écran system( "clear" )afin que vous puissiez l'utiliser au lieu d' system(3)appeler

Sont-ils disponibles en Unicode?

Oui. \u001b

Quelle version de ces couleurs est préférable?

Il est facile à utiliser 3/4-bit, mais il est beaucoup plus précis et beau à utiliser 24-bit.
Si vous n'avez pas d'expérience avecvoici donc un petit tutoriel:
24 bits signifie: 00000000et 00000000et 00000000. Chaque 8 bits correspond à une couleur spécifique.
1..8est pour et 9..16pour et 17..24pour
Donc , en #FF0000signifie et le voici:255;0;0
en #00FF00signifie qui est ici: 0;255;0
Est-ce que cela a du sens? quelle couleur vous voulez la combiner avec ces trois valeurs de 8 bits.


référence:
Wikipedia
séquences d'échappement ANSI
tldp.org
tldp.org
misc.flogisoft.com
quelques blogs / pages web dont je ne me souviens pas

Shakiba Moshiri
la source
70
Personne d'autre n'est vraiment étonné de cette réponse ??
Benj
14
C'est définitivement la réponse du Temple de la renommée, merci.
ForeverZer0
2
@NeilGuyLindberg pas de littéraux octaux cette erreur fait partie de Node.js pas elle-même eslist. vous pouvez utiliser x1B[pour l'éliminer.
Shakiba Moshiri
5
J'ai reculé assez loin pour voter pour cette réponse!
RNA
1
On dirait que @ShakibaMoshiri a écrit une thèse sur ce sujet xD Jokes apart, bravo pour une réponse aussi détaillée!
SH '
189

Utiliser tputavec la setafcapacité et un paramètre de 1.

echo "$(tput setaf 1)Hello, world$(tput sgr0)"
Ignacio Vazquez-Abrams
la source
8
Cela devrait être la meilleure option. ce que tput fait, c'est qu'il va lire les informations du terminal et rendre le code ANSI correctement échappé pour vous. du code comme celui- \033[31mci cassera la bibliothèque readline dans certains des terminaux.
Tian Chen
44
Explorez les couleurs avec une boucle simple (augmentez ila limite supérieure pour plus de nuances):for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done
msanford
2
Voici un HOWTO sur les codes tput
maxywb
tput: command not found(en alpin)
dgallant le
127
echo -e "\033[31m Hello World"

Le [31mcontrôle la couleur du texte:

  • 30- 37définit la couleur de premier plan
  • 40- 47définit la couleur d' arrière-plan

Une liste plus complète des codes de couleur peut être trouvée ici .

Il est recommandé de réinitialiser la couleur du texte \033[0mà la fin de la chaîne.

néocanable
la source
2
echo -e "\ 033 [31m Hello World", le [31m est la couleur
néocanable
36

Je viens de fusionner les bonnes prises dans toutes les solutions et je me suis retrouvé avec:

cecho(){
    RED="\033[0;31m"
    GREEN="\033[0;32m"
    YELLOW="\033[1;33m"
    # ... ADD MORE COLORS
    NC="\033[0m" # No Color

    printf "${!1}${2} ${NC}\n"
}

Et vous pouvez simplement l'appeler comme:

cecho "RED" "Helloworld"
Andrew Naguib
la source
1
Très pratique, je devais juste remplacer les guillemets simples par des guillemets doubles pour GREEN, YELLOW, NC pour le faire fonctionner dans mon script.
ionescu77
1
Excellente solution !!
David Kariuki
32

Ceci est le commutateur de couleur \033[ . Voir l' histoire .

Les codes de couleur sont comme 1;32(vert clair), 0;34(bleu), 1;34(bleu clair), etc.

Nous terminons les séquences de couleurs avec un commutateur de couleur \033[et 0mle code sans couleur. Tout comme l'ouverture et la fermeture des onglets dans un langage de balisage.

  SWITCH="\033["
  NORMAL="${SWITCH}0m"
  YELLOW="${SWITCH}1;33m"
  echo "${YELLOW}hello, yellow${NORMAL}"

echoSolution de fonction couleur simple :

cecho() {
  local code="\033["
  case "$1" in
    black  | bk) color="${code}0;30m";;
    red    |  r) color="${code}1;31m";;
    green  |  g) color="${code}1;32m";;
    yellow |  y) color="${code}1;33m";;
    blue   |  b) color="${code}1;34m";;
    purple |  p) color="${code}1;35m";;
    cyan   |  c) color="${code}1;36m";;
    gray   | gr) color="${code}0;37m";;
    *) local text="$1"
  esac
  [ -z "$text" ] && local text="$color$2${code}0m"
  echo "$text"
}

cecho "Normal"
cecho y "Yellow!"
Jorge Bucaran
la source
1
Je changerais la dernière textvariable de text="$color${@: 2}${code}0m"cette façon, toute la ligne, sauf le paramètre de couleur, sera colorée.
Shairon Toledo du
@tomazahlin ajoute simplement -e à l'écho, comme plusieurs fois mentionné ci-dessus
Artem Medvedev
Comme l'a suggéré Wilfred Hughes, il est préférable de l'utiliser tputcar il est plus portable - fonctionne également dans Bash sur macOS. Par conséquent, je suggère d'utiliser la fonction d'Alireza Mirian à partir de cette réponse: stackoverflow.com/a/23006365/2693875
Greg Dubicki Il y a
29

Une bonne façon de changer la couleur pour un seul echoest de définir une telle fonction:

function coloredEcho(){
    local exp=$1;
    local color=$2;
    if ! [[ $color =~ '^[0-9]$' ]] ; then
       case $(echo $color | tr '[:upper:]' '[:lower:]') in
        black) color=0 ;;
        red) color=1 ;;
        green) color=2 ;;
        yellow) color=3 ;;
        blue) color=4 ;;
        magenta) color=5 ;;
        cyan) color=6 ;;
        white|*) color=7 ;; # white or invalid color
       esac
    fi
    tput setaf $color;
    echo $exp;
    tput sgr0;
}

Usage:

coloredEcho "This text is green" green

Ou vous pouvez directement utiliser les codes de couleur mentionnés dans la réponse de Drew :

coloredEcho "This text is green" 2
Alireza Mirian
la source
Si vous ajoutez -nà l'écho, vous pouvez l'utiliser comme coloriage en ligneecho "Red `coloredEcho "fox" red` jumps over the lazy dog"
sobi3ch
24

Utilisez tputpour calculer les codes couleurs. Évitez d'utiliser le code d'échappement ANSI (par exemple \E[31;1mpour le rouge) car il est moins portable. Bash sous OS X, par exemple, ne le prend pas en charge.

BLACK=`tput setaf 0`
RED=`tput setaf 1`
GREEN=`tput setaf 2`
YELLOW=`tput setaf 3`
BLUE=`tput setaf 4`
MAGENTA=`tput setaf 5`
CYAN=`tput setaf 6`
WHITE=`tput setaf 7`

BOLD=`tput bold`
RESET=`tput sgr0`

echo -e "hello ${RED}some red text${RESET} world"
Wilfred Hughes
la source
18

Cette question a été répondue à maintes reprises :-) mais pourquoi pas.

La première utilisation tputest plus portable dans les environnements modernes que l'injection manuelle de codes ASCII viaecho -E

Voici une fonction bash rapide:

 say() {
     echo "$@" | sed \
             -e "s/\(\(@\(red\|green\|yellow\|blue\|magenta\|cyan\|white\|reset\|b\|u\)\)\+\)[[]\{2\}\(.*\)[]]\{2\}/\1\4@reset/g" \
             -e "s/@red/$(tput setaf 1)/g" \
             -e "s/@green/$(tput setaf 2)/g" \
             -e "s/@yellow/$(tput setaf 3)/g" \
             -e "s/@blue/$(tput setaf 4)/g" \
             -e "s/@magenta/$(tput setaf 5)/g" \
             -e "s/@cyan/$(tput setaf 6)/g" \
             -e "s/@white/$(tput setaf 7)/g" \
             -e "s/@reset/$(tput sgr0)/g" \
             -e "s/@b/$(tput bold)/g" \
             -e "s/@u/$(tput sgr 0 1)/g"
  }

Vous pouvez maintenant utiliser:

 say @b@green[[Success]] 

obtenir:

Un succès audacieux

Notes sur la portabilité des tput

Le premier tput(1)code source a été téléchargé en septembre 1986

tput(1) a été disponible dans la sémantique X / Open curses dans les années 1990 (la norme de 1997 a la sémantique mentionnée ci-dessous).

Donc, c'est ( assez ) omniprésent.

Ahmed Masud
la source
C'est plutôt cool! Je ne savais pas ça. Pouvez-vous nous parler de la disponibilité de tput? Est-il disponible sur la plupart des serveurs où l'on n'a pas les droits d'administrateur pour l'installer? Avez-vous un lien vers l'endroit où cette technique a été «inventée» pour la première fois?
Redsandro
3
tput est la manière conforme aux normes de le faire, où il est complètement indépendant de vous connaître les capacités du terminal. Si le terminal ne prend pas en charge une capacité donnée, il rétrogradera gracieusement à tout ce qu'il peut faire sans pousser les codes d'échappement vissés.
Ahmed Masud
1
J'ai cessé d'utiliser cette méthode car elle gâche la position du curseur dans les lignes de bash. Il s'enroulera au hasard avant la fin de la ligne et ne remontera pas jusqu'au début de la ligne lors de l'utilisation de l'accueil ou des touches fléchées. Revenir aux codes d'échappement manuels maladroits résout ce problème.
Redsandro
2
@Resandro - est-ce parce que vous l'utilisez $PS1sans \[...\]autour des parties non espacées? Continuez à utiliser les marqueurs Bash PS1 avec les chaînes tput.
Toby Speight
Notez que cette fonction ne fonctionne pas entièrement sur MacOsX en raison de différences dans l'utilitaire sed: unix.stackexchange.com/questions/13711/…
Jeff
14

Merci à @ k-five pour cette réponse

declare -A colors
#curl www.bunlongheng.com/code/colors.png

# Reset
colors[Color_Off]='\033[0m'       # Text Reset

# Regular Colors
colors[Black]='\033[0;30m'        # Black
colors[Red]='\033[0;31m'          # Red
colors[Green]='\033[0;32m'        # Green
colors[Yellow]='\033[0;33m'       # Yellow
colors[Blue]='\033[0;34m'         # Blue
colors[Purple]='\033[0;35m'       # Purple
colors[Cyan]='\033[0;36m'         # Cyan
colors[White]='\033[0;37m'        # White

# Bold
colors[BBlack]='\033[1;30m'       # Black
colors[BRed]='\033[1;31m'         # Red
colors[BGreen]='\033[1;32m'       # Green
colors[BYellow]='\033[1;33m'      # Yellow
colors[BBlue]='\033[1;34m'        # Blue
colors[BPurple]='\033[1;35m'      # Purple
colors[BCyan]='\033[1;36m'        # Cyan
colors[BWhite]='\033[1;37m'       # White

# Underline
colors[UBlack]='\033[4;30m'       # Black
colors[URed]='\033[4;31m'         # Red
colors[UGreen]='\033[4;32m'       # Green
colors[UYellow]='\033[4;33m'      # Yellow
colors[UBlue]='\033[4;34m'        # Blue
colors[UPurple]='\033[4;35m'      # Purple
colors[UCyan]='\033[4;36m'        # Cyan
colors[UWhite]='\033[4;37m'       # White

# Background
colors[On_Black]='\033[40m'       # Black
colors[On_Red]='\033[41m'         # Red
colors[On_Green]='\033[42m'       # Green
colors[On_Yellow]='\033[43m'      # Yellow
colors[On_Blue]='\033[44m'        # Blue
colors[On_Purple]='\033[45m'      # Purple
colors[On_Cyan]='\033[46m'        # Cyan
colors[On_White]='\033[47m'       # White

# High Intensity
colors[IBlack]='\033[0;90m'       # Black
colors[IRed]='\033[0;91m'         # Red
colors[IGreen]='\033[0;92m'       # Green
colors[IYellow]='\033[0;93m'      # Yellow
colors[IBlue]='\033[0;94m'        # Blue
colors[IPurple]='\033[0;95m'      # Purple
colors[ICyan]='\033[0;96m'        # Cyan
colors[IWhite]='\033[0;97m'       # White

# Bold High Intensity
colors[BIBlack]='\033[1;90m'      # Black
colors[BIRed]='\033[1;91m'        # Red
colors[BIGreen]='\033[1;92m'      # Green
colors[BIYellow]='\033[1;93m'     # Yellow
colors[BIBlue]='\033[1;94m'       # Blue
colors[BIPurple]='\033[1;95m'     # Purple
colors[BICyan]='\033[1;96m'       # Cyan
colors[BIWhite]='\033[1;97m'      # White

# High Intensity backgrounds
colors[On_IBlack]='\033[0;100m'   # Black
colors[On_IRed]='\033[0;101m'     # Red
colors[On_IGreen]='\033[0;102m'   # Green
colors[On_IYellow]='\033[0;103m'  # Yellow
colors[On_IBlue]='\033[0;104m'    # Blue
colors[On_IPurple]='\033[0;105m'  # Purple
colors[On_ICyan]='\033[0;106m'    # Cyan
colors[On_IWhite]='\033[0;107m'   # White


color=${colors[$input_color]}
white=${colors[White]}
# echo $white



for i in "${!colors[@]}"
do
  echo -e "$i = ${colors[$i]}I love you$white"
done

Résultat

entrez la description de l'image ici

J'espère que cette image vous aidera à choisir la couleur de votre bash: D

cyber8200
la source
Il convient de noter que cela nécessite bash v4.
Synox
14

Si vous utilisez zshoubash

black() {
    echo -e "\e[30m${1}\e[0m"
}

red() {
    echo -e "\e[31m${1}\e[0m"
}

green() {
    echo -e "\e[32m${1}\e[0m"
}

yellow() {
    echo -e "\e[33m${1}\e[0m"
}

blue() {
    echo -e "\e[34m${1}\e[0m"
}

magenta() {
    echo -e "\e[35m${1}\e[0m"
}

cyan() {
    echo -e "\e[36m${1}\e[0m"
}

gray() {
    echo -e "\e[90m${1}\e[0m"
}

black 'BLACK'
red 'RED'
green 'GREEN'
yellow 'YELLOW'
blue 'BLUE'
magenta 'MAGENTA'
cyan 'CYAN'
gray 'GRAY'

Essayez en ligne

Vishal
la source
14

Nous pouvons utiliser des couleurs vraies 24 bits RVB pour le texte et l'arrière-plan!

 ESC[38;2;⟨r⟩;⟨g⟩;⟨bm  /*Foreground color*/
 ESC[48;2;⟨r⟩;⟨g⟩;⟨bm  /*Background color*/

Exemple de texte rouge et de balise de fermeture:

 echo -e "\e[38;2;255;0;0mHello world\e[0m"

Générateur:

24 bits: Alors que les cartes graphiques en "vraie couleur" avec 16 à 24 bits de couleur sont devenues courantes, Xterm, Konsole de KDE, ainsi que tous les terminaux basés sur libvte (y compris le terminal GNOME) prennent en charge le réglage des couleurs de premier plan et d'arrière-plan 24 bits https: / /en.wikipedia.org/wiki/ANSI_escape_code#24-bit

Est-il sûr d'utiliser dans mes scripts?

Oui! Les terminaux 8 et 16 bits afficheront juste comme couleur de repli sur la gamme de la palette disponible, gardant le meilleur contraste, pas de casse!


De plus, personne n'a remarqué l'utilité de la vidéo inversée ANSI code 7 .

Il reste lisible sur toutes les couleurs de schémas de terminal, les arrière-plans noirs ou blancs ou d'autres palettes fantaisies, en échangeant les couleurs de premier plan et d'arrière-plan.

Exemple, pour un fond rouge qui fonctionne partout:

echo -e "\033[31;7mHello world\e[0m";

Voici à quoi cela ressemble lors du changement des schémas intégrés du terminal:

entrez la description de l'image ici

Ceci est le script de boucle utilisé pour le gif.

for i in {30..49};do echo -e "\033[$i;7mReversed color code $i\e[0m Hello world!";done

Voir https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters

NVRM
la source
11

Ces codes fonctionnent sur ma boîte Ubuntu:

entrez la description de l'image ici

echo -e "\x1B[31m foobar \x1B[0m"
echo -e "\x1B[32m foobar \x1B[0m"
echo -e "\x1B[96m foobar \x1B[0m"
echo -e "\x1B[01;96m foobar \x1B[0m"
echo -e "\x1B[01;95m foobar \x1B[0m"
echo -e "\x1B[01;94m foobar \x1B[0m"
echo -e "\x1B[01;93m foobar \x1B[0m"
echo -e "\x1B[01;91m foobar \x1B[0m"
echo -e "\x1B[01;90m foobar \x1B[0m"
echo -e "\x1B[01;89m foobar \x1B[0m"
echo -e "\x1B[01;36m foobar \x1B[0m"

Cela imprime les lettres abcd toutes de différentes couleurs:

echo -e "\x1B[0;93m a \x1B[0m b \x1B[0;92m c \x1B[0;93m d \x1B[0;94m"

Pour la boucle:

for (( i = 0; i < 17; i++ )); 
do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; 
done

entrez la description de l'image ici

Eric Leschinski
la source
2
Soit dit en passant: cela ne dépend pas beaucoup d'avoir installé une version spécifique d'ubuntu, mais d'utiliser PuTTY!
urzeit
11

J'ai trouvé la réponse impressionnante de Shakiba Moshiri pendant que je cherchais des informations sur ce sujet ... alors j'ai eu une idée ... et cela s'est terminé par une fonction assez agréable extrêmement facile à utiliser 😁
Donc je dois la partager 😉

https://github.com/ppo/bash-colors

Utilisation: à l' $(c <flags>) intérieur d'un echo -eouprintf

 ┌───────┬─────────────────┬──────────┐   ┌───────┬─────────────────┬──────────┐
  Code   Style            Octal        Code   Style            Octal    
 ├───────┼─────────────────┼──────────┤   ├───────┼─────────────────┼──────────┤
    -    Foreground       \033[3..       B    Bold             \033[1m  
    _    Background       \033[4..       U    Underline        \033[4m  
 ├───────┼─────────────────┼──────────┤      F    Flash/blink      \033[5m  
    k    Black            ......0m       N    Negative         \033[7m  
    r    Red              ......1m    ├───────┼─────────────────┼──────────┤
    g    Green            ......2m       L    Normal (unbold)  \033[22m 
    y    Yellow           ......3m       0    Reset            \033[0m  
    b    Blue             ......4m    └───────┴─────────────────┴──────────┘
    m    Magenta          ......5m 
    c    Cyan             ......6m 
    w    White            ......7m 
 └───────┴─────────────────┴──────────┘

Exemples:

echo -e "$(c 0wB)Bold white$(c) and normal"
echo -e "Normal text… $(c r_yB)BOLD red text on yellow background… $(c _w)now on
  white background… $(c 0U) reset and underline… $(c) and back to normal."
Pascal Polleunus
la source
10

Pour la lisibilité

Si vous souhaitez améliorer la lisibilité du code, vous pouvez d'abord echola chaîne puis ajouter la couleur plus tard en utilisant sed:

echo 'Hello World!' | sed $'s/World/\e[1m&\e[0m/' 
Ooker
la source
1
J'aime vraiment cette réponse! Pouvez-vous expliquer le $ dans la commande sed cependant?
Patrick
2
Le $ '<something>' est pour bash, pas sed. Il indique à bash de traiter le \ e comme une séquence d'échappement et de mettre un caractère "d'échappement". Habituellement, vous voyez les formes plus simples comme $ '\ t' ou $ '\ n' pour obtenir un caractère de tabulation ou de nouvelle ligne passé à un commander.
dsz
8

Jusqu'à présent, ma réponse préférée est Écho coloré.

Juste pour poster une autre option, vous pouvez consulter ce petit outil xcol

https://ownyourbits.com/2017/01/23/colorize-your-stdout-with-xcol/

vous l'utilisez comme grep, et il colorisera son stdin avec une couleur différente pour chaque argument, par exemple

sudo netstat -putan | xcol httpd sshd dnsmasq pulseaudio conky tor Telegram firefox "[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+" ":[[:digit:]]+" "tcp." "udp." LISTEN ESTABLISHED TIME_WAIT

exemple xcol

Notez qu'il accepte toute expression régulière que sed acceptera.

Cet outil utilise les définitions suivantes

#normal=$(tput sgr0)                      # normal text
normal=$'\e[0m'                           # (works better sometimes)
bold=$(tput bold)                         # make colors bold/bright
red="$bold$(tput setaf 1)"                # bright red text
green=$(tput setaf 2)                     # dim green text
fawn=$(tput setaf 3); beige="$fawn"       # dark yellow text
yellow="$bold$fawn"                       # bright yellow text
darkblue=$(tput setaf 4)                  # dim blue text
blue="$bold$darkblue"                     # bright blue text
purple=$(tput setaf 5); magenta="$purple" # magenta text
pink="$bold$purple"                       # bright magenta text
darkcyan=$(tput setaf 6)                  # dim cyan text
cyan="$bold$darkcyan"                     # bright cyan text
gray=$(tput setaf 7)                      # dim white text
darkgray="$bold"$(tput setaf 0)           # bold black = dark gray text
white="$bold$gray"                        # bright white text

J'utilise ces variables dans mes scripts comme ça

echo "${red}hello ${yellow}this is ${green}coloured${normal}"
nachoparker
la source
6

Pour développer cette réponse , pour les paresseux:

function echocolor() { # $1 = string
    COLOR='\033[1;33m'
    NC='\033[0m'
    printf "${COLOR}$1${NC}\n"
}

echo "This won't be colored"
echocolor "This will be colorful"
Mahn
la source
2
Ne pas échapper le terminal en code dur. Utilisation tput; c'est pour ça!
Toby Speight
@TobySpeight Bien que cela puisse être vrai pour le support multiplateforme (en théorie), si l'affiche trouve que cela fonctionne dans leur propre monde, pourquoi être en désaccord et dissuader les autres dans un monde similaire d'utiliser la technique? Par exemple, j'essaye similaire dans Ubuntu 16.04 bash et cela fonctionne. En tant que seul utilisateur sur cette plateforme, je trouve cette réponse acceptable. Je vais également utiliser tputpour scet rcbien (enregistrer le curseur, restaurer le curseur). Bien que cette réponse m'appelle «paresseuse», elle pourrait être reformulée comme «pratique» ou «directe».
WinEunuuchs2Unix
Ma propre solution était similaire à celle-ci, confinée purement aux shell intégrés, parce que la fourche de deux processus externes, sous-coquilles, etc. pour chaque message dans un script avait juste une odeur ... désagréable.
Amit Naidu
6

pour afficher la sortie du message avec des couleurs différentes, vous pouvez créer:

echo -e "\033[31;1mYour Message\033[0m"

-Noir 0; 30 Gris foncé 1; 30

-Rouge 0; 31 Rouge clair 1; 31

-Vert 0; 32 Vert clair 1; 32

-Brun / Orange 0; 33 Jaune 1; 33

-Bleu 0; 34 Bleu clair 1; 34

-Pourpre 0; 35 Violet clair 1; 35

-Cyan 0; 36 Cyan clair 1; 36

-Gris clair 0; 37 Blanc 1; 37

Amirouche Zeggagh
la source
5

Vous devez absolument utiliser tput sur des séquences de contrôle ANSI brutes.

Comme il existe un grand nombre de langages de contrôle de terminal différents, un système possède généralement une couche de communication intermédiaire. Les vrais codes sont recherchés dans une base de données pour le type de terminal actuellement détecté et vous donnez des requêtes standardisées à une API ou (depuis le shell) à une commande.

L'une de ces commandes est tput. tputaccepte un ensemble d'acronymes appelés noms de capacité et tous les paramètres, le cas échéant, recherche ensuite les séquences d'échappement correctes pour le terminal détecté dans la base de données terminfo et imprime les codes corrects (le terminal comprend, espérons-le).

depuis http://wiki.bash-hackers.org/scripting/terminalcodes

Cela dit, j'ai écrit une petite bibliothèque d'aide appelée bash-tint , qui ajoute une autre couche au-dessus de tput, ce qui la rend encore plus simple à utiliser (à mon humble avis):

Exemple: tint "white(Cyan(T)Magenta(I)Yellow(N)Black(T)) is bold(really) easy to use."

Donnerait le résultat suivant: entrez la description de l'image ici

ArtBIT
la source
5

Au lieu de coder en dur les codes d'échappement spécifiques à votre terminal actuel, vous devriez les utiliser tput.

Voici mon script de démonstration préféré:

#!/bin/bash

tput init

end=$(( $(tput colors)-1 ))
w=8
for c in $(seq 0 $end); do
    eval "$(printf "tput setaf %3s   " "$c")"; echo -n "$_"
    [[ $c -ge $(( w*2 )) ]] && offset=2 || offset=0
    [[ $(((c+offset) % (w-offset))) -eq $(((w-offset)-1)) ]] && echo
done

tput init

256 couleurs sorties par tput

Bruno Bronosky
la source
4

J'utilise ceci pour l'impression couleur

#!/bin/bash
#--------------------------------------------------------------------+
#Color picker, usage: printf $BLD$CUR$RED$BBLU'Hello World!'$DEF     |
#-------------------------+--------------------------------+---------+
#       Text color        |       Background color         |         |
#-----------+-------------+--------------+-----------------+         |
# Base color|Lighter shade| Base color   | Lighter shade   |         |
#-----------+-------------+--------------+-----------------+         |
BLK='\e[30m'; blk='\e[90m'; BBLK='\e[40m'; bblk='\e[100m' #| Black   |
RED='\e[31m'; red='\e[91m'; BRED='\e[41m'; bred='\e[101m' #| Red     |
GRN='\e[32m'; grn='\e[92m'; BGRN='\e[42m'; bgrn='\e[102m' #| Green   |
YLW='\e[33m'; ylw='\e[93m'; BYLW='\e[43m'; bylw='\e[103m' #| Yellow  |
BLU='\e[34m'; blu='\e[94m'; BBLU='\e[44m'; bblu='\e[104m' #| Blue    |
MGN='\e[35m'; mgn='\e[95m'; BMGN='\e[45m'; bmgn='\e[105m' #| Magenta |
CYN='\e[36m'; cyn='\e[96m'; BCYN='\e[46m'; bcyn='\e[106m' #| Cyan    |
WHT='\e[37m'; wht='\e[97m'; BWHT='\e[47m'; bwht='\e[107m' #| White   |
#-------------------------{ Effects }----------------------+---------+
DEF='\e[0m'   #Default color and effects                             |
BLD='\e[1m'   #Bold\brighter                                         |
DIM='\e[2m'   #Dim\darker                                            |
CUR='\e[3m'   #Italic font                                           |
UND='\e[4m'   #Underline                                             |
INV='\e[7m'   #Inverted                                              |
COF='\e[?25l' #Cursor Off                                            |
CON='\e[?25h' #Cursor On                                             |
#------------------------{ Functions }-------------------------------+
# Text positioning, usage: XY 10 10 'Hello World!'                   |
XY () { printf "\e[$2;${1}H$3"; }                                   #|
# Print line, usage: line - 10 | line -= 20 | line 'Hello World!' 20 |
line () { printf -v _L %$2s; printf -- "${_L// /$1}"; }             #|
# Create sequence like {0..(X-1)}                                    |
que () { printf -v _N %$1s; _N=(${_N// / 1}); printf "${!_N[*]}"; } #|
#--------------------------------------------------------------------+

Toutes les couleurs de base sont définies en tant que vars et il existe également des fonctions utiles: XY, line et que. Sourcez ce script dans l'un des vôtres et utilisez toutes les variables et fonctions de couleur.

Ivan
la source
3

Et c'est ce que j'ai utilisé pour voir toutes les combinaisons et décider ce qui se lit cool:

for (( i = 0; i < 8; i++ )); do
    for (( j = 0; j < 8; j++ )); do
        printf "$(tput setab $i)$(tput setaf $j)(b=$i, f=$j)$(tput sgr0)\n"
    done
done
isntn
la source
2

J'ai écrit swag pour y parvenir.

Tu peux juste faire

pip install swag

Vous pouvez maintenant installer toutes les commandes d'échappement sous forme de fichiers txt vers une destination donnée via:

swag install -d <colorsdir>

Ou encore plus simple via:

swag install

Qui va installer les couleurs ~/.colors.

Soit vous les utilisez comme ceci:

echo $(cat ~/.colors/blue.txt) This will be blue

Ou de cette façon, que je trouve en fait plus intéressante:

swag print -c red -t underline "I will turn red and be underlined"

Découvrez-le sur asciinema !

throws_exceptions_at_you
la source
0

Voici un petit script simple, que j'ai mis en place récemment, qui colorisera toute entrée canalisée au lieu d'utiliser "Toilette".

File: color.bsh

#!/usr/bin/env bash 

## A.M.Danischewski 2015+(c) Free - for (all (uses and 
## modifications)) - except you must keep this notice intact. 

declare INPUT_TXT=""
declare    ADD_LF="\n" 
declare -i DONE=0
declare -r COLOR_NUMBER="${1:-247}"
declare -r ASCII_FG="\\033[38;05;"
declare -r COLOR_OUT="${ASCII_FG}${COLOR_NUMBER}m"

function show_colors() { 
   ## perhaps will add bg 48 to first loop eventually 
 for fgbg in 38; do for color in {0..256} ; do 
 echo -en "\\033[${fgbg};5;${color}m ${color}\t\\033[0m"; 
 (($((${color}+1))%10==0)) && echo; done; echo; done
} 

if [[ ! $# -eq 1 || ${1} =~ ^-. ]]; then 
  show_colors 
  echo " Usage: ${0##*/} <color fg>" 
  echo "  E.g. echo \"Hello world!\" | figlet | ${0##*/} 54" 
else  
 while IFS= read -r PIPED_INPUT || { DONE=1; ADD_LF=""; }; do 
  PIPED_INPUT=$(sed 's#\\#\\\\#g' <<< "${PIPED_INPUT}")
  INPUT_TXT="${INPUT_TXT}${PIPED_INPUT}${ADD_LF}"
  ((${DONE})) && break; 
 done
 echo -en "${COLOR_OUT}${INPUT_TXT}\\033[00m"
fi 

Appelez-le ensuite avec la couleur rouge (196):
$> echo "text you want colored red" | color.bsh 196


la source
La logique de la boucle de couleur a été trouvée dans ce tutoriel de couleurs Ascii décent: misc.flogisoft.com/bash/tip_colors_and_formatting
-1

Faire référence à:

echo_red(){
    echo -e "\e[1;31m$1\e[0m"
}
echo_green(){
    echo -e "\e[1;32m$1\e[0m"
}
echo_yellow(){
    echo -e "\e[1;33m$1\e[0m"
}
echo_blue(){
    echo -e "\e[1;34m$1\e[0m"
}
Mike
la source
Notez que la fonction echo_green doit avoir le code 32 au lieu de 33. Impossible de modifier b / c stackoverflow nécessite au moins 6 caractères d'édition.
Daniel
-2

Voici la solution la plus simple et lisible. Avec bashj ( https://sourceforge.net/projects/bashj/ ), vous choisiriez simplement l'une de ces lignes:

#!/usr/bin/bash

W="Hello world!"
echo $W

R=130
G=60
B=190

echo u.colored($R,$G,$B,$W)

echo u.colored(255,127,0,$W)
echo u.red($W)
echo u.bold($W)
echo u.italic($W)

Y=u.yellow($W)
echo $Y
echo u.bold($Y)

256x256x256 les couleurs sont disponibles si vous avez la prise en charge des couleurs dans votre application de terminal.

Fil
la source
-3

après avoir mélangé d'autres solutions à partir du fil, voici comment j'ai réussi à obtenir des couleurs en npm scriptssortie (gitbash CLI):

{
    "deploy": "echo \u001b[1;32m && ng build && echo \u001b[1;0mdeploy {\u001b[1;33mcopy\u001b[1;0m: \u001b[1;32m0% && cp -r -f dist/packaged/* \\\\SERVER-01\\dist\\ && echo \u001b[1;0mdeploy {\u001b[1;33mcopy\u001b[1;0m} \u001b[1;34m\u001b[1;1m100% DEPLOYED"
}

entrez la description de l'image ici

déesse fraise
la source
-4

Tout comme quelque chose un peu là-bas, le faire passer par grep le mettra en surbrillance en rouge (mais seulement en rouge). Vous pouvez également utiliser des canaux nommés pour que votre chaîne soit plus proche de la fin de la ligne:

 grep '.*' --color=always <(echo "foobar")
FinalDuty
la source
il vous manque le point de pouvoir sélectionner la couleur de votre choix. grep aussi comme un utilitaire de coloration est vraiment discutable: P
Ahmed Masud
Pas vraiment, OP a spécifiquement mentionné qu'ils voulaient du rouge. Je suis d'accord qu'il existe de meilleures options que d'utiliser grep, mais cela permet de réaliser ce qu'ils ont demandé et évite d'avoir à apprendre quelque chose de plus complexe.
FinalDuty
-5
red='\e[0;31m'
NC='\e[0m' # No Color
echo -e "${red}Hello Stackoverflow${NC}"

Cette réponse est correcte, sauf que l'appel aux couleurs ne doit pas être à l'intérieur des guillemets.

echo -e ${red}"Hello Stackoverflow"${NC}

Devrait faire l'affaire.

Dale Corns
la source
3
Fonctionne bien à l'intérieur des guillemets. le commutateur -e évalue également ce qui est entre guillemets. L'exécution des deux guillemets (internes et externes) à l'aide de bash -x génère la même commande exécutée echo -e '\e[0;31mHello Stackoverflow\e[0m'. Il en va de même pour bash.
naab