Vieni a cambiare il colore di output di echo in Linux
Sto cercando di stampare un testo nel terminale usando il comando echo.
Voglio stampare il testo in un colore rosso. Come lo posso fare?
È possibile utilizzare questi codici di escape 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
E poi usali così nella tua sceneggiatura:
# .---------- 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"
che stampa love in rosso.
Dal commento di @james-lim, se si utilizza il comando echo, assicurarsi di utilizzare il flag -e per consentire l'escape dei backslash .
# Continued from above example
echo -e "I ${RED}love${NC} Stack Overflow"
(non aggiungere "\n" quando si usa echo a meno che non si desideri aggiungere una riga vuota aggiuntiva)
Puoi usare il fantastico comando tput (suggerito in la risposta di Ignacio ) per produrre codici di controllo del terminale per tutti i tipi di cose.
Uso
I sotto-comandi tput specifici sono discussi in seguito.
Diretto
Chiama tput come parte di una sequenza di comandi:
tput setaf 1; echo "this is red text"
Usa ; anziché && quindi se tput errori il testo continua a essere visualizzato.
Variabili Shell
Un'altra opzione è usare le variabili Shell:
red=`tput setaf 1`
green=`tput setaf 2`
reset=`tput sgr0`
echo "${red}red text ${green}green text${reset}"
tput produce sequenze di caratteri interpretate dal terminale come aventi un significato speciale. Non saranno mostrati loro stessi. Si noti che possono ancora essere salvati in file o elaborati come input da programmi diversi dal terminale.
Sostituzione del comando
Potrebbe essere più comodo inserire l'output di tput direttamente nelle stringhe echo usando la sostituzione di comando :
echo "$(tput setaf 1)Red text $(tput setab 7)and white background$(tput sgr 0)"
Esempio
Il comando precedente lo produce su Ubuntu:
Comandi di colore di primo piano e di sfondo
tput setab [1-7] # Set the background colour using ANSI escape
tput setaf [1-7] # Set the foreground colour using ANSI escape
I colori sono i seguenti:
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
Esistono anche versioni non ANSI delle funzioni di impostazione del colore (setb anziché setab e setf invece di setaf) che utilizzano numeri diversi, non dati qui.
Comandi in modalità testo
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
Comandi di movimento del cursore
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
Cancella e inserisci i comandi
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
Altri comandi
tput sgr0 # Reset text format to the terminal's default
tput bel # Play a bell
Con compiz wobbly windows , il comando bel fa in modo che il terminale oscilli per un secondo per attirare l'attenzione dell'utente.
Script
tput accetta script contenenti un comando per riga, che vengono eseguiti in ordine prima che tput esca.
Evita i file temporanei riecheggiando una stringa multilinea e collegandola alla rete:
echo -e "setf 7\nsetb 1" | tput -S # set fg white and bg red
Guarda anche
- Vedi
man 1 tput - Vedi
man 5 terminfoper l'elenco completo dei comandi e maggiori dettagli su queste opzioni. (Il comandotputcorrispondente è elencato nella colonnaCap-namedell'enorme tabella che inizia alla riga 81.)
alcune variabili che puoi usare:
# 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
il carattere di escape in bash , hex e octal rispettivamente:
| | 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 |
| | | | | |
breve esempio:
| 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 |
| | | | | |
eccezione bash:
Se intendi utilizzare questi codici nelle tue variabili di battuta speciali
- PS0
- PS1
- PS2 (= questo è per chiedere)
- PS4
dovresti aggiungere caratteri di escape extra in modo che bash possa interpretarli correttamente. Senza questa aggiunta di caratteri di escape aggiuntivi funziona, ma si incontrano problemi quando si utilizza Ctrl + r per la ricerca nella cronologia.
regola di eccezione per bash
Dovresti aggiungere \[ prima di ogni codice ANSI di partenza e aggiungere \] dopo ogni finale.
Esempio:
nell'uso regolare: \033[32mThis is in green\033[0m
per PS0/1/2/4: \[\033[32m\]This is in green\[\033[m\]
\[ è per l'inizio di una sequenza di caratteri non stampabili \] è per la fine di una sequenza di caratteri non stampabili
Suggerimento: per memorizzarlo puoi prima aggiungere \[\] e poi inserire il tuo codice ANSI tra di loro:
- \[start-ANSI-code\]
- \[end-ANSI-code\]
tipo di sequenza di colori:
- 3/4 bit
- 8 bit
- 24 bit
Prima di immergerti in questi colori, dovresti conoscere 4 modalità con questi codici:
1. modalità colore
Modifica lo stile del colore NOT text. Ad esempio, rendere il colore più luminoso o più scuro.
0reset1;più leggero del normale2;più scuro del normale
Questa modalità non è supportata ampiamente. È completamente supportato su Gnome-Terminal.
2. modalità testo
Questa modalità serve a modificare lo stile del testo NON a colori.
3;corsivo4;sottolineatura5;lampeggiante (lento)6;lampeggiante (veloce)7;reverse8;nascondi9;cross-out
e sono quasi supportati.
Ad esempio KDE-Konsole supporta 5; ma Gnome-Terminal non lo supporta e Gnome supporta 8; ma KDE no.
3. modalità di primo piano
Questa modalità è per colorare il primo piano.
4. modalità sfondo
Questa modalità è per colorare lo sfondo.
La tabella seguente mostra un riepilogo di versione a 3/4 bit di ANSI-color
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
| 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 | |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
La tabella seguente mostra un riepilogo di versione a 8 bit di ANSI-color
|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
| 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 |
|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
Il test rapido a 8 bit:for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done
La tabella seguente mostra un riepilogo di versione a 24 bit di ANSI-color
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
| 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 |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
alcune schermate
riassunto in primo piano a 8 bit in un .gif
sommario in 8 bit di sfondo in un .gif
riassunto dei colori con i loro valori
blinkingsu KDE-Terminal
un semplice codice Cche ti mostra di più
uno strumento più avanzato che ho sviluppato per gestire questi colori:
scatto in modalità colore
modalità testo sparato
la combinazione è OK
altri scatti
Suggerimenti e trucchi per utenti esperti e programmatori:
Possiamo usare questi codici in un linguaggio di programmazione?
Si, puoi. Ho sperimentato in bash , c , c ++ , dPerl , python
Stanno rallentando la velocità di un programma?
Penso che nessuno.
Possiamo usarli su Windows?
3/4-bit Sì, se si compila il codice con gccname__
alcuni screenshot su Win-7
Come calcolare la lunghezza del codice?
\033[ = 2, altre parti 1
Dove possiamo usare questi codici?
Ovunque abbia un interprete ttyname__xtermname__, gnome-terminal, kde-terminal, mysql-client-CLI e così via.
Ad esempio se vuoi colorare il tuo output con mysql puoi usare Perlname__
#!/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;
memorizzare questo codice in un nome file: pcc(= Perl Colorize Character) e quindi inserire il file in PATHvalido quindi utilizzarlo ovunque si desideri.
ls | pccdf | pcc
all'interno mysqlprima registrarlo per pagere quindi provare:
[user2:db2] pager pcc
PAGER set to 'pcc'
[user2:db2] select * from table-name;
Esso NON gestisce Unicode.
Questi codici fanno solo la colorazione?
No, possono fare molte cose interessanti. Provare:
echo -e '\033[2K' # clear the screen and do not move the position
o:
echo -e '\033[2J\033[u' # clear the screen and reset the position
Ci sono molti principianti che vogliono cancellare lo schermo con system( "clear" ) in modo da poter usare questo al posto di system(3) call
Sono disponibili in Unicode?
Sì. \u001b
Quale versione di questi colori è preferibile?
È facile da usare 3/4-bit, ma è molto preciso e bello da usare 24-bit.
Se non hai esperienza con html ecco un breve tutorial:
24 bit significa: 00000000 e 00000000 e 00000000. Ogni 8 bit è per un colore specifico.1..8 è per 
e 9..16 per 
e 17..24 per 
Quindi in html#FF0000 significa ed eccolo qui: 255;0;0
in html#00FF00 significa che qui è: 0;255;0
Ha senso? di che colore vuoi combinarlo con questi tre valori a 8 bit.
riferimento:
Wikipedia
Sequenze di escape ANSI
tldp.org
tldp.org
misc.flogisoft.com
alcuni blog/pagine web che non ricordo
Utilizzare tput con la capacità setaf e un parametro di 1.
echo "$(tput setaf 1)Hello, world$(tput sgr0)"
echo -e "\033[31m Hello World"
[31m controlla il colore del testo:
30-37sets colore in primo piano40-47sets colore di sfondo
Un elenco più completo di codici colore può essere trovato qui .
È buona norma reimpostare il colore del testo su \033[0m alla fine della stringa.
Questo è l'interruttore di colore \033[. Vedi cronologia .
I codici colore sono come 1;32 (verde chiaro), 0;34 (blu), 1;34 (azzurro) , eccetera.
Terminiamo sequenze di colori con un interruttore di colore \033[ e 0m, il no - codice colore. Proprio come aprire e chiudere le schede in un linguaggio di marcatura.
SWITCH="\033["
NORMAL="${SWITCH}0m"
YELLOW="${SWITCH}1;33m"
echo "${YELLOW}hello, yellow${NORMAL}"
Soluzione di colore semplice echo:
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 modo pulito per cambiare colore solo per uno echo è definire tale funzione:
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;
}
Uso:
coloredEcho "This text is green" green
Oppure potresti usare direttamente i codici colore citati in Risposta di Drew :
coloredEcho "This text is green" 2
Utilizzare tput per calcolare i codici colore. Evita di utilizzare il codice di escape ANSI (ad esempio \E[31;1m per il rosso) perché è meno portabile. Bash su OS X, ad esempio, non lo supporta.
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"
A questa domanda è stata data una risposta ancora e ancora :-) ma perché no.
Il primo utilizzo di tput è più portabile negli ambienti moderni rispetto all'iniezione manuale di ASCII codici attraverso echo -E
Ecco una rapida funzione bash:
say() {
echo "[email protected]" | sed \
-e "s/\(\(@\(red\|green\|yellow\|blue\|Magenta\|cyan\|white\|reset\|b\|u\)\)\+\)[[]\{2\}\(.*\)[]]\{2\}/\1\[email protected]/g" \
-e "s/@red/$(tput setaf 1)/g" \
-e "s/@green/$(tput setaf 2)/g" \
-e "s/@yellow/$(tput setaf 3)/g" \
-e "s/@blue/$(tput setaf 4)/g" \
-e "s/@Magenta/$(tput setaf 5)/g" \
-e "s/@cyan/$(tput setaf 6)/g" \
-e "s/@white/$(tput setaf 7)/g" \
-e "s/@reset/$(tput sgr0)/g" \
-e "s/@b/$(tput bold)/g" \
-e "s/@u/$(tput sgr 0 1)/g"
}
Ora puoi usare:
say @[email protected][[Success]]
ottenere:
Note sulla portabilità di tput
La prima volta che il codice sorgente tput(1) è stato caricato nel settembre 1986
tput(1) è stato disponibile nella semantica X/Open curses negli anni '90 (lo standard del 1997 ha la semantica menzionata di seguito).
Quindi, è ( abbastanza ) onnipresente.
Ho appena amalgamato le buone catture in tutte le soluzioni e ho finito con:
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"
}
E puoi chiamarlo semplicemente:
cecho "RED" "Helloworld"
Grazie a @ k-five per questa risposta
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
Risultato
Spero che questa immagine ti aiuti a scegliere il colore per il tuo bash: D
Questi codici funzionano sulla mia scatola 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"
Questo stampa le lettere a b c d tutte in diversi colori:
echo -e "\x1B[0;93m a \x1B[0m b \x1B[0;92m c \x1B[0;93m d \x1B[0;94m"
Per ciclo:
for (( i = 0; i < 17; i++ ));
do echo "$(tput setaf $i)This is ($i) $(tput sgr0)";
done
Per leggibilità
Se si desidera migliorare la leggibilità del codice, è possibile echo la stringa, quindi aggiungere il colore in un secondo momento utilizzando sed:
echo 'Hello World!' | sed $'s/World/\e[1m&\e[0m/'
La mia risposta preferita finora è colorata Eco.
Solo per pubblicare un'altra opzione, puoi dare un'occhiata a questo piccolo strumento xcol
https://ownyourbits.com/2017/01/23/colorize-your-stdout-with-xcol/
lo usi proprio come grep, e colorerà il suo stdin con un colore diverso per ogni argomento, per esempio
Sudo netstat -putan | xcol httpd sshd dnsmasq pulseaudio conky tor Telegram firefox "[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+" ":[[:digit:]]+" "tcp." "udp." LISTEN ESTABLISHED TIME_WAIT
Si noti che accetta qualsiasi espressione regolare che sed accetterà.
Questo strumento utilizza le seguenti definizioni
#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
Uso queste variabili nei miei script in questo modo
echo "${red}hello ${yellow}this is ${green}coloured${normal}"
Per espandere questa risposta , per i più pigri di noi:
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"
Nessuno ha notato l'utilità del video ANSI 7 invertito .
Rimane leggibile su qualsiasi schema di terminali colori, sfondi neri o bianchi o altre tavolozze di fantasia, scambiando i colori di primo piano e di sfondo.
Esempio, per uno sfondo rosso che funziona ovunque:
echo -e "\033[31;7mHello world\e[0m";
Ecco come appare quando si cambiano gli schemi integrati del terminale:
Questo è lo script di loop usato per la gif.
for i in {30..49};do echo -e "\033[$i;7mReversed color code $i\e[0m Hello world!";done
Vedi https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_ (Select_Graphic_Rendition) _parameters
Dovresti sicuramente usare tput su sequenze di controlli ANSI grezzi.
Poiché esiste un gran numero di linguaggi di controllo dei terminali differenti, in genere un sistema ha un livello di comunicazione intermedio. I codici reali vengono cercati in un database per il tipo di terminale correntemente rilevato e vengono fornite richieste standardizzate a un'API o (dalla shell) a un comando.
Uno di questi comandi è
tput.tputaccetta un insieme di acronimi chiamati nomi di capacità e qualsiasi parametro, se appropriato, quindi cerca le sequenze di escape corrette per il terminale rilevato nel database terminfo e stampa i codici corretti (il terminale si spera comprenda).
da http://wiki.bash-hackers.org/scripting/terminalcodes
Detto questo, ho scritto una piccola libreria helper chiamata bash-tint , che aggiunge un altro strato sopra tput, rendendolo ancora più semplice da usare (imho) :
Esempio: tint "white(Cyan(T)Magenta(I)Yellow(N)Black(T)) is bold(really) easy to use."
Darebbe il seguente risultato: 
Ho scritto Swag per ottenere proprio questo.
Puoi solo farlo
pip install Swag
Ora puoi installare tutti i comandi di escape come file txt in una data destinazione tramite:
Swag install -d <colorsdir>
O ancora più semplice tramite:
Swag install
Che installerà i colori su ~/.colors.
O li usi così:
echo $(cat ~/.colors/blue.txt) This will be blue
O in questo modo, che trovo in realtà più interessante:
Swag print -c red -t underline "I will turn red and be underlined"
Dai un'occhiata a asciinema !
E questo quello che vedevo tutte le combinazioni e decidere che legge bene:
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
Ecco una semplice piccola sceneggiatura, che ho messo insieme di recente, che colorerà qualsiasi input in pipe invece di usare "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
Quindi chiamalo con il colore rosso (196):$> echo "text you want colored red" | color.bsh 196
Fare riferimento a:
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"
}