Vous pouvez utiliser ces ANSI codes d'échappement :

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='3[0;31m'
NC='3[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 , assurez-vous d'utiliser le drapeau-e pour permettre les échappées de backslash.

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

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

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

---

Utilisation

Spécifique tput sous-commandes sont discutés plus tard.

Direct

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

tput setaf 1; echo "this is red text"

Use ; au lieu de && donc si tput erreurs le texte montre toujours.

variables Shell

une autre option est d'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 qui sont interprétées par le terminal comme ayant une signification particulière. Ils ne seront pas montrés. Notez qu'ils peuvent encore être enregistrées dans des fichiers ou traitées par des programmes autres que l' terminal.

commande de substitution

il peut être plus commode 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 ce sur Ubuntu:

---

commande de couleurs avant-plan et 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 aussi des versions non-ANSI des fonctions de réglage des couleurs ( setb au lieu de setab , et setf au lieu de setaf ) qui utilisent des numéros différents, Non indiqués ici.

mode Texte les commandes

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 les 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 compiz wobbly windows , la commande bel fait vaciller le terminal pendant une seconde pour attirer l'attention de l'utilisateur.

---

Scripts

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

Evitez les fichiers temporaires en faisant écho à une chaîne multiligne et en la raccordant:

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

---

Voir aussi

