# 5. Formatacao de Strings e Cores ## Introdução O **Bash** (Bourne Again Shell) é um interpretador de comandos usado em sistemas Unix-like, como Linux e macOS, para executar comandos, criar scripts e automatizar tarefas. Esta documentação foca na **importação** de bibliotecas locais e remotas, **funções**, e **formatação de strings com cores** (color set), detalhando sintaxe, comportamento do computador e exemplos práticos. ## Importação no Bash A importação de código externo no Bash é feita com os comandos `source` ou `.` (equivalentes), que incluem e executam outro script no contexto do script atual, permitindo reutilizar funções, variáveis e configurações. ### Sintaxe ```bash source ./caminho/para/script.sh # ou . ./caminho/para/script.sh ``` * **`source` ou `.`**: Inclui o script especificado. * **Caminho**: Relativo (ex.: `./script.sh`) ou absoluto (ex.: `/home/user/script.sh`). * **Comportamento**: Variáveis e funções do script importado tornam-se disponíveis no mesmo escopo (global, a menos que `local`). ### Importação de Bibliotecas Locais Bibliotecas locais são arquivos Bash (geralmente `.sh`) com funções ou variáveis reutilizáveis. #### Exemplo **cores.sh**: ```bash #!/bin/bash # Função para exibir texto em vermelho vermelho() { echo -e "\033[31m$1\033[0m" } ``` **main.sh**: ```bash #!/bin/bash source ./cores.sh vermelho "Erro: arquivo não encontrado" # Saída: texto em vermelho ``` * **Comportamento do Computador**: * O Bash lê `cores.sh` e carrega a função `vermelho` na memória do processo atual. * A função pode ser chamada no script `main.sh`. * Erro se o arquivo não existir: `source: ./cores.sh: No such file or directory`. #### Validação Verifique a existência do arquivo: ```bash if [ -f "./cores.sh" ]; then source ./cores.sh else echo "Erro: cores.sh não encontrado" exit 1 fi ``` ### Importação de Bibliotecas Remotas Bibliotecas remotas podem ser baixadas com `curl` ou `wget` e executadas com `source`. {% hint style="warning" %} Scripts remotos podem ser inseguros. {% endhint %} #### Exemplo ```bash #!/bin/bash curl -s https://exemplo.com/cores.sh | source /dev/stdin ``` * **Comportamento do Computador**: * `curl -s` baixa o script silenciosamente. * `source /dev/stdin` executa o conteúdo no contexto atual. * Funções e variáveis do script remoto são carregadas na memória. * Falhas na rede causam erro no `curl`, interrompendo a importação. #### Alternativa Segura Baixe para um arquivo temporário: ```bash #!/bin/bash temp_script=$(mktemp) curl -s -o "$temp_script" https://exemplo.com/cores.sh if [ $? -eq 0 ]; then source "$temp_script" rm "$temp_script" else echo "Erro ao baixar biblioteca remota" exit 1 fi ``` * **Comportamento**: O script é salvo temporariamente, executado e removido, reduzindo riscos. #### Cuidados * **Segurança**: Inspecione scripts remotos antes de executar. * **Conexão**: Valide a rede: ```bash if ! curl -s --head https://exemplo.com/cores.sh >/dev/null; then echo "Erro: URL inacessível" exit 1 fi ``` * **Cache**: Armazene localmente para evitar downloads repetidos: ```bash if [ ! -f "./cores.sh" ]; then curl -s -o cores.sh https://exemplo.com/cores.sh fi source ./cores.sh ``` ## Funções no Bash Funções agrupam comandos para reutilização, frequentemente importadas de bibliotecas. ### Sintaxe ```bash nome_funcao() { # Comandos } # ou function nome_funcao { # Comandos } ``` * **Chamada**: `nome_funcao [argumentos]`. * **Argumentos**: `$1`, `$2`, ..., `$@` (todos), `$#` (quantidade). * **Retorno**: Use `return` (códigos 0-255) ou `echo` (valores). #### Exemplo **funcoes.sh**: ```bash #!/bin/bash exibir_aviso() { local mensagem="$1" echo -e "\033[33mAviso: $mensagem\033[0m" } ``` **main.sh**: ```bash #!/bin/bash source ./funcoes.sh exibir_aviso "Processando dados..." # Saída: texto em amarelo ``` * **Comportamento do Computador**: * O Bash carrega `exibir_aviso` na memória ao importar `funcoes.sh`. * A função usa códigos ANSI para colorir a saída. * Variáveis locais não afetam o escopo global. ## Formatação de Strings com Conjunto de Cores (Color Set) O Bash suporta formatação de strings, incluindo cores no terminal, usando **códigos de escape ANSI**. Esses códigos controlam a aparência do texto (cor, estilo, fundo) em terminais compatíveis. ### Códigos ANSI para Cores * **Estrutura**: `\033[m\033[0m` * `\033[`: Inicia a sequência de escape. * ``: Define cor ou estilo. * `m`: Aplica o formato. * `\033[0m`: Reseta o formato. #### Cores de Texto (Foreground) * 30: Preto * 31: Vermelho * 32: Verde * 33: Amarelo * 34: Azul * 35: Magenta * 36: Ciano * 37: Branco #### Cores de Fundo (Background) * 40: Preto * 41: Vermelho * 42: Verde * 43: Amarelo * 44: Azul * 45: Magenta * 46: Ciano * 47: Branco #### Estilos * 0: Resetar * 1: Negrito * 4: Sublinhado * 7: Inverter (troca texto e fundo) #### Exemplo ```bash echo -e "\033[31mTexto vermelho\033[0m" echo -e "\033[1;34mTexto azul em negrito\033[0m" echo -e "\033[43mFundo amarelo\033[0m" ``` * **Comportamento do Computador**: * O Bash envia os códigos ANSI ao terminal, que interpreta e aplica a formatação. * `\033[0m` garante que a formatação não afete o texto subsequente. * Terminais não compatíveis (ex.: alguns ambientes remotos) podem exibir os códigos como texto bruto. ### Biblioteca de Cores Crie uma biblioteca para reutilizar funções de formatação de cores. **cores.sh**: ```bash #!/bin/bash vermelho() { echo -e "\033[31m$1\033[0m"; } verde() { echo -e "\033[32m$1\033[0m"; } amarelo() { echo -e "\033[33m$1\033[0m"; } azul() { echo -e "\033[34m$1\033[0m"; } ``` **main.sh**: ```bash #!/bin/bash source ./cores.sh vermelho "Erro!" verde "Sucesso!" amarelo "Aviso!" azul "Informação!" ``` * **Saída**: * Erro! (em vermelho) * Sucesso! (em verde) * Aviso! (em amarelo) * Informação! (em azul) ### Formatação Avançada de Strings Além de cores, o Bash suporta formatação de strings com ferramentas como `printf` e expansões de variáveis. #### Usando `printf` ```bash nome="Alice" printf "\033[32m%s, bem-vindo!\033[0m\n" "$nome" # Saída: Alice, bem-vindo! (em verde) ``` * **Vantagens do `printf`**: * Maior controle sobre formatação (ex.: alinhamento, largura). * Suporta múltiplos argumentos: ```bash printf "\033[31mErro: %s (código %d)\033[0m\n" "falha" 404 ``` #### Expansões de Strings * **Substituição**: `${variavel/padrão/substituição}` ```bash texto="ola mundo" echo "${texto/ola/OLÁ}" # Saída: OLÁ mundo ``` * **Corte**: `${variavel:offset:tamanho}` ```bash echo "${texto:0:3}" # Saída: ola ``` * **Padrão padrão**: `${variavel:-valor}` ```bash echo "${nome:-Desconhecido}" # Saída: Alice (ou Desconhecido se nome vazio) ``` ### Comportamento do Computador * **Códigos ANSI**: Enviados ao terminal, que os interpreta para renderizar cores ou estilos. Terminais incompatíveis podem ignorar ou exibir códigos brutos. * **Printf**: Processa a string internamente, formatando-a antes de enviar ao terminal. * **Expansões**: O Bash processa expansões na memória, substituindo ou manipulando strings antes da saída. ### Boas Práticas para Formatação de Cores * **Use `echo -e` ou `printf`**: `echo -e` habilita sequências de escape; `printf` é mais robusto. * **Sempre resetar**: Inclua `\033[0m` para evitar formatação persistente. * **Teste compatibilidade**: Verifique se o terminal suporta ANSI (`tput colors` retorna o número de cores suportadas). * **Centralize em biblioteca**: Armazene funções de cores em um arquivo importado: ```bash # cores.sh erro() { echo -e "\033[1;31m$1\033[0m"; } ``` ## Integração de Importação, Funções e Formatação **funcoes\_cores.sh**: ```bash #!/bin/bash log_erro() { echo -e "\033[1;31m[ERRO] $1\033[0m"; } log_sucesso() { echo -e "\033[1;32m[SUCESSO] $1\033[0m"; } formatar_nome() { echo "${1^^}"; } # Converte para maiúsculas ``` **main.sh**: ```bash #!/bin/bash source ./funcoes_cores.sh log_erro "Falha no processo" log_sucesso "Operação concluída" nome=$(formatar_nome "alice") log_sucesso "Nome formatado: $nome" ``` * **Saída**: * \[ERRO] Falha no processo (em vermelho negrito) * \[SUCESSO] Operação concluída (em verde negrito) * \[SUCESSO] Nome formatado: ALICE (em verde negrito) ## Permissões e Execução * Tornar executável: `chmod +x script.sh`. * Executar: `./script.sh`. ## Redirecionamento e Pipelines Cores podem não funcionar em redirecionamentos para arquivos, pois códigos ANSI são texto bruto: ```bash source ./cores.sh vermelho "Erro" > output.txt # output.txt contém \033[31mErro\033[0m ``` Solução: Remova códigos ANSI para arquivos: ```bash log_limpo() { echo "$1" | sed -r 's/\033\[[0-9;]*m//g'; } log_limpo "$(vermelho "Erro")" > output.txt # output.txt contém apenas "Erro" ``` ## Boas Práticas Gerais * Valide arquivos importados com `[ -f ]`. * Inspecione scripts remotos por segurança. * Use nomes únicos para funções e variáveis. * Comente bibliotecas para clareza. * Teste scripts em ambientes seguros. ## Recursos Adicionais * Manual: `man bash`, `man printf`. * Ajuda: ` --help`. * Comunidades: Stack Overflow, fóruns Linux. Essa documentação detalha importação de bibliotecas locais e remotas, funções e formatação de strings com cores no Bash, explicando o comportamento do computador e fornecendo exemplos práticos. Para aprofundar, experimente criar bibliotecas de formatação ou consulte a documentação oficial. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://0xmorte.gitbook.io/bibliadopentestbr/conceitos/programacao-e-linguagens/bash-ou-shell/5.-formatacao-de-strings-e-cores.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.