personalizar - ps1 linux




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

Por legibilidade

Se você deseja melhorar a legibilidade do código, é possível echo o echo da string primeiro e depois adicionar a cor usando sed :

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

Eu estou tentando imprimir um texto no terminal usando o comando echo.

Eu quero imprimir o texto em uma cor vermelha. Como eu posso fazer isso?


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

exemplo curto:

| 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 de bash:

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

  • PS0
  • PS1
  • PS2 (isto é para pedir)
  • PS4

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

regra de exceção para bash

Você deve adicionar \[ antes de qualquer código ANSI inicial e adicionar \] depois de qualquer 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 iniciar uma sequência de caracteres não imprimíveis
\] é para o fim de uma sequência de caracteres não imprimíveis

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

tipo de sequência de cores:

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

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

1. modo de cor

Ele modifica o estilo da cor NÃO 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 cor.

  • 3; itálico
  • 4; sublinhado
  • 5; piscando (lento)
  • 6; piscando (rápido)
  • 7; marcha ré
  • 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 suporta 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[32m |         |       | yellow           | echo -e "\033[33m####\033[m" |                                      |
|         34 | \033[32m |         |       | blue             | echo -e "\033[34m####\033[m" |                                      |
|         35 | \033[32m |         |       | purple           | echo -e "\033[35m####\033[m" | real name: magenta = reddish-purple  |
|         36 | \033[32m |         |       | cyan             | echo -e "\033[36m####\033[m" |                                      |
|         37 | \033[32m |         |       | white            | echo -e "\033[37m####\033[m" |                                      |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|         38 | 8/24     |                    This is for special use of 8-bit or 24-bit                                            |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
| background | ~        |         |       | ~                | ~                            | ~                                    |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|         40 | \033[40m |         |       | black            | echo -e "\033[40m####\033[m" |                                      |
|         41 | \033[41m |         |       | red              | echo -e "\033[41m####\033[m" |                                      |
|         42 | \033[42m |         |       | green            | echo -e "\033[42m####\033[m" |                                      |
|         43 | \033[43m |         |       | yellow           | echo -e "\033[43m####\033[m" |                                      |
|         44 | \033[44m |         |       | blue             | echo -e "\033[44m####\033[m" |                                      |
|         45 | \033[45m |         |       | purple           | echo -e "\033[45m####\033[m" | real name: magenta = reddish-purple  |
|         46 | \033[46m |         |       | cyan             | echo -e "\033[46m####\033[m" |                                      |
|         47 | \033[47m |         |       | white            | echo -e "\033[47m####\033[m" |                                      |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
|         48 | 8/24     |                    This is for special use of 8-bit or 24-bit                                            |                                                                                       |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|

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

primeiro plano de resumo de 8 bits em um .gif

resumo de 8 bits em um .gif

resumo de cores com seus valores

blinking no KDE-Terminal

um código C simples que mostra mais

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

tiro em modo de cor

tiro de modo de texto

combinando é OK

mais tiros


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

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

Sim você pode. Eu experimentei em bash , c , c + + , d perl , python

Eles diminuem 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 o 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?

Qualquer lugar que tenha um intérprete tty
xterm , gnome-terminal , kde-terminal , mysql-client-CLI e assim por diante.
Por exemplo, se você quiser colorir sua saída com o mysql, você pode usar o Perl

#!/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 este código em um nome de arquivo: pcc (= Perl Colorize Character) e, em seguida, coloque o arquivo em um PATH válido e use-o em qualquer lugar que desejar.

ls | pcc
df | pcc

dentro do mysql primeiro registre-o para pager e tente:

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

NÃO manipula Unicode.

Esses códigos só fazem colorização?

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

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

Há um monte de iniciantes que querem limpar a tela com o system( "clear" ) para que você possa usar isso em vez da chamada do system(3)

Eles estão disponíveis em Unicode?

Sim. \u001b

Qual versão dessas cores é preferível?

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


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

Distintivos:


Esta pergunta foi respondida repetidas vezes :-) mas porque não.

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

Aqui está uma rápida função bash:

 say() {
     echo "[email protected]" | sed \
             -e "s/\(\(@\(red\|green\|yellow\|blue\|magenta\|cyan\|white\|reset\|b\|u\)\)\+\)[[]\{2\}\(.*\)[]]\{2\}/\1\[email protected]/g" \
             -e "s/@red/$(tput setaf 1)/g" \
             -e "s/@green/$(tput setaf 2)/g" \
             -e "s/@yellow/$(tput setaf 3)/g" \
             -e "s/@blue/$(tput setaf 4)/g" \
             -e "s/@magenta/$(tput setaf 5)/g" \
             -e "s/@cyan/$(tput setaf 6)/g" \
             -e "s/@white/$(tput setaf 7)/g" \
             -e "s/@reset/$(tput sgr0)/g" \
             -e "s/@b/$(tput bold)/g" \
             -e "s/@u/$(tput sgr 0 1)/g"
  }

Agora você pode usar:

 say @[email protected][[Success]] 

para obter:

Notas sobre portabilidade de tput

A primeira vez em que o código-fonte de tput(1) foi carregado em setembro de 1986

tput(1) está disponível na semântica de curses X / Open em 1990s (1997 standard tem a semântica mencionada abaixo).

Então, é ( bastante ) onipresente.


Este é o interruptor de cor \033[ . Veja o history .

Os codes cores são como 1;32 (verde claro), 0;34 (azul), 1;34 (azul claro), etc.

Terminamos sequências de cores com um interruptor de cor \033[ e 0m , o código sem cor. Apenas 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}"

Solução de função de echo 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!"

Graças a @ k-cinco 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 image ajude você a escolher sua cor para o seu bash: D


Minha resposta favorita até agora é coloredEcho.

Só para postar outra opção, você pode conferir essa pequena ferramenta xcol

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

você usa apenas como grep, e ele irá 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

Note que ele aceita qualquer expressão regular que 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 ​​em meus scripts, assim

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

Para expandir esta resposta , para o preguiçoso 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"

Uma maneira simples de alterar a 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 códigos de cores mencionados na resposta de Drew :

coloredEcho "This text is green" 2

Use tput para calcular os códigos de cores. Evite usar o código de escape ANSI (por exemplo, \E[31;1m para vermelho) porque é menos portátil. Bash no OS X, por exemplo, não suporta isso.

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"

Você pode usar esses 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 então 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} \n"

que imprime love em vermelho.

Do comentário de @ james-lim, se você estiver usando o comando echo , certifique-se de usar o sinalizador -e para permitir escapes de barra invertida.

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

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


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

c_echo(){
    RED="\033[0;31m"
    GREEN='\033[0;32m'
    YELLOW='\033[1;33m'
    NC='\033[0m' # No Color

    printf "${!1}${2} ${NC}\n"
}

E você pode apenas chamá-lo como:

c_echo "RED" "Helloworld"

Aqui está um pequeno script simples, que eu coloquei recentemente, que irá colorir qualquer entrada canalizada em vez de usar "WC".

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 com cor vermelha (196):
$> echo "text you want colored red" | color.bsh 196


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

Como há 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 procurados em um banco de dados para o tipo de terminal detectado atualmente 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 de nomes de capacidade e quaisquer parâmetros, se apropriado, então procura as seqüências de escape corretas para o terminal detectado no banco de dados terminfo e imprime os códigos corretos (o terminal compreende, com sorte).

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

Dito isso, eu escrevi uma pequena biblioteca de ajuda chamada bash-tint , que adiciona outra camada ao topo do tput, tornando ainda mais simples de usar (imho):

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

Daria o seguinte resultado:


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 no seu aplicativo de terminal.


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

O [31m controla a cor do texto:

  • 30 - 37 conjuntos de cor de primeiro plano
  • 40 - 47 conjuntos de cor de fundo

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

É recomendável redefinir a cor do texto de volta para \033[0m no final da string.


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

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

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

Deve fazer o truque.





terminal-color