Estou tentando imprimir um texto no terminal usando o comando echo.
Quero imprimir o texto em vermelho. Como eu posso fazer isso?
Estou tentando imprimir um texto no terminal usando o comando echo.
Quero imprimir o texto em vermelho. Como eu posso fazer isso?
Respostas:
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 love
em vermelho.
No comentário de @ james-lim, se você estiver usando o echo
comando, 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)
\e[0;31mHello Stackoverflow\e[0m
echo
para ativar escapes de barra invertida.
\x1B
vez de \e
. \033
seria bom para todas as plataformas.
for (( i = 30; i < 38; i++ )); do echo -e "\033[0;"$i"m Normal: (0;$i); \033[1;"$i"m Light: (1;$i)"; done
Você pode usar o tput
comando awesome (sugerido na resposta de Ignacio ) para produzir códigos de controle de terminal para todos os tipos de coisas.
tput
Subcomandos específicos são discutidos posteriormente.
Chame tput
como parte de uma sequência de comandos:
tput setaf 1; echo "this is red text"
Use em ;
vez de fazê- &&
lo, se os tput
erros ainda aparecerem no texto.
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}"
tput
produz 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.
Pode ser mais conveniente inserir tput
a saída diretamente em suas echo
strings usando a substituição de comando :
echo "$(tput setaf 1)Red text $(tput setab 7)and white background$(tput sgr 0)"
O comando acima produz isso no Ubuntu:
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 ( setb
em vez de setab
, e setf
em vez de setaf
) que usam números diferentes, não dadas aqui.
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
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
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
tput sgr0 # Reset text format to the terminal's default
tput bel # Play a bell
Com janelas trémulas Compiz , o bel
comando faz com que a oscilação do terminal por um segundo para chamar a atenção do usuário.
tput
aceita scripts contendo um comando por linha, que são executados em ordem antes das tput
saí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
man 1 tput
man 5 terminfo
a lista completa de comandos e mais detalhes sobre essas opções. (O tput
comando correspondente está listado na Cap-name
coluna da tabela enorme que começa na linha 81.)$()
é uma substituição de comando . Tudo o tput af 1
que é 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 1
sozinho produzirá uma linha de saída em branco.
ncurses
tput
cores, consulte esta resposta no Unix StackExchange
reset=`tput sgr0`
deveria ser reset=`tput sgr 0`
, com um espaço.
# 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
| | 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 |
| | | | | |
| 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 |
| | | | | |
Se você vai usar esses códigos em suas variáveis especiais do bash
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 + r
para pesquisar em seu histórico.
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\]
Antes de mergulhar nessas cores, você deve conhecer quatro modos com estes códigos:
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.
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.
Este modo é para colorir o primeiro plano.
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 |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
resumo de 8 bits em primeiro plano em um .gif
resumo de 8 bits em segundo plano em um .gif
blinking
no terminal KDE
um C
código simples que mostra mais
uma ferramenta mais avançada que desenvolvi para lidar com essas cores:
Sim você pode. Eu experimentei embater, c, c ++, d perl, Pitão
Eu acho que não.
3/4-bit Sim, se você compilar o código com gcc
algumas capturas de tela no Win-7
\033[
= 2, outras partes 1
Em qualquer lugar que tem um tty
intérprete
xterm
, gnome-terminal
, kde-terminal
, mysql-client-CLI
e 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 PATH
e use-o onde quiser.
ls | pcc
df | pcc
dentro mysql
primeiro registre-o pager
e tente:
[user2:db2] pager pcc
PAGER set to 'pcc'
[user2:db2] select * from table-name;
Ele não lidar com Unicode.
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
Sim. \u001b
É 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: 00000000
e 00000000
e 00000000
. Cada 8 bits é para uma cor específica.
1..8
é para e 9..16
para e 17..24
para
Então, emhtml #FF0000
significa e aqui está: 255;0;0
emhtml #00FF00
significa 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
x1B[
para eliminá-lo.
Use tput
com a setaf
capacidade e um parâmetro de 1
.
echo "$(tput setaf 1)Hello, world$(tput sgr0)"
\033[31m
irá quebrar a biblioteca readline em alguns dos terminais.
i
limite superior do aumento para obter mais tons):for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done
tput: command not found
(em alpino)
echo -e "\033[31m Hello World"
O [31m
controla a cor do texto:
30
- 37
define a cor do primeiro plano40
- 47
define a cor de fundoUma lista mais completa de códigos de cores pode ser encontrada aqui .
É uma boa prática redefinir a cor do texto \033[0m
no 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 0m
o 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}"
echo
Soluçã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!"
text
variável text="$color${@: 2}${code}0m"
dessa maneira, toda a linha, exceto o parâmetro color, será colorida.
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
-n
a ecoar, então você pode usá-lo como corante em linhaecho "Red `coloredEcho "fox" red` jumps over the lazy dog"
Use tput
para calcular códigos de cores. Evite usar o código de escape ANSI (por exemplo, \E[31;1m
para 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:
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.
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?
$PS1
sem \[...\]
as peças não espaçadoras ? Continue usando os marcadores Bash PS1 com as strings de tput.
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
Espero que esta imagem ajude você a escolher sua cor para sua festança: D
Se você estiver usando zsh
oubash
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'
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:
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 -e
ouprintf
┌───────┬─────────────────┬──────────┐ ┌───────┬─────────────────┬──────────┐
│ 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."
Se você deseja melhorar a legibilidade do código, você pode echo
primeiro 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"
tput
; é para isso que serve!
tput
para sc
e rc
embora (salvar cursor, restaurar cursor). Embora essa resposta me chame de "preguiçoso", poderia ser reformulado como "prático" ou "direto ao ponto".
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
.tput
aceita 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."
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.
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 scripts
veja 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.
echo -e '\e[0;31mHello Stackoverflow\e[0m'
. Portanto, é o mesmo para o bash.