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

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

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)

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:

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.)

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

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

résumé des couleurs avec leurs valeurs

blinking sur KDE-Terminal

un Ccode simple qui vous en montre plus

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

prise de vue en mode couleur

prise de vue en mode texte

la combinaison est OK

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 dansfrapper, c, c ++, ré perl, python

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;

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 avechtmlvoici 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 , enhtml #FF0000signifie et le voici:255;0;0
enhtml #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

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

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

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.

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"

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!"

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

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"

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:

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.

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

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

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

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

 ESC[38;2;⟨r⟩;⟨g⟩;⟨b⟩m  /*Foreground color*/
 ESC[48;2;⟨r⟩;⟨g⟩;⟨b⟩m  /*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:

text.addEventListener("input",update)
back.addEventListener("input",update)

function update(){
  let a = text.value.substr(1).match(/.{1,2}/g)
  let b = back.value.substr(1).match(/.{1,2}/g)
  out1.textContent = "echo -e \"\\" + `033[38;2;${parseInt(a[0],16)};${parseInt(a[1],16)};${parseInt(a[2],16)}mHello\"`
  out2.textContent = "echo -e \"\\" + `033[48;2;${parseInt(b[0],16)};${parseInt(b[1],16)};${parseInt(b[2],16)}mWorld!\"`
}

div {padding:1rem;font-size:larger}

TEXT COLOR: <input type="color" id="text" value="#23233">
<br><div id="out1"></div>
BACK COLOR: <input type="color" id="back" value="#FFFF00">
<br><div id="out2">

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:

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

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

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."

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

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

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

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"

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

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:

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

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.

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

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 !

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

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

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.

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

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")

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.