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?
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?
Réponses:
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 love
en rouge.
D'après le commentaire de @ james-lim, si vous utilisez la echo
commande, 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)
\e[0;31mHello Stackoverflow\e[0m
echo
d'activer les échappements antislash.
\x1B
au lieu de \e
. \033
serait ok pour toutes les plateformes.
for (( i = 30; i < 38; i++ )); do echo -e "\033[0;"$i"m Normal: (0;$i); \033[1;"$i"m Light: (1;$i)"; done
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.
Des tput
sous-commandes spécifiques sont discutées plus loin.
Appelez tput
dans le cadre d'une séquence de commandes:
tput setaf 1; echo "this is red text"
Utiliser ;
au lieu de&&
si en cas d' tput
erreurs le texte s'affiche toujours.
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 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.
Il peut être plus pratique d'insérer tput
la sortie de directement dans vos echo
chaînes en utilisant la substitution de commande :
echo "$(tput setaf 1)Red text $(tput setab 7)and white background$(tput sgr 0)"
La commande ci-dessus produit ceci sur Ubuntu:
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
au lieu de setab
et setf
au lieu de setaf
) qui utilisent des nombres différents, non donnés ici.
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
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
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
tput sgr0 # Reset text format to the terminal's default
tput bel # Play a bell
Avec les fenêtres tremblantes compiz , la bel
commande fait osciller le terminal pendant une seconde pour attirer l'attention de l'utilisateur.
tput
accepte les scripts contenant une commande par ligne, qui sont exécutés dans l'ordre avant de tput
quitter.
É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
man 1 tput
man 5 terminfo
pour la liste complète des commandes et plus de détails sur ces options. (La tput
commande correspondante est répertoriée dans la Cap-name
colonne de l'énorme tableau qui commence à la ligne 81.)$()
c'est une substitution de commande . Il tput af 1
suffit de générer la chaîne de code couleur, mais les codes ne sont pas des caractères imprimables, donc la saisie tput af 1
seule produira une ligne de sortie vierge.
ncurses
tput
couleurs, consultez cette réponse sur Unix StackExchange
reset=`tput sgr0`
devrait être reset=`tput sgr 0`
, avec un espace.
# 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
| | 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 |
| | | | | |
| 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 |
| | | | | |
Si vous allez utiliser ces codes dans vos variables bash spéciales
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 + r
pour la recherche dans votre historique.
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\]
Avant de plonger dans ces couleurs, vous devez connaître 4 modes avec ces codes:
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.
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.
Ce mode sert à coloriser le premier plan.
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 |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
premier plan résumé 8 bits dans un .gif
résumé de fond 8 bits dans un .gif
blinking
sur KDE-Terminal
un C
code simple qui vous en montre plus
un outil plus avancé que j'ai développé pour faire face à ces couleurs:
Oui, vous pouvez. J'ai vécu dansfrapper, c, c ++, ré perl, python
Je pense que non.
3/4 bits Oui, si vous compilez le code avec gcc
quelques captures d'écran sur Win-7
\033[
= 2, autres parties 1
Partout qui a un tty
interprète
xterm
, gnome-terminal
, kde-terminal
, mysql-client-CLI
et 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 PATH
puis utilisez-le où vous voulez.
ls | pcc
df | pcc
à l' intérieur d' mysql
abord l' enregistrer pour pager
puis essayer:
[user2:db2] pager pcc
PAGER set to 'pcc'
[user2:db2] select * from table-name;
Il ne gère PAS Unicode.
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
Oui. \u001b
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: 00000000
et 00000000
et 00000000
. Chaque 8 bits correspond à une couleur spécifique.
1..8
est pour et 9..16
pour et 17..24
pour
Donc , enhtml #FF0000
signifie et le voici:255;0;0
enhtml #00FF00
signifie 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
x1B[
pour l'éliminer.
Utiliser tput
avec la setaf
capacité et un paramètre de 1
.
echo "$(tput setaf 1)Hello, world$(tput sgr0)"
\033[31m
ci cassera la bibliothèque readline dans certains des terminaux.
i
la limite supérieure pour plus de nuances):for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done
tput: command not found
(en alpin)
echo -e "\033[31m Hello World"
Le [31m
contrôle la couleur du texte:
30
- 37
définit la couleur de premier plan40
- 47
définit la couleur d' arrière-planUne 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 0m
le 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}"
echo
Solution 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!"
text
variable de text="$color${@: 2}${code}0m"
cette façon, toute la ligne, sauf le paramètre de couleur, sera colorée.
tput
car il est plus portable - fonctionne également dans Bash sur macOS. Par conséquent, je suggère d'utiliser la fonction d'Alireza Mirian à partir de cette réponse: stackoverflow.com/a/23006365/2693875
Une bonne façon de changer la couleur pour un seul echo
est 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
-n
à l'écho, vous pouvez l'utiliser comme coloriage en ligneecho "Red `coloredEcho "fox" red` jumps over the lazy dog"
Utilisez tput
pour calculer les codes couleurs. É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 à maintes reprises :-) mais pourquoi pas.
La première utilisation tput
est 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:
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.
tput
? Est-il disponible sur la plupart des serveurs où l'on n'a pas les droits d'administrateur pour l'installer? Avez-vous un lien vers l'endroit où cette technique a été «inventée» pour la première fois?
$PS1
sans \[...\]
autour des parties non espacées? Continuez à utiliser les marqueurs Bash PS1 avec les chaînes tput.
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
J'espère que cette image vous aidera à choisir la couleur de votre bash: D
Si vous utilisez zsh
oubash
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'
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:
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 -e
ouprintf
┌───────┬─────────────────┬──────────┐ ┌───────┬─────────────────┬──────────┐
│ 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."
Si vous souhaitez améliorer la lisibilité du code, vous pouvez d'abord echo
la 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"
tput
; c'est pour ça!
tput
pour sc
et rc
bien (enregistrer le curseur, restaurer le curseur). Bien que cette réponse m'appelle «paresseuse», elle pourrait être reformulée comme «pratique» ou «directe».
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
.tput
accepte 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."
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.
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 scripts
sortie (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.
echo -e '\e[0;31mHello Stackoverflow\e[0m'
. Il en va de même pour bash.