• voir man 1 tput
• voir man 5 terminfo pour la liste complète des commandes et plus de détails sur ces options. (Correspondant à la tput la commande est listée dans la colonne Cap-name de l'énorme table qui commence à la ligne 81.)

quelques variables que vous pouvez utiliser:

# Reset
Color_Off='3[0m'       # Text Reset

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

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

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

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

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

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

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

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

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

bref exemple:

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

Bash exception:

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

• 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 cet ajout de caractères d'échappement supplémentaires, il fonctionne, mais vous allez faire face à des problèmes lorsque vous utilisez Ctrl + r pour la recherche dans votre histoire.

exceptional rule for bash

vous devez ajouter \[ avant tout code ANSI de départ et ajouter \] après tout code de fin.

Exemple:

en usage régulier: 3[32mThis is in green3[0m

pour PS0/1/2/4: \[3[32m\]This is in green\[3[m\]

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

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

conseil: pour le mémoriser vous pouvez d'abord ajouter \[\] et puis mettre votre code ANSI entre eux:

- \[start-ANSI-code\]

- \[end-ANSI-code\]

type de séquence de couleur:

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

avant de plonger dans ces couleurs, vous devriez connaître environ 4 modes avec ces codes:

1. mode couleur

il modifie le style de la couleur et non le texte. Par exemple, faites la couleur claire ou plus foncée.

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

ce mode n'est pas largement supporté. Il est entièrement compatible avec Gnome-Terminal.

2. mode texte

ce mode est pour modifier le style du texte et non la couleur.

• 3; italique
• 4; souligner
• 5; clignotement (lent)
• 6; clignotant (rapide)
• 7; reverse
• 8; cacher
• 9; croix

et sont presque supportés.

Par exemple KDE-Konsole supporte 5; mais Gnome-Terminal ne supporte pas et Gnome supporte 8; mais KDE ne supporte pas.

3. mode premier plan

This le mode est pour colorer le premier plan.

4. mode d'arrière-plan

ce mode est pour colorer le fond.

le tableau ci-dessous montre un résumé de 3/4 bit version de ANSI-Couleur

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

le tableau ci-dessous montre un résumé de 8 bit version de ANSI-Couleur

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

de La 8-bit test rapide:

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

le tableau ci-dessous montre un résumé de 24 bits version de ANSI-Couleur

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

quelques captures d'écran

premier plan Résumé en 8 bits dans un .gif

arrière-plan 8 bits résumé dans un .gif

résumé couleur avec leurs valeurs

blinking on KDE-Terminal

un simple C code qui vous montre plus

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

---

couleur-mode prise de vue

mode texte shot

combiner est OK

plus de photos

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

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

Oui, vous le pouvez. J'ai vécu dans bash , c , c++ , d perl , python

ralentissent-ils la vitesse d'un programme?

je pense, non.

peut-on les utiliser sur Windows?

3/4-bit Oui, si vous compilez le code avec gcc

quelques captures d'écran sur Win-7

comment calculer la longueur du code?

3[ = 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.

Exemple si vous voulez coloriser votre sortie avec mysql vous pouvez utiliser Perl

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

stockez ce code dans un nom de fichier: pcc (= caractère Perl coloriser) puis mettez le fichier a dans valide PATH puis utilisez-le où vous voulez.

ls | pcc

df | pcc

inside mysql enregistrer d'abord pour pager et ensuite essayer:

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

Il ne PAS gérer l'Unicode.

de ces codes seulement colorisation?

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

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

ou:

echo -e '3[2J3[u' # clear the screen and reset the position

Il ya beaucoup de débutants qui veulent effacer l'écran avec system( "clear" ) donc vous pouvez utiliser ce au lieu de system(3) appel

sont-ils disponibles en Unicode?

Oui. \u001b

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

Il est facile à utiliser 3/4-bit , mais elle est très précise et agréable à utiliser 24-bit .

Si vous n'avez pas d'expérience avec html voici donc un tutoriel rapide:

24 bits signifie: 00000000 et 00000000 et 00000000 . Chaque 8 bits est pour une couleur spécifique.

24..17 est pour et 16..9 pour et 8..1 pour

Ainsi, dans html #FF0000 signifie et voici: 255;0;0

dans html #00FF00 signifie qui, ici, est: 0;255;0

Cela fait-il sens? quelle couleur vous voulez le combiner avec ces trois valeurs 8-bit.

référence:

Wikipedia

séquences d'évasion de L'ANSI

tldp.org

tldp.org

misc.flogisoft.com

certains blogs / pages web que je ne me souviens pas

badges:

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

echo "$(tput setaf 1)Hello, world$(tput sgr0)"

echo -e "3[31m Hello World"

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

• 30 - 37 sets premier plan couleur
• 40 - 47 les ensembles arrière-plan couleur

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

Il est de bonne pratique pour réinitialiser la couleur du texte de retour à 3[0m au bout de la chaîne.

C'est le la couleur de l'interrupteur 3[ . Voir histoire .

couleur codes sont comme 1;32 (Vert Clair), 0;34 (Bleu), 1;34 (Bleu clair), etc.

nous terminons les séquences de couleur avec un commutateur de couleur 3[ et 0m , le no - code de couleur. Tout comme l'ouverture et la fermeture les onglets dans un langage de balisage.

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

de couleur Simple "151980920 de la fonction" solution:

cecho() {
  local code="3["
  case "" 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=""
  esac
  [ -z "$text" ] && local text="$color${code}0m"
  echo "$text"
}

cecho "Normal"
cecho y "Yellow!"

une façon soignée de changer de couleur seulement pour un echo est de définir une telle fonction:

function coloredEcho(){
    local exp=;
    local color=;
    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;
}

Utilisation:

coloredEcho "This text is green" green

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

coloredEcho "This text is green" 2

utilisez tput pour calculer les codes de couleur. Évitez d'utiliser le code d'échappement ANSI (par exemple \E[31;1m pour le rouge) parce qu'il est moins portable. Bash sur OS X, par exemple, ne le supporte pas.

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"

cette question a été répondue à plusieurs reprises :-) mais pourquoi pas.

la première utilisation de tput est plus portable dans les environnements modernes que l'injection manuelle de codes ASCII par le biais de echo -E

Voici une fonction de bash rapide:

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

Maintenant vous pouvez utiliser:

 say @b@green[[Success]] 

pour obtenir:

Notes sur la portabilité de tput

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

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

Donc, c'est ( tout à fait ) omniprésente.

ces codes fonctionnent sur ma boîte Ubuntu:

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 a b C D tous dans des 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

merci à @k-five pour cette réponse

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

# Reset
colors[Color_Off]='3[0m'       # Text Reset

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

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

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

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

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

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

# High Intensity backgrounds
colors[On_IBlack]='3[0;100m'   # Black
colors[On_IRed]='3[0;101m'     # Red
colors[On_IGreen]='3[0;102m'   # Green
colors[On_IYellow]='3[0;103m'  # Yellow
colors[On_IBlue]='3[0;104m'    # Blue
colors[On_IPurple]='3[0;105m'  # Purple
colors[On_ICyan]='3[0;106m'    # Cyan
colors[On_IWhite]='3[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

Espère que cette image vous aider à choisir votre couleur pour votre bash :D

Pour des raisons de lisibilité

si vous voulez améliorer la lisibilité du code, vous pouvez echo la chaîne d'abord puis Ajouter la couleur plus tard en utilisant sed :

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

ma réponse préférée jusqu'à présent est coloredEcho.

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 va coloriser ses 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

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 so

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

pour développer sur cette réponse , pour les paresseux de nous:

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

echo "This won't be colored"
echocolor "This will be colorful"

et c'est ce que j'ai utilisé pour voir toutes les combinaisons et décider qui 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

j'ai écrit swag pour y arriver.

il Vous suffit de faire

pip install swag

maintenant vous pouvez installer toutes les commandes d'échappement comme des fichiers txt à une destination donnée via:

swag install -d <colorsdir>

ou encore plus facile via:

swag install

qui installera les couleurs à ~/.colors .

soit vous les utilisez comme ceci:

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

Ou, ce que je trouve en fait plus intéressant:

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

Check it out on asciinema !

personne n'a remarqué l'utilité du code ANSI 7 vidéo inversée .

il reste lisible sur n'importe quelles couleurs de schèmes de terminal, des fonds noirs ou blancs, ou d'autres palettes de fantaisies, en échangeant des couleurs de premier plan et d'arrière-plan.

exemple, pour un fond rouge qui fonctionne partout:

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

C'est à quoi il ressemble quand changer le terminal intégré dans les schémas:

c'est le script de boucle utilisé pour le gif.

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

voir https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_ (Select_Graphic_Rendition)_paramètres

vous devez absolument utiliser le débit sur les séquences brutes de contrôle ANSI.

parce qu'il y a un grand nombre de contrôles terminaux différents les langues, généralement un système a une couche de communication intermédiaire. Les codes réels sont recherchés dans une base de données type de terminal et vous donnez des requêtes standardisées à une API ou (de le shell) pour une commande.

Une de ces commandes est tput . tput accepte un ensemble d'Acronymes appelés les noms des capacités et les paramètres, s'il y a lieu, séquences d'échappement correctes pour le terminal détecté dans le terminfo base de données et imprime les codes corrects (le terminal espérons comprendre.)

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 sur le dessus du tput, le rendant encore plus simple à utiliser (imho):

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

donnerait le résultat suivant:

voici un petit script simple, que j'ai mis ensemble récemment, qui va coloriser toute entrée par canalisation 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 ||  =~ ^-. ]]; 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 

alors appelez-le avec la couleur Rouge (196):

$> echo "text you want colored red" | color.bsh 196

Voici la solution la plus simple et lisible. Avec bashj ( https://sourceforge.net/projects/bashj / ), il vous suffit de choisir 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 de la couleur dans votre application de terminal.

tout comme quelque chose d'un peu là-bas, en le passant par grep mettra en évidence comme rouge (mais seulement rouge). Vous pouvez aussi utiliser des pipes nommées pour que votre chaîne soit plus proche de la fin de la ligne:

 grep '.*' --color=always <(echo "foobar")

red='\e[0;31m'
NC='\e[0m' # No Color
echo -e "${red}Hello Stackoverflow${NC}"

Cette réponse correcte, sauf que l'appel de couleurs ne doivent pas être entre guillemets.

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

Devrait faire l'affaire.