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?
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)
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:
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 terminfopour la liste complète des commandes et plus de détails sur ces options. (La commandetputcorrespondante est répertoriée dans la colonne _Cap-name_ 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 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:
- 3/4 bit
- 8 bits
- 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.
0reset1;plus léger que la normale2;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;italique4;souligné5;clignotant (lent)6;clignotant (rapide)7;inverse8;masquer9;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
résumé de fond 8 bits dans un .gif
résumé des couleurs avec leurs valeurs
blinking sur KDE-Terminal
un simple code C qui vous en montre plus
un outil plus avancé que j'ai développé pour traiter ces couleurs:
tir en mode couleur
tir en mode texte
la combinaison est OK
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 ttyxterm, 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 | pccdf | 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;
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
Utilisez tput avec la capacité setaf et un paramètre de 1.
echo "$(tput setaf 1)Hello, world$(tput sgr0)"
echo -e "\033[31m Hello World"
Le [31m contrôle la couleur du texte:
30-37définit la couleur de l'avant-plan40-47dé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.
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!"
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
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"
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"
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 "$@" | 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"
}
Maintenant vous pouvez utiliser:
say @b@green[[Success]]
obtenir:
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.
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 cela image vous aider à choisir votre couleur pour votre bash: D
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"
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
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/'
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
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}"
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:
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
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"
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.tputaccepte 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: 
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 !
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
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
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.
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
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"
}