Usando Sequências de Escape ANSI

Sequências de escape ANSI são códigos que controlam a formatação do texto nos terminais. Essas sequências começam com o caractere de escape (\033 ou \e) seguido por colchetes e números para as cores.

Sintaxe básica para mudar a cor do texto:

\033[CORm

Substitua COR por um número de 30 a 37 para cores de texto: 30 (preto), 31 (vermelho), 32 (verde), 33 (amarelo), 34 (azul), 35 (magenta), 36 (ciano), 37 (branco)

Usando o Comando echo com Códigos de Cor

O comando echo com a opção -e permite usar sequências de escape na saída.

Exemplo:

echo -e "\033[31mEste texto é vermelho\033[0m"

Aqui, \033[31m define a cor do texto como vermelho, e \033[0m redefine para o padrão.

Mais exemplos:

echo -e "\033[32mTexto verde\033[0m"
echo -e "\033[34mTexto azul\033[0m"
echo -e "\033[33mTexto amarelo\033[0m"

Usando tput para Manipulação de Cores

O comando tput oferece uma maneira de mudar as cores do texto em scripts.

Sintaxe básica para definir a cor do texto:

tput setaf NÚMERO_DA_COR

NÚMERO_DA_COR varia de 0 a 7: 0 (preto), 1 (vermelho), 2 (verde), 3 (amarelo), 4 (azul), 5 (magenta), 6 (ciano), 7 (branco)

Exemplo:

tput setaf 1; echo "Texto vermelho"; tput sgr0

Aqui, tput sgr0 redefine a formatação do texto.

Para definir a cor de fundo, use setab em vez de setaf:

tput setab 3; echo "Texto com fundo amarelo"; tput sgr0

Esses métodos oferecem maneiras de adicionar cor à saída do Bash, melhorando a legibilidade da interface do terminal.

Para mais informações sobre códigos de escape ANSI, consulte o artigo ANSI escape code.

Para saber mais sobre o comando tput, confira a página do manual Linux para tput.

Criando Variáveis de Cor para Uso Consistente

Defina variáveis de cor em scripts para manter seu código legível. Veja como criar variáveis de cor:

VERMELHO='\033[0;31m'
VERDE='\033[0;32m'
AZUL='\033[0;34m'
SC='\033[0m' # Sem Cor

Use essas variáveis em seus scripts:

echo -e "${VERMELHO}Este é um texto vermelho${SC}"
echo -e "${VERDE}Este é um texto verde${SC}"

Benefícios de usar variáveis para gerenciamento de cores:

• Fácil de mudar cores no script
• Melhora a legibilidade do código
• Reduz erros ao digitar códigos de cor frequentemente

Combinando Cores e Estilos de Texto

Adicione negrito, sublinhado e outros atributos de texto para criar uma saída chamativa:

Texto em negrito:

echo -e "\033[1mEste é um texto em negrito\033[0m"

Texto sublinhado:

echo -e "\033[4mEste é um texto sublinhado\033[0m"

Combinando cores e estilos:

echo -e "\033[1;31mEste é um texto vermelho em negrito\033[0m"

Você pode criar variáveis para essas combinações:

VERMELHO_NEGRITO='\033[1;31m'
AZUL_SUBLINHADO='\033[4;34m'

echo -e "${VERMELHO_NEGRITO}Texto vermelho em negrito${SC}"
echo -e "${AZUL_SUBLINHADO}Texto azul sublinhado${SC}"

Essas técnicas permitem criar scripts Bash visualmente atraentes e informativos.

Para mais informações sobre scripts Bash, consulte o Manual do GNU Bash.

Compatibilidade Entre Diferentes Terminais

Ao usar cores em scripts Bash, considere a compatibilidade entre diferentes terminais e sistemas operacionais:

• Use códigos de escape ANSI ou comandos tput, que funcionam na maioria das distribuições Linux e macOS.
• Evite códigos de cor específicos de certos terminais.
• Teste seus scripts em diferentes sistemas para verificar a exibição das cores.
• Use uma biblioteca de cores que lida com problemas de compatibilidade para você.

Aqui está um exemplo de configuração de cor compatível:

if [ -t 1 ]; then
    VERMELHO=$(tput setaf 1)
    VERDE=$(tput setaf 2)
    RESET=$(tput sgr0)
else
    VERMELHO=""
    VERDE=""
    RESET=""
fi

echo "${VERMELHO}Isso deve ser vermelho na maioria dos terminais${RESET}"

Redefinindo Cores para Manter a Legibilidade

Após usar saída colorida, é importante redefinir as cores para seus valores padrão:

• Redefina as cores após cada saída colorida para evitar afetar o texto posterior.
• Use o comando de redefinição no final das seções coloridas.
• Use um trap para redefinir as cores se o script sair inesperadamente.

Aqui estão alguns métodos para redefinir a cor do texto e atributos:

1. Usando código de escape ANSI:

   echo -e "\033[0mIsso redefine todos os atributos"

2. Usando tput:

   echo "$(tput sgr0)Isso também redefine todos os atributos"

3. Usando uma variável (recomendado para consistência):

   RESET='\033[0m'
   echo -e "${VERMELHO}Texto vermelho${RESET} Texto normal"

Seguindo essas práticas, você pode criar scripts com saída colorida que funcionam em diferentes sistemas e mantêm a legibilidade durante toda a execução.

Usando 'printf' para Saída Colorida Formatada

O comando printf oferece mais controle sobre a formatação da saída do que o echo. É útil para formatação de cores em scripts Bash.

Vantagens do printf sobre o echo:

• Melhor controle sobre a formatação da saída
• Comportamento consistente entre versões do Bash
• Permite especificação de largura de campo e alinhamento

Exemplos de formatação de cores com printf:

VERMELHO='\033[0;31m'
VERDE='\033[0;32m'
SC='\033[0m'

printf "${VERMELHO}%-20s${SC} ${VERDE}%s${SC}\n" "Erro:" "Arquivo não encontrado"
printf "${VERMELHO}%-20s${SC} ${VERDE}%s${SC}\n" "Aviso:" "Pouco espaço em disco"

Este código cria uma saída alinhada e colorida para mensagens de erro e aviso.

Bibliotecas de Cores de Terceiros

Algumas bibliotecas de cores de terceiros estão disponíveis para Bash, oferecendo funções de cores pré-definidas e sintaxe mais simples.

Bibliotecas de cores disponíveis:

• Bash-it: Uma coleção de comandos e scripts Bash da comunidade
• bashcopy: Uma pequena biblioteca para saída colorida em scripts Bash
• ansi: Uma biblioteca para códigos de escape ANSI em scripts shell

Vantagens de usar bibliotecas externas:

• Funções de cores pré-definidas para implementação rápida
• Geralmente incluem opções de formatação extras
• Podem lidar com problemas de compatibilidade de terminal

Desvantagens de usar bibliotecas externas:

• Dependência extra para seus scripts
• Pode ser excessivo para necessidades simples de cor
• Possíveis problemas de compatibilidade com diferentes versões do Bash

Exemplo usando a biblioteca 'colors.sh':

source colors.sh

echo "$(red "Este é um texto vermelho")"
echo "$(green "Este é um texto verde")"

Embora essas bibliotecas possam simplificar o uso de cores, considere suas necessidades e a complexidade do script ao decidir se deve usá-las.

Para mais informações sobre printf, consulte o Manual do GNU Bash.

Para explorar bibliotecas de cores Bash, confira Bash-it no GitHub.

Corrigindo Códigos de Cor Não Interpretados

Os códigos de cor podem não funcionar em scripts Bash por estas razões:

• O terminal não suporta códigos de cor
• A opção -e está faltando ao usar echo
• Sintaxe incorreta nos códigos de cor
• O suporte a cores está desativado no terminal

Formas de corrigir problemas com sequências de cor:

1. Verifique o suporte a cores do terminal:

   if [ -t 1 ]; then
   echo "O terminal suporta cores"
   else
   echo "O terminal não suporta cores"
   fi

2. Use echo com a opção -e:

   echo -e "\033[31mTexto vermelho\033[0m"

3. Verifique a sintaxe do código de cor:

   
   # Sintaxe correta
   echo -e "\033[31mTexto vermelho\033[0m"

Sintaxe errada

echo -e "\033[31Texto vermelho\033[0m"

4. Use tput para melhor compatibilidade:
```bash
vermelho=$(tput setaf 1)
reset=$(tput sgr0)
echo "${vermelho}Texto vermelho${reset}"

Corrigindo Diferenças de Cores Entre Terminais

Os terminais podem exibir cores de forma diferente. Para corrigir essas diferenças:

1. Use códigos de cor ANSI padrão (30-37 para primeiro plano, 40-47 para fundo)

2. Teste seus scripts em diferentes terminais

3. Use bibliotecas de cores que resolvem problemas de compatibilidade

4. Adicione uma opção para desativar cores em seus scripts:

usar_cor=true

if [ "$usar_cor" = true ]; then
    VERMELHO='\033[0;31m'
    VERDE='\033[0;32m'
    SC='\033[0m'
else
    VERMELHO=''
    VERDE=''
    SC=''
fi

echo -e "${VERMELHO}Isso pode ser vermelho${SC}"
echo -e "${VERDE}Isso pode ser verde${SC}"

5. Use tput para uma saída mais consistente:

if [ -t 1 ]; then
    VERMELHO=$(tput setaf 1)
    VERDE=$(tput setaf 2)
    RESET=$(tput sgr0)
else
    VERMELHO=""
    VERDE=""
    RESET=""
fi

echo "${VERMELHO}Isso deve ser consistentemente vermelho${RESET}"
echo "${VERDE}Isso deve ser consistentemente verde${RESET}"

Esses métodos podem ajudar você a corrigir problemas de cor e criar uma saída colorida consistente em seus scripts Bash em diferentes terminais.

Para mais informações sobre suporte a cores em terminais, consulte a documentação de códigos de escape ANSI.