Estou tentando imprimir um texto no terminal usando o comando echo.

Quero imprimir o texto em vermelho. Como eu posso fazer isso?

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)

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:

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

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

resumo de 8 bits em segundo plano em um .gif

resumo de cores com seus valores

blinking no terminal KDE

um Ccódigo simples que mostra mais

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

foto no modo de cor

foto em modo texto

combinar é bom

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 embater, c, c ++, d perl, Pitão

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;

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 comhtmlentã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, emhtml #FF0000significa e aqui está: 255;0;0
emhtml #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

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

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

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.

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"

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

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

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"

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:

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.

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

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

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

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

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

Exemplo de texto em vermelho e tag de fechamento:

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

Gerador:

text.addEventListener("input",update)
back.addEventListener("input",update)

function update(){
  let a = text.value.substr(1).match(/.{1,2}/g)
  let b = back.value.substr(1).match(/.{1,2}/g)
  out1.textContent = "echo -e \"\\" + `033[38;2;${parseInt(a[0],16)};${parseInt(a[1],16)};${parseInt(a[2],16)}mHello\"`
  out2.textContent = "echo -e \"\\" + `033[48;2;${parseInt(b[0],16)};${parseInt(b[1],16)};${parseInt(b[2],16)}mWorld!\"`
}

div {padding:1rem;font-size:larger}

TEXT COLOR: <input type="color" id="text" value="#23233">
<br><div id="out1"></div>
BACK COLOR: <input type="color" id="back" value="#FFFF00">
<br><div id="out2">

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:

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

Esses códigos funcionam na minha caixa do Ubuntu:

echo -e "\x1B[31m foobar \x1B[0m"
echo -e "\x1B[32m foobar \x1B[0m"
echo -e "\x1B[96m foobar \x1B[0m"
echo -e "\x1B[01;96m foobar \x1B[0m"
echo -e "\x1B[01;95m foobar \x1B[0m"
echo -e "\x1B[01;94m foobar \x1B[0m"
echo -e "\x1B[01;93m foobar \x1B[0m"
echo -e "\x1B[01;91m foobar \x1B[0m"
echo -e "\x1B[01;90m foobar \x1B[0m"
echo -e "\x1B[01;89m foobar \x1B[0m"
echo -e "\x1B[01;36m foobar \x1B[0m"

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

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

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

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

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

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"

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

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:

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

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.

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

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 !

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

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

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.

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

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

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.