Como alterar a cor de saída do eco no Linux


Respostas:


2297

Você pode usar estes códigos de 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 depois use-os assim em seu 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"

que imprime loveem vermelho.

No comentário de @ james-lim, se você estiver usando o echocomando, use o sinalizador -e para permitir escapes de barra invertida .

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

(não adicione "\n"ao usar eco, a menos que você queira adicionar uma linha vazia adicional)


11
Não funciona para mim - saída:\e[0;31mHello Stackoverflow\e[0m
Ben Harold

172
Você tentou com "-e"? Diz echopara ativar escapes de barra invertida.
James Lim

142
No MacOSX, use em \x1Bvez de \e. \033seria bom para todas as plataformas.
Xiao

4
Em um arquivo de propriedades ant, use unicode para o esacpe, por exemplo, red = \ u001b [0; 31m
shonky linux user

20
Como o msanford criado para o tput, aqui está o "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
everyman

971

Você pode usar o tputcomando awesome (sugerido na resposta de Ignacio ) para produzir códigos de controle de terminal para todos os tipos de coisas.


Uso

tputSubcomandos específicos são discutidos posteriormente.

Direto

Chame tputcomo parte de uma sequência de comandos:

tput setaf 1; echo "this is red text"

Use em ;vez de fazê- &&lo, se os tputerros ainda aparecerem no texto.

Variáveis ​​do shell

Outra opção é usar variáveis ​​de shell:

red=`tput setaf 1`
green=`tput setaf 2`
reset=`tput sgr0`
echo "${red}red text ${green}green text${reset}"

tputproduz seqüências de caracteres que são interpretadas pelo terminal como tendo um significado especial. Eles não serão mostrados eles mesmos. Observe que eles ainda podem ser salvos em arquivos ou processados ​​como entrada por outros programas que não o terminal.

Substituição de comando

Pode ser mais conveniente inserir tputa saída diretamente em suas echostrings usando a substituição de comando :

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

Exemplo

O comando acima produz isso no Ubuntu:

Captura de tela do texto do terminal colorido


Comandos em primeiro plano e em segundo plano

tput setab [1-7] # Set the background colour using ANSI escape
tput setaf [1-7] # Set the foreground colour using ANSI escape

As cores são as seguintes:

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

Há também versões não-ANSI das funções de ajuste de cores ( setbem vez de setab, e setfem vez de setaf) que usam números diferentes, não dadas aqui.

Comandos no modo de texto

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

Comandos de movimento do cursor

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

Limpar e inserir comandos

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

Outros comandos

tput sgr0    # Reset text format to the terminal's default
tput bel     # Play a bell

Com janelas trémulas Compiz , o belcomando faz com que a oscilação do terminal por um segundo para chamar a atenção do usuário.


Scripts

tputaceita scripts contendo um comando por linha, que são executados em ordem antes das tputsaídas.

Evite arquivos temporários repetindo uma sequência de várias linhas e transmitindo-a por canal:

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

Veja também

  • Vejo man 1 tput
  • Veja man 5 terminfoa lista completa de comandos e mais detalhes sobre essas opções. (O tputcomando correspondente está listado na Cap-namecoluna da tabela enorme que começa na linha 81.)

13
Ótima resposta. Este é o que mais me ajudou. Para qualquer um que estivesse se perguntando o que eu estava pensando, isso $()é uma substituição de comando . Tudo o tput af 1que é gerado é gerar a sequência de códigos de cores, mas os códigos não são caracteres imprimíveis, portanto, digitar tput af 1sozinho produzirá uma linha de saída em branco.
22414 Chris-Middleton

5
Nota: se você estiver usando o CygWin e não tiver o tput installncurses
Enrico

3
tput também funciona dentro sed para analisar cruft em legíveis cruft, colorido: gist.github.com/nickboldt/fab71da10bd5169ffdfa
nickboldt

1
Para obter uma lista completa das tputcores, consulte esta resposta no Unix StackExchange
Andrew #

Eu acho que reset=`tput sgr0`deveria ser reset=`tput sgr 0`, com um espaço.
monkeypants 24/09/19

835

algumas variáveis ​​que você pode usar:

# 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

o caractere de escape em bash , hex e octal, respectivamente:

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

pequeno exemplo:

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

exceção do bash:

Se você vai usar esses códigos em suas variáveis ​​especiais do bash

  • PS0
  • PS1
  • PS2 (= isso é para solicitação)
  • PS4

você deve adicionar caracteres de escape extras para que pode interpretá-los corretamente. Sem isso, adicionar caracteres de escape extras funciona, mas você terá problemas ao usar Ctrl + rpara pesquisar em seu histórico.

regra de exceção para bash

Você deve adicionar \[antes de qualquer código ANSI inicial e \]depois de qualquer código final.
Exemplo:
em uso regular: \033[32mThis is in green\033[0m
para PS0 / 1/2/4: \[\033[32m\]This is in green\[\033[m\]

\[é para o início de uma sequência de caracteres não imprimíveis
\] é para o final de uma sequência de caracteres não imprimíveis

Dica: para memorizá-lo, você pode primeiro adicionar \[\]e depois colocar seu código ANSI entre eles:
- \[start-ANSI-code\]
-\[end-ANSI-code\]

tipo de sequência de cores:

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

Antes de mergulhar nessas cores, você deve conhecer quatro modos com estes códigos:

1. modo de cor

Ele modifica o estilo da cor NÃO do texto. Por exemplo, torne a cor mais clara ou mais escura.

  • 0 Redefinir
  • 1; mais leve que o normal
  • 2; mais escuro que o normal

Este modo não é suportado amplamente. É totalmente compatível com o Gnome-Terminal.

2. modo de texto

Este modo é para modificar o estilo do texto NÃO da cor.

  • 3; itálico
  • 4; sublinhado
  • 5; piscando (lento)
  • 6; piscando (rápido)
  • 7; reverter
  • 8; ocultar
  • 9; descartar

e são quase suportados.
Por exemplo, o KDE-Konsole suporta, 5;mas o Gnome-Terminal não e o Gnome, 8;mas o KDE não.

3. modo de primeiro plano

Este modo é para colorir o primeiro plano.

4. modo de fundo

Este modo é para colorir o fundo.

A tabela abaixo mostra um resumo da versão de 3/4 bits da cor 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                                            |                                                                                       |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|

A tabela abaixo mostra um resumo da versão de 8 bits da cor 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     |
|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|

O teste rápido de 8 bits:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

A tabela abaixo mostra um resumo da versão de 24 bits da cor 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 |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|

algumas capturas de tela

resumo de 8 bits em primeiro plano em um .gif

foreground.gif

resumo de 8 bits em segundo plano em um .gif

background.gif

resumo de cores com seus valores

insira a descrição da imagem aqui insira a descrição da imagem aqui insira a descrição da imagem aqui insira a descrição da imagem aqui

blinking no terminal KDE

Piscando no KDE

um Ccódigo simples que mostra mais

cecho_screenshot

uma ferramenta mais avançada que desenvolvi para lidar com essas cores:

bline


foto no modo de cor

desaparecer-normal-brilhante

foto em modo texto

modo somente texto

combinar é bom

combinar

mais tiros


Dicas e truques para usuários e programadores avançados:

Podemos usar esses códigos em uma linguagem de programação?

Sim você pode. Eu experimentei em, , , ,

Eles estão diminuindo a velocidade de um programa?

Eu acho que não.

Podemos usá-los no Windows?

3/4-bit Sim, se você compilar o código com gcc
algumas capturas de tela no Win-7

Como calcular o comprimento do código?

\033[ = 2, outras partes 1

Onde podemos usar esses códigos?

Em qualquer lugar que tem um ttyintérprete
xterm, gnome-terminal, kde-terminal, mysql-client-CLIe assim por diante.
Por exemplo, se você quiser colorir sua saída com mysql, você pode usarPerl

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

armazene esse código em um nome de arquivo: pcc(= Perl Colorize Character) e, em seguida, coloque o arquivo a em válido PATHe use-o onde quiser.

ls | pcc
df | pcc

dentro mysqlprimeiro registre-o pagere tente:

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

pcc

Ele não lidar com Unicode.

Esses códigos apenas colorizam?

Não, eles podem fazer muitas coisas interessantes. Tentar:

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

Muitos iniciantes desejam limpar a tela system( "clear" )para que você possa usá-lo em vez de system(3)ligar

Eles estão disponíveis no Unicode?

Sim. \u001b

Qual versão dessas cores é preferível?

É fácil de usar 3/4-bit, mas é muito preciso e bonito de usar 24-bit.
Se você não tem experiência comentão aqui está um tutorial rápido:
24 bits significa: 00000000e 00000000e 00000000. Cada 8 bits é para uma cor específica.
1..8é para e 9..16para e 17..24para
Então, em #FF0000significa e aqui está: 255;0;0
em #00FF00significa que aqui está: 0;255;0
Isso faz sentido? que cor você deseja combiná-lo com esses três valores de 8 bits.


referência: seqüências de escape ANSI da
Wikipedia tldp.org tldp.org misc.flogisoft.com alguns blogs / páginas da web que não me lembro





70
Ninguém mais está realmente surpreso com esta resposta?
Benj

14
Esta é definitivamente a resposta do corredor da fama, obrigado.
ForeverZer0

2
@NeilGuyLindberg sem literais octais, este erro faz parte do Node.js. não é o próprio eslist. você pode usar x1B[para eliminá-lo.
Shakiba Moshiri

5
Eu rolei de volta para longe para votar esta resposta!
RNA

1
Parece que, @ ShakibaMoshiri escreveu uma tese sobre esse tópico xD Jokes à parte, aplausos por uma resposta tão detalhada!
SH '

189

Use tputcom a setafcapacidade e um parâmetro de 1.

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

8
Essa deve ser a melhor opção. o que o tput faz é ler as informações do terminal e renderizar o código ANSI com escape correto para você. código como \033[31mirá quebrar a biblioteca readline em alguns dos terminais.
Tian Chen

44
Explore cores com um loop simples ( ilimite superior do aumento para obter mais tons):for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done
msanford

2
Aqui está um HOWTO sobre os códigos de tput: tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
maxywb

tput: command not found(em alpino)
dgallant 30/01

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

O [31mcontrola a cor do texto:

  • 30- 37define a cor do primeiro plano
  • 40- 47define a cor de fundo

Uma lista mais completa de códigos de cores pode ser encontrada aqui .

É uma boa prática redefinir a cor do texto \033[0mno final da sequência.


2
echo -e "\ 033 [31m Olá, mundo", o [31m é a cor
neocanable

36

Acabei de juntar as boas capturas em todas as soluções e acabei com:

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 você pode simplesmente chamá-lo como:

cecho "RED" "Helloworld"

1
Muito prático, eu apenas tive que substituir aspas simples por aspas duplas para GREEN, YELLOW, NC para que funcionasse no meu script.
22819 ionescu77

1
Ótima solução !!
David Kariuki 30/04

31

Este é o interruptor de cores \033[ . Veja a história .

Os códigos de cores são como 1;32(verde claro), 0;34(azul), 1;34(azul claro) etc.

Encerramos as seqüências de cores com um comutador de cores \033[e 0mo código sem cores. Assim como abrir e fechar guias em uma linguagem de marcação.

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

echoSolução de função de cor simples :

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
Eu mudaria a última textvariável text="$color${@: 2}${code}0m"dessa maneira, toda a linha, exceto o parâmetro color, será colorida.
Shairon Toledo

@tomazahlin basta adicionar -e para echo, como várias vezes mencionado acima
Artem Medvedev

28

Uma maneira pura de mudar de cor apenas para um echoé definir essa função:

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

Ou você pode usar diretamente os códigos de cores mencionados na resposta de Drew :

coloredEcho "This text is green" 2

Se você adicionar -na ecoar, então você pode usá-lo como corante em linhaecho "Red `coloredEcho "fox" red` jumps over the lazy dog"
sobi3ch

23

Use tputpara calcular códigos de cores. Evite usar o código de escape ANSI (por exemplo, \E[31;1mpara vermelho) porque é menos portátil. O Bash no OS X, por exemplo, não é compatível.

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

Esta pergunta foi respondida repetidamente :-) mas por que não.

A primeira utilização tputé mais portátil em ambientes modernos do que a injeção manual de códigos ASCII através deecho -E

Aqui está uma função rápida do 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"
  }

Agora você pode usar:

 say @b@green[[Success]] 

para obter:

Sucesso em negrito e verde

Notas sobre portabilidade de tput

O primeiro tput(1)código-fonte foi carregado em setembro de 1986

tput(1) está disponível na semântica do X / Open curses na década de 1990 (o padrão de 1997 tem a semântica mencionada abaixo).

Então, é ( bastante ) onipresente.


Isso é bem legal! Não sabia disso. Você pode dizer algo sobre a disponibilidade de tput? Está disponível na maioria dos servidores em que não há direitos de administrador para instalá-lo? Você tem um link para onde essa técnica foi "inventada" pela primeira vez?
Redsandro 5/10

3
tput é a maneira compatível com os padrões para fazer isso, onde é completamente independente de você conhecer os recursos do terminal. Se o terminal não suportar uma determinada capacidade, ele será rebaixado normalmente para o que puder fazer, sem pressionar códigos de escape mal-humorados.
Ahmed Masud

1
Parei de usar esse método, pois mexe com a posição do cursor nas linhas do bash. Ele será quebrado aleatoriamente antes do final da linha e não voltará até o início da linha ao usar as teclas inicial ou de seta. Voltar aos desajeitados códigos de escape manuais corrige esse problema.
Redsandro 22/10

2
@ Resandro - é isso porque você está usando $PS1sem \[...\]as peças não espaçadoras ? Continue usando os marcadores Bash PS1 com as strings de tput.
precisa

Note-se que esta função não totalmente trabalho em MacOSX por causa de differencies no utilitário sed: unix.stackexchange.com/questions/13711/...
Jeff

14

Obrigado a @ k-five por esta resposta

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

Resultado

insira a descrição da imagem aqui

Espero que esta imagem ajude você a escolher sua cor para sua festança: D


Note-se que isso requer o bash v4.
Synox

14

Se você estiver usando zshoubash

black() {
    echo -e "\e[30m${1}\e[0m"
}

red() {
    echo -e "\e[31m${1}\e[0m"
}

green() {
    echo -e "\e[32m${1}\e[0m"
}

yellow() {
    echo -e "\e[33m${1}\e[0m"
}

blue() {
    echo -e "\e[34m${1}\e[0m"
}

magenta() {
    echo -e "\e[35m${1}\e[0m"
}

cyan() {
    echo -e "\e[36m${1}\e[0m"
}

gray() {
    echo -e "\e[90m${1}\e[0m"
}

black 'BLACK'
red 'RED'
green 'GREEN'
yellow 'YELLOW'
blue 'BLUE'
magenta 'MAGENTA'
cyan 'CYAN'
gray 'GRAY'

Experimente on-line


14

Podemos usar cores verdadeiras de 24 bits RGB para texto e plano de fundo!

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

Exemplo de texto em vermelho e tag de fechamento:

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

Gerador:

24 bits: À medida que as placas gráficas "true color" com 16 a 24 bits de cor se tornaram comuns, o Xterm, o Konsole do KDE, bem como todos os terminais baseados em libvte (incluindo o GNOME Terminal), suportam a configuração de cores de primeiro plano e de fundo de 24 bits https: / /en.wikipedia.org/wiki/ANSI_escape_code#24-bit

É seguro usar nos meus scripts?

Sim! Os terminais de 8 e 16 bits exibirão apenas como cor substituta na faixa da paleta disponível, mantendo o melhor contraste, sem quebras!


Além disso, ninguém notou a utilidade do vídeo reverso do código ANSI 7 .

Ele fica legível em qualquer esquema de terminal, cores, fundo preto ou branco ou outras paletas de fantasia, trocando as cores de primeiro e segundo plano.

Exemplo, para um fundo vermelho que funciona em qualquer lugar:

echo -e "\033[31;7mHello world\e[0m";

É assim que se parece ao alterar os esquemas internos do terminal:

insira a descrição da imagem aqui

Este é o script de loop usado para o gif.

for i in {30..49};do echo -e "\033[$i;7mReversed color code $i\e[0m Hello world!";done

Consulte https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters


11

Esses códigos funcionam na minha caixa do Ubuntu:

insira a descrição da imagem aqui

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"

Isso imprime as letras abcd todas em cores diferentes:

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

For loop:

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

insira a descrição da imagem aqui


2
A propósito: Isso não depende muito de ter instalado uma versão específica do ubuntu, mas usando o PuTTY!
urzeit

11

Eu encontrei a resposta incrível de Shakiba Moshiri enquanto procurava informações sobre esse tópico ... então eu tive uma idéia ... e acabou em uma função bastante agradável extremamente fácil de usar (
então eu tenho que compartilhar)

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

Uso: $(c <flags>) dentro de um echo -eouprintf

 ┌───────┬─────────────────┬──────────┐   ┌───────┬─────────────────┬──────────┐
  Code   Style            Octal        Code   Style            Octal    
 ├───────┼─────────────────┼──────────┤   ├───────┼─────────────────┼──────────┤
    -    Foreground       \033[3..       B    Bold             \033[1m  
    _    Background       \033[4..       U    Underline        \033[4m  
 ├───────┼─────────────────┼──────────┤      F    Flash/blink      \033[5m  
    k    Black            ......0m       N    Negative         \033[7m  
    r    Red              ......1m    ├───────┼─────────────────┼──────────┤
    g    Green            ......2m       L    Normal (unbold)  \033[22m 
    y    Yellow           ......3m       0    Reset            \033[0m  
    b    Blue             ......4m    └───────┴─────────────────┴──────────┘
    m    Magenta          ......5m 
    c    Cyan             ......6m 
    w    White            ......7m 
 └───────┴─────────────────┴──────────┘

Exemplos:

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

Para legibilidade

Se você deseja melhorar a legibilidade do código, você pode echoprimeiro a string e depois adicionar a cor mais tarde usando sed:

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

1
Eu realmente gosto desta resposta! Você pode explicar o comando $ no comando sed?
Patrick

2
O $ '<algo>' é para bash, não sed. Ele diz ao bash para processar o \ e como uma sequência de escape e inserir um caractere "escape". Geralmente, você vê as formas mais simples como $ '\ t' ou $ '\ n' para obter um caractere de tabulação ou nova linha passado para um comando.
DSZ

8

Minha resposta favorita até agora é colouredEcho.

Apenas para postar outra opção, você pode conferir esta pequena ferramenta xcol

https://ownyourbits.com/2017/01/23/colorize-your-stdout-with-xcol/

você o usa como grep, e ele colorirá seu stdin com uma cor diferente para cada argumento, por exemplo

sudo netstat -putan | xcol httpd sshd dnsmasq pulseaudio conky tor Telegram firefox "[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+" ":[[:digit:]]+" "tcp." "udp." LISTEN ESTABLISHED TIME_WAIT

exemplo xcol

Observe que ele aceita qualquer expressão regular que o sed aceitará.

Esta ferramenta usa as seguintes definições

#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

Eu uso essas variáveis ​​nos meus scripts assim

echo "${red}hello ${yellow}this is ${green}coloured${normal}"

6

Para expandir esta resposta , para os preguiçosos de nós:

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
Não codifique o escape do terminal. Use tput; é para isso que serve!
Toby Speight

@TobySpeight Embora isso possa ser verdade no suporte a várias plataformas (em teoria), se o pôster acha que funciona em seu próprio mundo, por que discordar e dissuadir outras pessoas em um mundo semelhante de usar a técnica? Caso em questão, estou tentando semelhante no Ubuntu 16.04 bash e funciona. Como o único usuário nesta plataforma, acho esta resposta aceitável. Também usarei tputpara sce rcembora (salvar cursor, restaurar cursor). Embora essa resposta me chame de "preguiçoso", poderia ser reformulado como "prático" ou "direto ao ponto".
WinEunuuchs2Unix 2/11/19

Minha própria solução foi semelhante a esta, confinada apenas aos shell embutidos, porque bifurcar dois processos externos, subcascas etc. para cada mensagem em um script tinha apenas um cheiro ... desagradável.
Amit Naidu

6

para mostrar a saída da mensagem com cores diferentes, você pode fazer:

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

-Preto 0; 30 Cinza escuro 1; 30

-Vermelho 0; 31 Vermelho claro 1; 31

-Verde 0; 32 Verde claro 1; 32

-Marron / Laranja 0; 33 Amarelo 1; 33

-Azul 0; 34 Azul claro 1; 34

-Roxo 0; 35 Roxo claro 1; 35

-Ciano 0; 36 Ciano claro 1; 36

- Cinza claro 0; 37 Branco 1; 37


5

Você definitivamente deve usar tput sobre sequências de controle ANSI brutas.

Como existe um grande número de diferentes linguagens de controle de terminal, geralmente um sistema possui uma camada de comunicação intermediária. Os códigos reais são pesquisados ​​em um banco de dados para o tipo de terminal detectado no momento e você fornece solicitações padronizadas para uma API ou (do shell) para um comando.

Um desses comandos é tput. tputaceita um conjunto de acrônimos chamados nomes de capacidade e quaisquer parâmetros, se apropriado, procura as seqüências de escape corretas para o terminal detectado no banco de dados terminfo e imprime os códigos corretos (esperamos que o terminal entenda).

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

Dito isso, escrevi uma pequena biblioteca auxiliar chamada bash-tint , que adiciona outra camada à parte superior da tput, tornando ainda mais simples o uso (imho):

Exemplo: tint "white(Cyan(T)Magenta(I)Yellow(N)Black(T)) is bold(really) easy to use."

Daria o seguinte resultado: insira a descrição da imagem aqui


5

Em vez de codificar códigos de escape específicos do seu terminal atual, você deve usar tput.

Este é o meu script de demonstração favorito:

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

Saída de 256 cores por tput


4

Estou usando isso para impressão em cores

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

Todas as cores básicas são definidas como vars e também existem algumas funções úteis: XY, linha e que. Crie esse script em um dos seus e use todos os recursos e funções de cores.


3

E é isso que eu costumava ver todas as combinações e decidir qual fica legal:

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

Eu escrevi ganhos para conseguir exatamente isso.

Você pode apenas fazer

pip install swag

Agora você pode instalar todos os comandos de escape como arquivos txt em um determinado destino via:

swag install -d <colorsdir>

Ou ainda mais fácil via:

swag install

Qual instalará as cores para ~/.colors.

Ou você os usa assim:

echo $(cat ~/.colors/blue.txt) This will be blue

Ou assim, o que acho realmente mais interessante:

swag print -c red -t underline "I will turn red and be underlined"

Confira no asciinema !


0

Aqui está um pequeno script simples, reuni recentemente, que colorirá qualquer entrada canalizada em vez de usar "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 

Em seguida, chame-o de cor vermelha (196):
$> echo "text you want colored red" | color.bsh 196


Lógica laço cor foi encontrada nesta cores Ascii decentes Tutorial: misc.flogisoft.com/bash/tip_colors_and_formatting

-1

Referir-se:

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

Observe que a função echo_green deve ter o código 32 em vez de 33. Não é possível editar o b / c stackoverflow requer pelo menos 6 caracteres de edição.
Daniel

-2

Aqui está a solução mais simples e legível. Com bashj ( https://sourceforge.net/projects/bashj/ ), você simplesmente escolheria uma destas linhas:

#!/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 cores estão disponíveis se você tiver o suporte de cores em seu aplicativo de terminal.


-3

depois de misturar outras soluções do thread, npm scriptsveja como eu consegui obter cores na saída (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"
}

insira a descrição da imagem aqui


-4

Assim como algo um pouco lá fora, passar pelo grep o destacará como vermelho (mas apenas vermelho). Você também pode usar pipes nomeados para que sua string fique mais próxima do final da linha:

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

você está perdendo o ponto de poder selecionar a cor de sua escolha. Também grep como um utilitário coloração é realmente questionável: P
Ahmed Masud

Na verdade, a OP mencionou especificamente que queria vermelho. Concordo que existem opções melhores do que usar grep, mas ele consegue o que eles pediram e poupa a necessidade de aprender algo mais complexo.
FinalDuty 1/11

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

Esta resposta está correta, exceto que a chamada para cores não deve estar dentro das aspas.

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

Deve fazer o truque.


3
Funciona bem dentro das aspas. a opção -e também avalia o que está entre aspas. A execução de aspas (dentro e fora) usando bash -x gera o mesmo comando executado echo -e '\e[0;31mHello Stackoverflow\e[0m'. Portanto, é o mesmo para o bash.
naab
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.