web-dev-qa-db-fra.com

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

J'essaie d'imprimer un texte dans le terminal à l'aide de la commande echo.

Je veux imprimer le texte en rouge. Comment puis je faire ça?

1493
satheesh.droid

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 ensuite, 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 love en rouge.

D'après le commentaire de @ james-lim, si vous utilisez la commande echo, veillez à utiliser l'indicateur -e pour autoriser les échappements de barre oblique inversée .

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

(N'ajoutez pas "\n" lorsque vous utilisez echo, sauf si vous souhaitez ajouter une ligne vide supplémentaire)

2007
Tobias

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


Usage

Des sous-commandes spécifiques tput sont discutées plus tard.

Direct

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

_tput setaf 1; echo "this is red text"
_

Utilisez _;_ au lieu de _&&_ donc si tput erreurs, le texte reste affiché.

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}"
_

tput produit des séquences de caractères interprétées par le terminal comme ayant une signification particulière. Ils ne seront pas montré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 commande

Il peut être plus pratique d’insérer la sortie de tput directement dans vos chaînes echo en utilisant 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:

Screenshot of colour terminal text


Commandes de couleur de premier plan et de fond

_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 (setb à la place de setab et setf à la place de setaf) qui utilisent des numéros différents, non indiqué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 fenêtres flottantes , la commande bel fait vaciller le terminal pendant une seconde pour attirer l'attention de l'utilisateur.


Les scripts

tput accepte les scripts contenant une commande par ligne, qui sont exécutés dans l'ordre avant la sortie de tput.

