Come modificare il colore di output di eco in Linux


Risposte:


2297

È 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ì nel tuo 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"

che stampa lovein rosso.

Dal commento di @james-lim, se si utilizza il echocomando, assicurarsi di utilizzare il flag -e per consentire le escape di barra rovesciata .

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

(non aggiungere "\n"quando si utilizza echo a meno che non si desideri aggiungere una riga vuota aggiuntiva)


11
Non funziona per me - uscita:\e[0;31mHello Stackoverflow\e[0m
Ben Harold

172
Hai provato con "-e"? Indica echodi abilitare le escape backslash.
James Lim,

142
In MacOSX, usando \x1Binvece di \e. \033andrebbe bene per tutte le piattaforme.
Xiao,

4
In un file di proprietà della formica utilizzare unicode per esacpe, ad esempio red = \ u001b [0; 31m
utente Linux

20
Come msanford creato per tput, ecco "ANSI-Rainbow"for (( i = 30; i < 38; i++ )); do echo -e "\033[0;"$i"m Normal: (0;$i); \033[1;"$i"m Light: (1;$i)"; done
ogni uomo il

971

Puoi usare il fantastico tputcomando (suggerito nella risposta di Ignacio ) per produrre codici di controllo terminali per ogni genere di cose.


uso

Sottocomandi specifici tputverranno discussi più avanti.

Diretto

Chiama tputcome parte di una sequenza di comandi:

tput setaf 1; echo "this is red text"

Utilizzare ;invece di &&così se gli tputerrori il testo mostra ancora.

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

tputproduce sequenze di caratteri che vengono interpretate dal terminale come aventi un significato speciale. Non verranno 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 tputl'output direttamente nelle echostringhe usando la sostituzione dei comandi :

echo "$(tput setaf 1)Red text $(tput setab 7)and white background$(tput sgr 0)"

Esempio

Il comando sopra produce questo su Ubuntu:

Schermata del testo del terminale a colori


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 ( setbanziché setabe setfanziché setaf) che utilizzano numeri diversi, non indicati 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 le finestre traballanti di Compiz , il belcomando fa oscillare il terminale per un secondo per attirare l'attenzione dell'utente.


Script

tputaccetta script contenenti un comando per riga, che vengono eseguiti in ordine prima di tputuscire.

Evita i file temporanei facendo eco a una stringa multilinea e eseguendone il piping:

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

Guarda anche

  • Vedere man 1 tput
  • Vedi man 5 terminfol'elenco completo dei comandi e maggiori dettagli su queste opzioni. (Il tputcomando corrispondente è elencato nella Cap-namecolonna dell'enorme tabella che inizia alla riga 81.)

13
Bella risposta. Questo è quello che mi ha aiutato di più. Per chiunque si stesse chiedendo cosa mi stavo chiedendo, $()è una sostituzione di comando . Tutto tput af 1ciò che genera è generare la stringa di codice colore, ma i codici non sono caratteri stampabili, quindi la tput af 1sola digitazione produrrà una riga vuota di output.
Chris Middleton,

5
Nota: se stai usando CygWin e non hai l'installazione di tputncurses
Enrico,

3
tput funziona anche all'interno di sed per l'analisi dell'innesto in
legft

1
Per un elenco completo dei tputcolori dai un'occhiata a questa risposta su Unix StackExchange
Andrew

Penso che reset=`tput sgr0`dovrebbe essere reset=`tput sgr 0`, con uno spazio.
Monkeypants,

835

alcune variabili che è possibile utilizzare:

# 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 rispettivamente in bash , hex e ottale :

|       | 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 hai intenzione di usare questi codici nelle tue variabili bash speciali

  • PS0
  • PS1
  • PS2 (= questo è per il prompt)
  • PS4

dovresti aggiungere altri caratteri di escape in modo che può interpretarli correttamente. Senza questo aggiungere ulteriori caratteri di escape funziona ma incontrerai problemi quando usi la Ctrl + rricerca nella tua cronologia.

regola di eccezione per bash

È necessario aggiungere \[prima di qualsiasi codice ANSI iniziale e aggiungere \]dopo quelli finali.
Esempio:
in uso normale: \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 non stampabili caratteri
\]è per la fine di una sequenza di non stampabili caratteri

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

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

Prima di immergerti in questi colori, dovresti conoscere 4 modalità con questi codici:

1. modalità colore

Modifica lo stile del colore NON il testo. Ad esempio, rendere il colore più chiaro o più scuro.

  • 0 Ripristina
  • 1; più leggero del normale
  • 2; più scuro del normale

Questa modalità non è ampiamente supportata. È pienamente supportato su Gnome-Terminal.

2. modalità testo

Questa modalità serve per modificare lo stile del testo NON a colori.

  • 3; corsivo
  • 4; sottolineare
  • 5; lampeggiante (lento)
  • 6; lampeggiante (veloce)
  • 7; inversione
  • 8; nascondere
  • 9; cross-out

e sono quasi supportati.
Ad esempio KDE-Konsole supporta 5;ma Gnome-Terminal no e Gnome supporta 8;ma KDE no.

3. modalità primo piano

Questa modalità serve per colorare il primo piano.

4. modalità sfondo

Questa modalità serve per colorare lo sfondo.

La tabella seguente mostra un riepilogo della 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[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                                            |                                                                                       |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|

La tabella seguente mostra un riepilogo della 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 veloce 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 della 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

primo piano riepilogo a 8 bit in a .gif

foreground.gif

riepilogo in background a 8 bit in a .gif

background.gif

riepilogo dei colori con i loro valori

inserisci qui la descrizione dell'immagine inserisci qui la descrizione dell'immagine inserisci qui la descrizione dell'immagine inserisci qui la descrizione dell'immagine

blinking sul terminale KDE

KDE-lampeggiante

un semplice Ccodice che ti mostra di più

cecho_screenshot

uno strumento più avanzato che ho sviluppato per gestire questi colori:

Bline


colpo in modalità colore

fade-normale-luminoso

colpo in modalità testo

solo-text-mode

la combinazione è OK

combinare

più colpi


Suggerimenti e trucchi per utenti avanzati e programmatori:

Possiamo usare questi codici in un linguaggio di programmazione?

Si, puoi. Ho sperimentato in, , , ,

Stanno rallentando la velocità di un programma?

Penso che nessuno.

Possiamo usarli su Windows?

3/4-bit Sì, se si compila il codice con gcc
alcune schermate su Win-7

Come calcolare la lunghezza del codice?

\033[ = 2, altre parti 1

Dove possiamo usare questi codici?

Da nessuna parte che ha un ttyinterprete
xterm, gnome-terminal, kde-terminal, mysql-client-CLIe così via.
Ad esempio, se vuoi colorare il tuo output con mysql, puoi usarloPerl

#!/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;

memorizza questo codice in un nome di file: pcc(= Perl Colorize Character) e quindi metti il ​​file a in valido PATHquindi usalo dove preferisci.

ls | pcc
df | pcc

dentro mysqlprima registralo per pagere poi prova:

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

pcc

Essa 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 in system( "clear" )modo da poter usare questo invece di system(3)chiamare

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 conquindi ecco un breve tutorial:
24 bit significa: 00000000e 00000000e 00000000. Ogni 8 bit è per un colore specifico.
1..8è per e 9..16per e 17..24per
So in #FF0000significa ed eccolo qui: 255;0;0
in #00FF00significa che qui è: ha 0;255;0
senso? di che colore vuoi combinalo con questi tre valori a 8 bit.


riferimento:
Wikipedia
ANSI sequenze di escape
tldp.org
tldp.org
misc.flogisoft.com
alcuni blog / pagine Web che non ricordo


70
Nessun altro è davvero stupito da questa risposta ??
Benj

14
Questa è sicuramente la risposta alla Hall of Fame, grazie.
ForeverZer0

2
@NeilGuyLindberg no letterali ottali questo errore fa parte di Node.js e non si elenca da solo. puoi usarlo x1B[per eliminarlo.
Shakiba Moshiri,

5
Sono tornato abbastanza indietro per votare questa risposta!
RNA

1
Sembra che @ShakibaMoshiri abbia scritto una tesi su questo argomento xD Scherzi a parte, applausi per una risposta così dettagliata!
SH '

189

Utilizzare tputcon la setafcapacità e un parametro di 1.

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

8
Questa dovrebbe essere l'opzione migliore. ciò che fa tput è leggere le informazioni sul terminale e renderizzare il codice ANSI con escape corretto per te. codice come \033[31mromperà la libreria readline in alcuni dei terminali.
Tian Chen

44
Esplora i colori con un semplice ciclo (aumenta iil limite superiore per più sfumature):for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done
msanford

2
Ecco un HOWTO sui codici tput
maxywb

tput: command not found(su alpino)
decantato il

127
echo -e "\033[31m Hello World"

Il [31mcontrolla il colore del testo:

  • 30- 37imposta il colore di primo piano
  • 40- 47imposta il colore di sfondo

Un elenco più completo di codici colore è disponibile qui .

È buona norma ripristinare il colore del testo \033[0malla fine della stringa.


2
echo -e "\ 033 [31m Hello World", il [31m è il colore
neocanabile

36

Ho appena unito 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 semplicemente chiamarlo come:

cecho "RED" "Helloworld"

1
Molto pratico, ho dovuto sostituire solo virgolette singole con virgolette doppie per VERDE, GIALLO, NC per farlo funzionare nella mia sceneggiatura.
ionescu77,

1
Ottima soluzione !!
David Kariuki,

31

Questo è l' interruttore del colore\033[ . Vedi la storia .

I codici colore sono come 1;32(Verde chiaro), 0;34(Blu), 1;34(Blu chiaro), ecc.

Terminiamo le sequenze di colori con un interruttore di colore \033[e 0mil codice no- color . Proprio come aprire e chiudere le schede in un linguaggio di markup.

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

echoSoluzione di funzione colore semplice :

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

1
Modificherei l'ultima textvariabile in text="$color${@: 2}${code}0m"questo modo l'intera linea tranne il parametro color verrà colorato.
Shairon Toledo,

@tomazahlin ha appena aggiunto -e all'eco, come più volte menzionato sopra
Artem Medvedev

28

Un modo preciso 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 puoi usare direttamente i codici colore citati nella risposta di Drew :

coloredEcho "This text is green" 2

Se aggiungi -nl'eco, puoi usarlo come colorazione in lineaecho "Red `coloredEcho "fox" red` jumps over the lazy dog"
sobi3ch,

23

Utilizzare tputper calcolare i codici colore. Evita di usare il codice di escape ANSI (ad es. \E[31;1mPer il rosso) perché è meno portatile. 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"

18

A questa domanda è stata data una risposta ripetuta :-) ma perché no.

Il primo utilizzo tputè più portatile negli ambienti moderni rispetto all'iniezione manuale di codici ASCIIecho -E

Ecco una rapida funzione 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"
  }

Ora puoi usare:

 say @b@green[[Success]] 

ottenere:

Successo audace

Note sulla portabilità di tput

Il tput(1)codice sorgente per la prima volta è stato caricato nel settembre 1986

tput(1) è stato disponibile nella semantica X / Open curses negli anni '90 (lo standard 1997 ha la semantica menzionata sotto).

Quindi, è ( abbastanza ) onnipresente.


Questo è abbastanza bello! Non lo sapevo. Puoi dire qualcosa sulla disponibilità di tput? È disponibile sulla maggior parte dei server in cui non si dispone dei diritti di amministratore per installarlo? Hai un link a dove questa tecnica è stata prima "inventata"?
Redsandro,

3
tput è il modo conforme agli standard per farlo, in cui è completamente indipendente dalla conoscenza delle funzionalità del terminale. Se il terminale non supporta una determinata funzionalità, eseguirà il downgrade con grazia a tutto ciò che può fare senza spingere fuori codici di escape.
Ahmed Masud,

1
Ho smesso di usare questo metodo in quanto incasina la posizione del cursore in linee bash. Si avvolgerà casualmente prima della fine della linea e non tornerà indietro fino all'inizio della linea quando si usano i tasti freccia o home. Tornando ai goffi codici di escape manuali risolve questo problema.
Redsandro,

2
@Resandro - è perché lo stai usando $PS1senza \[...\]intorno alle parti senza spaziatura? Continua a utilizzare i marcatori Bash PS1 con le stringhe di tput.
Toby Speight,

Nota che questa funzione non funziona completamente su MacOsX a causa delle differenze nell'utilità
Jeff

14

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

inserisci qui la descrizione dell'immagine

Spero che questa immagine ti aiuti a scegliere il colore per il tuo bash: D


Va notato che ciò richiede bash v4.
Synox

14

Se si sta utilizzando zshobash

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'

Prova online


14

Possiamo usare colori reali RGB a 24 bit sia per il testo che per lo sfondo!

 ESC[38;2;⟨r⟩;⟨g⟩;⟨bm  /*Foreground color*/
 ESC[48;2;⟨r⟩;⟨g⟩;⟨bm  /*Background color*/

Esempio di testo rosso e tag di chiusura:

 echo -e "\e[38;2;255;0;0mHello world\e[0m"

Generatore:

24 bit: quando le schede grafiche "true color" con 16-24 bit di colore sono diventate comuni, Xterm, Konsole di KDE, così come tutti i terminali basati su libvte (incluso il terminale GNOME) supportano l'impostazione del colore di primo piano e sfondo a 24 bit https: / /en.wikipedia.org/wiki/ANSI_escape_code#24-bit

È sicuro da usare nei miei script?

Sì! I terminali a 8 e 16 bit visualizzeranno come fallback un colore sulla gamma della tavolozza disponibile, mantenendo il miglior contrasto, nessuna rottura!


Inoltre, nessuno ha notato l'utilità del video invertito codice 7 ANSI .

Rimane leggibile su qualsiasi schema di colori di terminali, sfondi bianchi o neri o altre palette fantasiose, 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:

inserisci qui la descrizione dell'immagine

Questo è lo script del 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


11

Questi codici funzionano sulla mia casella Ubuntu:

inserisci qui la descrizione dell'immagine

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 su tutti i colori:

echo -e "\x1B[0;93m a \x1B[0m b \x1B[0;92m c \x1B[0;93m d \x1B[0;94m"

Per loop:

for (( i = 0; i < 17; i++ )); 
do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; 
done

inserisci qui la descrizione dell'immagine


2
A proposito: questo non dipende molto dall'aver installato una versione specifica di Ubuntu, ma dall'uso di PuTTY!
Urzeit,

11

Ho trovato la fantastica risposta di Shakiba Moshiri mentre cercavo informazioni su quell'argomento ... poi ho avuto un'idea ... ed è finita in una funzione molto carina estremamente facile da usare 😁
Quindi devo condividerla 😉

https://github.com/ppo/bash-colors

Utilizzo: $(c <flags>) all'interno di un echo -eoprintf

 ┌───────┬─────────────────┬──────────┐   ┌───────┬─────────────────┬──────────┐
  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 
 └───────┴─────────────────┴──────────┘

Esempi:

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

10

Per leggibilità

Se si desidera migliorare la leggibilità del codice, è possibile echoprima la stringa, quindi aggiungere il colore in seguito utilizzando sed:

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

1
Mi piace molto questa risposta! Puoi per favore spiegare $ nel comando sed però?
Patrick

2
$ '<something>' è per bash, non sed. Indica a bash di elaborare \ e come sequenza di escape e di inserire un carattere "escape". Di solito vedi le forme più semplici come $ '\ t' o $ '\ n' per far passare una scheda o un carattere di nuova riga a un carattere comando.
dsz,

8

La mia risposta preferita finora è coloredEcho.

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

esempio xcol

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

6

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"

2
Non scappare il terminale hardcode. Utilizzare tput; ecco a cosa serve!
Toby Speight,

@TobySpeight Sebbene ciò possa essere vero per il supporto multipiattaforma (in teoria), se un poster trova che funziona nel proprio mondo, perché non sono d'accordo e dissuadere gli altri in un mondo simile dall'usare la tecnica? Caso in questione sto provando simili in Ubuntu 16.04 bash e funziona. Come unico utente su questa piattaforma trovo questa risposta accettabile. Userò anche tputper sce rcsebbene (salva cursore, ripristina cursore). Anche se questa risposta mi chiama "pigro", potrebbe essere riformulato come "pratico" o "dritto al punto".
WinEunuuchs2Unix

La mia soluzione era simile a questa, limitata esclusivamente agli shell incorporati, perché il fork di due processi esterni, subshells ecc. Per ogni messaggio in uno script aveva solo un ... odore sgradevole.
Amit Naidu,

6

per mostrare l'output del messaggio con colori diversi è possibile effettuare:

echo -e "\033[31;1mYour Message\033[0m"

-Nero 0; 30 Grigio scuro 1; 30

-Rosso 0; 31 Rosso chiaro 1; 31

-Verde 0; 32 Verde chiaro 1; 32

-Brown / Orange 0; 33 Yellow 1; 33

-Blu 0; 34 Azzurro 1; 34

-Purple 0; 35 Viola chiaro 1; 35

-Cyan 0; 36 Ciano chiaro 1; 36

-Light Grey 0; 37 White 1; 37


5

Dovresti assolutamente usare tput su sequenze di controllo ANSI non elaborate.

Poiché esiste un gran numero di linguaggi di controllo dei terminali diversi, di solito un sistema ha un livello di comunicazione intermedio. I codici reali vengono cercati in un database per il tipo di terminale attualmente rilevato e si forniscono richieste standardizzate a un'API o (dalla shell) a un comando.

Uno di questi comandi è tput. tputaccetta una serie 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 (si spera che il terminale capisca).

da http://wiki.bash-hackers.org/scripting/terminalcodes

Detto questo, ho scritto una piccola libreria di supporto chiamata bash-tint , che aggiunge un altro livello oltre a 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: inserisci qui la descrizione dell'immagine


5

Io invece di codificare codici di escape specifici per il tuo terminale attuale, dovresti usare tput.

Questo è il mio script demo preferito:

#!/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

256 colori emessi da tput


4

Sto usando questo per la stampa a colori

#!/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[*]}"; } #|
#--------------------------------------------------------------------+

Tutti i colori di base sono impostati come var e ci sono anche alcune utili funzioni: XY, line e que. Sorgi questo script in uno dei tuoi e usa tutti i colori e le funzioni.


3

E questo è quello che ho usato per vedere tutte le combinazioni e decidere quale è bello:

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

2

Ho scritto swag per ottenere proprio questo.

Puoi solo fare

pip install swag

Ora puoi installare tutti i comandi di escape come file txt su una determinata destinazione tramite:

swag install -d <colorsdir>

O ancora più facile tramite:

swag install

Che installerà i colori a ~/.colors.

O li usi in questo modo:

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 su asciinema !


0

Ecco una semplice piccola sceneggiatura, che ho messo insieme di recente, che colorerà qualsiasi input convogliato 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


La logica del loop di colore è stata trovata in questo discreto tutorial sui colori di Ascii: misc.flogisoft.com/bash/tip_colors_and_formatting

-1

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

Si noti che la funzione echo_green dovrebbe avere il codice 32 anziché 33. Non è possibile modificare stackoverflow b / c richiede almeno 6 caratteri di modifica.
Daniel

-2

Ecco la soluzione più semplice e leggibile. Con bashj ( https://sourceforge.net/projects/bashj/ ), sceglieresti semplicemente una di queste righe:

#!/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 i colori sono disponibili se si dispone del supporto colore nella propria applicazione terminale.


-3

dopo aver mescolato altre soluzioni dal thread, ecco come sono riuscito a ottenere i colori npm scriptsnell'output (CLI gitbash):

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

inserisci qui la descrizione dell'immagine


-4

Proprio come qualcosa un po 'là fuori, passandolo attraverso grep lo evidenzierà come rosso (ma solo rosso). Puoi anche usare le named pipe in modo che la tua stringa sia più vicina alla fine della linea:

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

ti manca il punto di poter selezionare il colore che preferisci. anche grep come utility di colorazione è davvero discutibile: P
Ahmed Masud,

Non proprio, OP ha menzionato specificamente che voleva il rosso. Sono d'accordo che ci sono opzioni migliori rispetto all'utilizzo di grep, ma ottiene ciò che hanno chiesto e risparmia dover imparare qualcosa di più complesso.
FinalDuty

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

Questa risposta è corretta, tranne per il fatto che la chiamata ai colori non deve essere racchiusa tra virgolette.

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

Dovrebbe fare il trucco.


3
Funziona bene tra virgolette. l'opzione -e valuta anche le virgolette. L'esecuzione di entrambe (virgolette interne ed esterne) usando bash -x genera lo stesso comando eseguito echo -e '\e[0;31mHello Stackoverflow\e[0m'. Quindi è lo stesso per bash.
naab,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.