É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 terminfo pour la liste complète des commandes et plus de détails sur ces options. (La commande tput correspondante est répertoriée dans la colonne _Cap-name_ de l'énorme tableau qui commence à la ligne 81.)
852
Drew Noakes

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

petit 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 spéciales

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

vous devez ajouter des caractères d'échappement supplémentaires pour que bash puisse les interpréter correctement. Sans l'ajout de caractères d'échappement supplémentaires, cela fonctionne, mais vous rencontrerez des problèmes lorsque vous utilisez Ctrl + r pour 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 tout code de fin.
Exemple:
en usage régulier: \033[32mThis is in green\033[0m
pour PS0/1/2/4: \[\033[32m\]This is in green\[\033[m\]

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

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

type de séquence de couleur:

  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 de couleur

Il modifie le style de couleur PAS du texte. Par exemple, rendre la couleur plus claire ou plus sombre.

  • 0 reset
  • 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 supporté sur Gnome-Terminal.

2. mode texte

Ce mode sert à modifier le style du texte, PAS la couleur.

  • 3; italique
  • 4; souligné
  • 5; clignotant (lent)
  • 6; clignotant (rapide)
  • 7; inverse
  • 8; masquer
  • 9; barré

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

3. mode de premier plan

Ce mode sert à coloriser le premier plan.

4. mode de fond

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

Le tableau ci-dessous présente un résumé de la version 3/4 bit 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[32m |         |       | yellow           | echo -e "\033[33m####\033[m" |                                      |
|         34 | \033[32m |         |       | blue             | echo -e "\033[34m####\033[m" |                                      |
|         35 | \033[32m |         |       | purple           | echo -e "\033[35m####\033[m" | real name: Magenta = reddish-purple  |
|         36 | \033[32m |         |       | cyan             | echo -e "\033[36m####\033[m" |                                      |
|         37 | \033[32m |         |       | 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é de la 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

résumé au premier plan en 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

enter image description hereenter image description hereenter image description hereenter image description here

blinking sur KDE-Terminal

KDE-blinking

un simple code C qui vous en montre plus

cecho_screenshot

un outil plus avancé que j'ai développé pour traiter ces couleurs:

bline


tir en mode couleur

fade-normal-bright

tir en mode texte

only-text-mode

la combinaison est OK

combine

plus de coups


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

Peut-on utiliser ces codes dans un langage de programmation?

Oui, vous pouvez. J'ai expérimenté dans bash , c , c ++ , dPerl , python

Sont-ils ralentir la vitesse d'un programme?

Je pense que non.

Pouvons-nous les utiliser sous Windows?

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

Comment calculer la longueur du code?

\033[ = 2, autres parties 1

Où pouvons-nous utiliser ces codes?

Partout où il y a un interprète tty
xterm, gnome-terminal, kde-terminal, mysql-client-CLI et ainsi de suite.
Par exemple, si vous voulez coloriser votre sortie avec mysql, vous pouvez utiliser Perl

#!/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;

enregistrez ce code dans un nom de fichier: pcc (= Perl Colorize Character), puis placez le fichier a dans PATH valide, puis utilisez-le où bon vous semble.

ls | pcc
df | pcc

dans mysql, inscrivez-le d'abord pour pager et essayez ensuite:

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

pcc

Il PAS ne gère 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 avec system( "clear" ) afin que vous puissiez utiliser ceci au lieu de system(3) call

Sont-ils disponibles en Unicode?

Oui. \u001b

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

Il est facile d’utiliser 3/4-bit, mais il est beaucoup plus précis et beau d’utiliser 24-bit.
Si vous n'avez pas d'expérience avec html , voici un tutoriel rapide:
24 bits signifie: 00000000 et 00000000 et 00000000. Chaque 8 bits est pour une couleur spécifique.
1..8 est pour  et 9..16 pour  et 17..24 pour 
Donc, dans html#FF0000 signifie  et le voici: 255;0;0
in html#00FF00 signifie  qui est ici: 0;255;0
Cela a-t-il du sens? quelle couleur vous voulez le combiner avec ces trois valeurs 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

666
Shakiba Moshiri

Utilisez tput avec la capacité setaf et un paramètre de 1.

echo "$(tput setaf 1)Hello, world$(tput sgr0)"
177
echo -e "\033[31m Hello World"

Le [31m contrôle la couleur du texte:

  • 30-37 définit la couleur de l'avant-plan
  • 40-47 définit la couleur de fond

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

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

113
Neo

C'est le commutateur de couleur \033[. Voir historique .

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 0m, le no - code de couleur. Tout comme l'ouverture et la fermeture d'onglets dans un langage de balisage.

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

Couleur simple echo solution fonctionnelle:

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!"
31
Jorge Bucaran

Un moyen intéressant de changer de couleur pour un seul echo consiste à définir cette 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 réponse de Drew :

coloredEcho "This text is green" 2
29
Alireza Mirian

Je viens d'amalgamer les bonnes prises dans toutes les solutions et j'ai fini par:

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"
24
Andrew Naguib

Utilisez tput pour calculer les codes de couleur. Évitez d'utiliser le code d'échappement ANSI (par exemple, \E[31;1m pour 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"
22
Wilfred Hughes

Cette question a été répondue encore et encore :-) mais pourquoi pas.

D'abord, utiliser tput est plus portable dans les environnements modernes que d'injecter manuellement les codes ASCII via echo -E

Voici une fonction rapide bash:

 say() {
     echo "[email protected]" | sed \
             -e "s/\(\(@\(red\|green\|yellow\|blue\|Magenta\|cyan\|white\|reset\|b\|u\)\)\+\)[[]\{2\}\(.*\)[]]\{2\}/\1\[email protected]/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"
  }

Maintenant vous pouvez utiliser:

 say @[email protected][[Success]] 

obtenir:

Bold-Green Success

Notes sur la portabilité de tput

La première fois que tput(1) le code source a été téléchargé en septembre 1986

tput(1) était disponible dans la sémantique X/Open curses dans les années 1990 (le standard de 1997 contient la sémantique mentionnée ci-dessous).

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

19
Ahmed Masud

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

enter image description here

J'espère que cela image vous aider à choisir votre couleur pour votre bash: D

14
kyo

Ces codes fonctionnent sur ma boîte Ubuntu:

enter image description here

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"

Ceci imprime les lettres a b c d toutes de couleurs différentes:

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

Pour boucle:

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

enter image description here

12
Eric Leschinski

Pour la lisibilité

Si vous voulez améliorer la lisibilité du code, vous pouvez commencer par echo puis ajouter la couleur plus tard en utilisant sed:

echo 'Hello World!' | sed $'s/World/\e[1m&\e[0m/' 
10
Ooker

Ma réponse préférée jusqu'ici est coloréeEcho.

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 exactement comme grep, et il colorera 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

xcol example

Notez qu'il accepte toutes les expressions régulières acceptées par sed.

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 si

echo "${red}hello ${yellow}this is ${green}coloured${normal}"
9
nachoparker

Personne n'a remarqué l'utilité de la vidéo inversée de code ANSI 7 .

Il reste lisible sur toutes les couleurs de schémas de terminaux, d’arrière-plans noirs ou blancs, ou d’autres palettes fantaisies, en permutant les couleurs d’avant-plan et d’arrière-plan.

Exemple, pour un fond rouge qui fonctionne partout:

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

Voici à quoi ça ressemble quand on change les schémas intégrés du terminal:

enter image description here

C'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

6
NVRM

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"
6
Mahn

Vous devez absolument utiliser tput sur les 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 dispose généralement d'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 (à partir du shell) à une commande.

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

à partir de 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: enter image description here

4
ArtBIT

J'ai écrit Swag pour atteindre cet objectif.

Vous pouvez 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 facilement via:

Swag install

Ce qui installera les couleurs sur ~/.colors.

Soit vous les utilisez comme ceci:

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

Ou de cette façon, que je trouve réellement plus intéressant:

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

Vérifiez-le sur asciinema !

3

Et c'est ce que j'avais l'habitude de voir toutes les combinaisons et de décider laquelle se lit bien:

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
3
isntn

pour afficher le message avec différentes couleurs, vous pouvez créer:

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

-Noir 0; 30 Gris foncé 1; 30

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

-Purple 0; 35 Light Purple 1; 35

-Cyan 0; 36 Cyan Clair 1; 36

-Light Grey 0; 37 Blanc 1; 37

1
Amirouche Zeggagh

Voici une implémentation qui fonctionne sur un terminal MacOS pour configurer PS1 avec coloration et ainsi de suite.

Il existe deux implémentations, l'une reposant sur l'écho et l'autre sur printf pour invoquer dynamiquement des méthodes sans se déchaîner.

C'est juste un début mais robuste et ne clignotera pas le terminal. Prend en charge git branch pour le moment, mais peut être étendu pour faire un certain nombre de choses à terme.

Peut être trouvé ici:

https://github.com/momomo/opensource/blob/master/momomo.com.Shell.style.sh

Devrait fonctionner en copiant et collant. Pas de dépendances.

0
momomo

Voici un petit script simple, que j’ai composé récemment, qui colorise toutes les entrées raccordées au lieu d’utiliser "Toilet".

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 

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

0
user4401178

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"
}
0
Mike