Colorindo seu terminal e ambiente de shell?

Aqui está uma algumas coisas que você pode fazer:

Editores + Código
Muitos editores têm sintaxe destacando o suporte. vim e emacs estão ativados por padrão. Você também pode habilitá-lo em nano .

Você também pode sintetizar o código de realce no terminal usando Pygments como ferramenta de linha de comando.

grep
grep --color=auto destaca todas as correspondências. Você também pode usar export GREP_OPTIONS="--color=auto" para torná-lo persistente sem um alias. Se você usar --color=always, “ll usará cores mesmo quando for canalizado , o que confunde as coisas.

ls

ls --color=always

Cores especificadas por:

export LS_COLORS="rs=0:di=01;34:ln=01;36:mh=00:pi=40;33" 

(dica: dircolors pode ser útil)

PS1
Você pode definir seu PS1 (prompt do shell) para usar cores. Por exemplo:

PS1="\e[33;1m\u@\h: \e[31m\W\e[0m\$ " 

Irá produzir um PS1 como:

[amarelo] lucas @ ubuntu: [vermelho] ~ [normal] $

Você pode ser muito criativo com isso. Como uma ideia:

PS1="\e[s\e[0;0H\e[1;33m\h \t\n\e[1;32mThis is my computer\e[u[\u@\h: \w]\$ " 

Coloca uma barra no topo do seu terminal com algumas informações aleatórias. (Para melhores resultados, também use alias clear="echo -e "\e[2J\n\n"".)

Livrando-se das sequências de escape

Se algo está travado na saída de cor quando você não quer, eu uso este sed linha para retirar as sequências de escape:

sed "s/\[^[[0-9;]*[a-zA-Z]//gi" 

Se quiser uma experiência mais autêntica, você também pode se livrar das linhas que começam com \e[8m, que instrui o terminal a ocultar o texto. (Não é amplamente suportado.)

sed "s/^\[^[8m.*$//gi" 

Observe também que esses ^ [s devem ser ^ [s reais, literais. Você pode digitá-los pressionando ^ V ^ [no bash, ou seja, Ctrl + V , Ctrl + [ .

Comentários

• A primeira linha PS1 deve ser assim: PS1='\e[33;1m\u@\h: \e[31m\W\e[0m\$ '. Há um x supérfluo após a quarta barra invertida.
• As fugas devem ser colocadas entre \[...\] ou os comandos da segunda linha sobrescreverão a primeira linha. PS1 = ‘ [ \ e [33; 1m ] \ u @ \ h: [ \ e [31m ] \ W \ e [0m \ $ ‘
• O ls --color=always não ‘ não funciona.A abordagem de @Michael Durrant ‘ é melhor para isso: ls --color=al > /dev/null 2>&1 && alias ls='ls -F --color=al' || alias ls='ls -G'

Eu também uso:

export TERM=xterm-color export GREP_OPTIONS="--color=auto" GREP_COLOR="1;32" export CLICOLOR=1 export LSCOLORS=ExFxCxDxBxegedabagacad 

E se você gosta de colorir seu prompt, as cores definidas podem seja útil:

export COLOR_NC="\e[0m" # No Color export COLOR_BLACK="\e[0;30m" export COLOR_GRAY="\e[1;30m" export COLOR_RED="\e[0;31m" export COLOR_LIGHT_RED="\e[1;31m" export COLOR_GREEN="\e[0;32m" export COLOR_LIGHT_GREEN="\e[1;32m" export COLOR_BROWN="\e[0;33m" export COLOR_YELLOW="\e[1;33m" export COLOR_BLUE="\e[0;34m" export COLOR_LIGHT_BLUE="\e[1;34m" export COLOR_PURPLE="\e[0;35m" export COLOR_LIGHT_PURPLE="\e[1;35m" export COLOR_CYAN="\e[0;36m" export COLOR_LIGHT_CYAN="\e[1;36m" export COLOR_LIGHT_GRAY="\e[0;37m" export COLOR_WHITE="\e[1;37m" 

E então meu prompt é mais ou menos assim:

case $TERM in xterm*|rxvt*) local TITLEBAR="\[\033]0;\u ${NEW_PWD}\007\]" ;; *) local TITLEBAR="" ;; esac local UC=$COLOR_WHITE # user"s color [ $UID -eq "0" ] && UC=$COLOR_RED # root"s color PS1="$TITLEBAR\n\[${UC}\]\u \[${COLOR_LIGHT_BLUE}\]\${PWD} \[${COLOR_BLACK}\]\$(vcprompt) \n\[${COLOR_LIGHT_GREEN}\]→\[${COLOR_NC}\] " 

$ (vcprompt) está chamando um script python em meu ~ / sbin que imprime informações de controle de versão sobre o caminho atual. Inclui suporte para Mercurial, Git, Svn, Cvs, etc. O autor do script tem a fonte aqui .

Este é o fonte completa da minha configuração de prompt:

Comentários

• Veja aqui a solução para um problema de linha que tive quando usei o acima PS1: stackoverflow.com/questions/5087036/…
• I ‘ atualizamos a resposta para refletir os colchetes de escape para as cores no prompt. Obrigado!
• $LSCOLORS e $CLICOLOR são para BSD ls. GNU ls (Linux) usa $LS_COLORS com uma sintaxe diferente. Como o GNU me parece um lar, uso LSCOLORS=exgxfxDacxBaBaCaCaeaEa para imitar as ‘ cores do GNU no BSD.
• grep: warning: GREP_OPTIONS is deprecated; please use an alias or script
• Você pode precisar fornecer o arquivo .bashrc para que a modificação tenha efeito. Você pode fazer isso com o seguinte comando. source /path/to/.bashrc

grep e ls já foram mencionados, se você quiser muito mais cores verifique Colorizador genérico , seu objetivo inicial era colorir os arquivos de log, mas, ao sair da caixa, também coloriza ping, traceroute, gcc, make, netstat, diff, last, ldap e cvs.

É facilmente estendido se você conheço regexes. Eu adicionei ps e nmap à lista (se você entrar em grc Ficarei mais do que feliz em compartilhar os arquivos .conf para essas duas ferramentas)

(A propósito, para instalá-lo via synaptic, pacman, e da mesma forma você pode ter mais sorte na pesquisa para “grc”)

Comentários

• grc agora é compatível com ps por padrão. Eu ‘ d estaria interessado em suas nmap colorações. Veja também minha resposta para aliasing todos eles de uma forma que irá absorver novos comandos quando você atualizar o grc.
• Eu percebi isso. aqui ‘ s meu conf.nmap (e todo o resto, na verdade) gist.github.com/sygo/844982#file-conf -nmap – Notei que você trabalha no infosec, você pode achar o conf.hexdump interessante, mas ainda ‘ não terminei.
• Obrigado @Sygo. Eu ‘ bifurquei e revisei sua essência. Eu ‘ nunca realmente fiz commit de dados com git (muito menos github ‘ s gists) e não consigo descobrir como propor mesclá-los novamente para você (eu ‘ estou supondo que isso é porque os pontos essenciais são muito simplificados).
• Eu suspeito que você pode ‘ t porque ‘ é uma essência e não um repositório adequado. No entanto, eu verifiquei seu fork e ‘ estou definitivamente testando sua versão. Eu ‘ estou curioso para saber o que aquele hex dump se tornará …

Eu aperfeiçoei meu .bashrc ao longo dos anos para trabalhar no OSX e no Ubuntu.
Eu também o reduzi em tamanho para 28 linhas com declarações de condição compactas.
Com ele , meu prompt PS1 se parece com:

com hora em vermelho, nome de usuário em verde, nome da máquina em azul claro, pwd em azul mais escuro e git branch em amarelo.

Recurso do meu prompt PS1:

• mostra git branch!
• caminhos de diretório longos (mais de 6 elementos) são ” aparado “para mostrar os 3 primeiros e os 3 últimos diretórios com _ entre eles (é a pwd sed parte de LOCATION).
• retorno de carro no final para que o prompt esteja sempre à esquerda!

As linhas relevantes do meu arquivo .bashrc são:

git_branch () { git branch 2> /dev/null | sed -e "/^[^*]/d" -e "s/* \(.*\)/\1/"; } HOST="\033[02;36m\]\h"; HOST=" "$HOST TIME="\033[01;31m\]\t \033[01;32m\]" LOCATION=" \033[01;34m\]`pwd | sed "s#\(/[^/]\{1,\}/[^/]\{1,\}/[^/]\{1,\}/\).*\(/[^/]\{1,\}/[^/]\{1,\}\)/\{0,1\}#\1_\2#g"`" BRANCH=" \033[00;33m\]$(git_branch)\[\033[00m\]\n\$ " PS1=$TIME$USER$HOST$LOCATION$BRANCH PS2="\[\033[01;36m\]>" 

Para ls com cores quando disponível um d sem erros quando não (ou seja,OSX):

ls --color=al > /dev/null 2>&1 && alias ls="ls -F --color=al" || alias ls="ls -G" 

Comentários

• As cores estão disponíveis para ls no OS X, mas é feito usando export CLICOLOR=1.
• @ThomasW mas não no linux :-p O cara usa os dois.
• No entanto, ThomasW está correto em apontar que a resposta está errada ao dizer que as cores não estão disponíveis com ls no MacOS 10. A resposta também está errada porque o as strings de prompt aqui estão de fato com defeito. Eles não equilibram corretamente \[ e \] e causaram problemas para pelo menos uma pessoa ao copiar esta resposta .

Cores para páginas do manual ( mais detalhes ):

function _colorman() { env \ LESS_TERMCAP_mb=$(printf "\e[1;35m") \ LESS_TERMCAP_md=$(printf "\e[1;34m") \ LESS_TERMCAP_me=$(printf "\e[0m") \ LESS_TERMCAP_se=$(printf "\e[0m") \ LESS_TERMCAP_so=$(printf "\e[7;40m") \ LESS_TERMCAP_ue=$(printf "\e[0m") \ LESS_TERMCAP_us=$(printf "\e[1;33m") \ "$@" } function man() { _colorman man "$@"; } function perldoc() { command perldoc -n less "$@" |man -l -; } 

Cores para grep (1;32 é verde brilhante, veja outros posts aqui para outras cores):

GREP_OPTS="--color=auto" # for aliases since $GREP_OPTIONS is deprecated GREP_COLOR="1;32" # (legacy) bright green rather than default red GREP_COLORS="ms=$GREP_COLOR" # (new) Matching text in Selected line = green alias grep="grep $GREP_OPTS" alias egrep="egrep $GREP_OPTS" alias fgrep="fgrep $GREP_OPTS" 

Mais cores para GNU ls :

# use the config at ~/.dircolors if it exists, otherwise generate anew eval "$( dircolors --sh $(ls -d ~/.dircolors 2>/dev/null) )" # Usage: _ls_colors_add BASE NEW [NEW...] # Have LS color given NEW extensions the way BASE extension is colored _ls_colors_add() { local BASE_COLOR="${LS_COLORS##*:?.$1=}" NEW if [ "$LS_COLORS" != "$BASE_COLOR" ]; then BASE_COLOR="${BASE_COLOR%%:*}" shift for NEW in "$@"; do if [ "$LS_COLORS" = "${LS_COLORS#*.$NEW=}" ]; then LS_COLORS="${LS_COLORS%%:}:*.$NEW=$BASE_COLOR:" fi done fi export LS_COLORS } _ls_colors_add zip jar xpi # archives _ls_colors_add jpg ico JPG PNG webp # images _ls_colors_add ogg opus # audio (opus now included by default) CLICOLOR=1 # BSD auto-color trigger (like ls -G but for everything) if ls -ld --color=auto / >/dev/null 2>&1 then alias ls="ls -ph --color=auto" else alias ls="ls -ph" fi 

Instalar grc ( Coloridor genérico ) e adicione-o aos seus aliases:

# using this as a variable allows easier calling down lower export GRC="grc -es --colour=auto" # loop through known commands plus all those with named conf files for cmd in g++ head ld ping6 tail traceroute6 `locate grc/conf.`; do cmd="${cmd##*grc/conf.}" # we want just the command # if the command exists, alias it to pass through grc type "$cmd" >/dev/null 2>&1 && alias "$cmd"="$GRC $cmd" done # This needs run-time detection. We even fake the "command not found" error. configure() { if [[ -x ./configure ]]; then colourify ./configure "$@" else echo "configure: command not found" >&2 return 127 fi } # GRC plus LS awesomeness (assumes you have an alias for ls) unalias ll 2>/dev/null if ls -ld --color=always / >/dev/null 2>&1; then GNU_LS="--color=always"; fi ll() { if [[ -t 1 ]] || [[ -n "$CLICOLOR_FORCE" ]] then colourify ls -l $GNU_LS "$@" else ls -l "$@" fi } 

Cores para diff : Muito conteúdo para uma função, use um script e coloque-o no arquivo rc (desnecessário se você instalou grc):

#!/usr/bin/perl use strict; use warnings; open (DIFF, "-|", "diff", @ARGV) or die $!; my $ydiff = 1; while (<DIFF>) { if (not -t 1) { print; next; } chomp; $ydiff = 0 if /^[ <>\@+-]/ or ($. == 1 && /^\d+[a-z]{1,5}\d+$/); my $color = ""; if (! $ydiff && /^[\@+-<>]/) { $color = (/^[<-](?!--$)/ ? 1 : /^[+>]/ ? 2 : 5); } elsif ($ydiff && /\t {6}([<|>])(?:\t|$)/) { $color = ($1 eq "<" ? 1 : $1 eq ">" ? 2 : 4); } $color ? printf ("\e[1;3%dm%s\e[0;0m\n",$color,$_) : print "$_\n"; } close DIFF; 

Cores para prompt bash :

# Shorten home dir, cygwin drives, paths that are too long if [ -d /cygdrive ] && uname -a |grep -qi cygwin; then CYGWIN_OS=1; fi function PSWD() { local p="$*" space A B cols="${COLUMNS:-`tput cols 2>/dev/null || echo 80`}" p="${p/$HOME/\~}" # shrink home down to a tilde if [ -n "$CYGWIN_OS" ] && [ "${p#/cygdrive/?/}" != "$p" ]; then p="${p:10:1}:${p:11}" # /cygdrive/c/hi -> c:/hi fi space="$((${#USER}+${#HOSTNAME}+6))" # width w/out the path if [ "$cols" -lt 60 ]; then echo -n "$N "; space=-29; p="$p$N\b"; fi if [ "$cols" -lt "$((space+${#p}+20))" ]; then # < 20 chars for the command A=$(( (cols-20-space)/4 )) # a quarter of the space (-20 for cmd) if [ $A -lt 4 ]; then A=4; fi # 4+ chars from beginning B=$(( cols-20-space-A*2 )) # half (plus rounding) of the space if [ $B -lt 8 ]; then B=8; fi # 8+ chars from end p="${p:0:$A}..${p: -$B}" fi echo "$p" } PSC() { echo -ne "\[\033[${1:-0;38}m\]"; } PR="0;32" # default color used in prompt is green if [ "$(id -u)" = 0 ]; then sudo=41 # root is red background elif [ "$USER" != "${SUDO_USER:-$USER}" ]; then sudo=31 # not root, not self: red text else sudo="$PR" # standard user color fi PROMPT_COMMAND="[ $? = 0 ] && PS1=${PS1[1]} || PS1=${PS1[2]}" PSbase="$(PSC $sudo)\u$(PSC $PR)@\h $(PSC 33)\$(PSWD \w)" PS1[1]="$PSbase$(PSC $PR)\$ $(PSC)" PS1[2]="$PSbase$(PSC 31)\$ $(PSC)" PS1="${PS1[1]}" unset sudo PR PSbase 

Comentários

• Votos positivos para uma captura de tela
• Minha função PSWD() costumava ser compatível com POSIX, mas ‘ é muito mais fácil de ser facilitada usando manipulação de substring bash / zsh. Veja a revisão 6 para a versão POSIX, que envolve muitos pontos de interrogação e não foi ‘ adaptável ao terminal largura. Não ‘ atualizei a captura de tela, mas ‘ há apenas uma ligeira alteração na largura de 80 caracteres.
• CLICOLOR=1 não ‘ não funciona para mim com o FREEBSD 11.2
• @SimonC. – Você pode estar usando utilitários GNU em seu sistema FreeBSD ao invés dos BSD. CLICOLOR=1 ls deve fazer a mesma coisa que ls -G usando BSD (ls -g em BSDs mais antigos). Se ls --color funcionar (sem erro), você ‘ está usando GNU ‘ s ls comando e $CLICOLOR é ignorado.
• @SimonC. – Você realmente deve carregar seu ~/.bashrc para que as alterações tenham efeito. Execute source ~/.bashrc ou inicie uma nova sessão bash (inicie um terminal ou execute bash).

Defina um prompt em negrito / colorido. De cyberciti.biz e do BashFAQ

# "tput bold" will work regardless of the foreground and background colors. # Place the tput output into variables, so they are only execd once. bold=$(tput bold) # This could also be a color. reset=$(tput sgr0) export PS1="\u@\[$bold\]\h\[$reset\]:\w \$ " 

Eu também consegui encontrar configurações de cores que são amplamente suportadas e que não imprimem caracteres gobbledygook em ambientes mais antigos (mesmo FreeBSD4!), e parece funcionar bem se TERM = vt100, xterm , cor xterm. (Em geral). Do meu .bashrc:

# Set some options, based on the OS OS=`uname -s` case "$OS" in "SunOS" ) # Solaris ls doesn"t allow color, so use special characters LS_OPTS="-F" alias ls="ls ${LS_OPTS}" ;; "Linux" ) # GNU ls supports colors! # See dircolors to customize colors export LS_OPTS="--color=auto" alias ls="ls ${LS_OPTS}" # Get color support for "less" export LESS="--RAW-CONTROL-CHARS" # Use colors for less, man, etc. [[ -f ~/.LESS_TERMCAP ]] && . ~/.LESS_TERMCAP export GREP_OPTIONS="--color=auto" ;; "Darwin"|"FreeBSD") # Most FreeBSD & Apple Darwin supports colors export CLICOLOR=true # Get color support for "less" export LESS="--RAW-CONTROL-CHARS" # Use colors for less, man, etc. [[ -f ~/.LESS_TERMCAP ]] && . ~/.LESS_TERMCAP export GREP_OPTIONS="--color=auto" ;; * ) echo "Unknown OS [$OS]" ;; esac 

Comentários

• Ou se você quiser usar ZSH, Phil Gold ‘ s prompt em aperiodic.net/phil/prompt é uma obra de arte.

Coisas que ainda não foram ditas aqui:

Para colorir a saída de suas compilações com gcc , existe colorgcc de Johannes Schlüter

Para colorir logs, existe multitail

Para colorir qualquer stdout, eu coloquei xcol

Eu pessoalmente uso estes da ferramenta xcol.

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

Também gosto desta pequena função colouredEcho (encontrada no Stack Overflow)

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; } coloredEcho "This text is green" green 

Desculpe, não é permitido postar mais links

Comentários

• Olá, como você faz os sinalizadores para o caminho do prompt? Estou mencionando as barras retangulares com extremidades de triângulo. Obrigado
• isso funciona em um terminal ubuntu gnu também?
• lnav também é uma ótima ferramenta para mostrar arquivos de log coloridos

Há uma boa ferramenta para configurar suas cores para o comando ls – http://geoff.greer.fm/lscolors/

Sugiro que você dê uma olhada em ZSH e seu plug-in oh-my-zsh que tem um dos recursos de console mais poderosos que já vi. Um deles é escolher o tema para seu terminal. Este é um exemplo do meu tema … Na tty as cores não são tão quentes, mas são as mesmas que nesta imagem … De qualquer forma, você vai adorar! “8c43e39300”> insira a descrição da imagem aqui

Para visualizar a saída do diff em cores, use colordiff .

sudo apt-get install colordiff 

Tubo qualquer saída de formato diff para colordiff:

Isso inclui alguns formatos alternativos diff “s, como -y (lado a lado.)

Alternativamente, se invocado autônomo ( sem nada canalizado para ele), ele atua como um invólucro em torno de “diff” e colore a saída. Portanto, tenho isso em meu .bashrc, com o alias “diff” para colordiff.

# if colordiff is installed, use it if type colordiff &>/dev/null ; then alias diff=colordiff 

Comentários

• O .bashrc exemplo não contém o fi, e pode ser convertido em um comando de linha única: type colordiff &> /dev/null && alias diff='colordiff'

Eu apenas me perguntei a mesma coisa. Eu tenho minha própria abordagem, mas estou procurando alternativas.

Eu escrevo invólucros de bash em torno de chamadas de programa e canalizo sua saída através de sed. Do que eu gosto sed é que ele modificará e ecoará cada linha imediatamente => sem muito buffer. No entanto, não gosto que para cada chamada para um programa empacotado o sed o código é analisado e compilado.

Por exemplo, isso é o que eu faço para colorir a saída de ip:

# # Colorcodes # NORMAL=`echo -e "\033[0m"` RED=`echo -e "\033[31m"` GREEN=`echo -e "\033[0;32m"` LGREEN=`echo -e "\033[1;32m"` BLUE=`echo -e "\033[0;34m"` LBLUE=`echo -e "\033[1;34m"` YELLOW=`echo -e "\033[0;33m"` # # command: ip # highlight ip addresses, default route and interface names # IP4=$GREEN IP6=$LBLUE IFACE=${YELLOW} DEFAULT_ROUTE=$LBLUE IP_CMD=$(which ip) function colored_ip() { ${IP_CMD} $@ | sed \ -e "s/inet [^ ]\+ /${IP4}&${NORMAL}/g"\ -e "s/inet6 [^ ]\+ /${IP6}&${NORMAL}/g"\ -e "s/^default via .*$/${DEFAULT_ROUTE}&${NORMAL}/"\ -e "s/^\([0-9]\+: \+\)\([^ \t]\+\)/\1${IFACE}\2${NORMAL}/" } alias ip="colored_ip" 

Para definir o prompt, tenho isso em meu arquivo .bashrc.

#Set variables for foreground colors fgRed=$(tput setaf 1) ; fgGreen=$(tput setaf 2) ; fgBlue=$(tput setaf 4) fgMagenta=$(tput setaf 5) ; fgYellow=$(tput setaf 3) ; fgCyan=$(tput setaf 6) fgWhite=$(tput setaf 7) ; fgBlack=$(tput setaf 0) #Set variables for background colors bgRed=$(tput setab 1) ; bgGreen=$(tput setab 2) ; bgBlue=$(tput setab 4) bgMagenta=$(tput setab 5) ; bgYellow=$(tput setab 3) ; bgCyan=$(tput setab 6) bgWhite=$(tput setab 7) ; bgBlack=$(tput setab 0) #Set variables for font weight and text decoration B=$(tput bold) ; U=$(tput smul) ; C=$(tput sgr0) #NOTE: ${C} clears the current formatting if [[ $USER = "root" ]]; then PS1="${B}${fgRed}\u${C}@\h(\s): ${fgGreen}\w${C} > " else PS1="${B}${fgCyan}\u${C}@\h(\s): ${fgGreen}\w${C} > " fi 

Isso me dá um prompt parecido com este:

user@host(bash): ~/bin > 

O diretório de trabalho está em verde . E o nome do usuário está em negrito e ciano, a menos que eu execute o shell com sudo, caso em que o nome do usuário (“root”) exibe negrito e vermelho.

Pessoalmente, gosto muito de ter os caracteres de controle de formatação armazenados em variáveis porque torna a leitura do código para definir o prompt mais fácil. Também torna a edição do prompt muito mais fácil.

A razão de eu usar tput é que ele deve ter suporte universal do que as estranhas sequências 033[01;31m\]. Além disso, como um bônus adicional, se você fizer echo $PS1 no prompt, verá o prompt bruto com cores em vez dessas sequências de controle ininteligíveis.

Você também pode tentar um projeto que ajude a colorir a saída de scripts, chamado ScriptEchoColor na forja de origem: http://scriptechocolor.sourceforge.net/

ex .:

echoc "@{lr}text output in light red" echoc "@{bLGu}text outpus in blue, light green background and underlined" echoc "you @{lr} can @{bLGu} mix @{-a} it all too" echoc -x "ls" #executes ls command and colorizes it automatically to be easy to be seen 

As cores automáticas são configuráveis.

Isto é um exemplo feito com ele:

Uma excelente ferramenta Python de uso geral para colorir a saída de comandos é “ colout “

Você dá a ele um regex com N grupos, seguido por uma lista separada por vírgulas de N cores. Qualquer texto que corresponda a um grupo será exibido na cor correspondente.

Então, por exemplo, se você estiver vendo algum resultado de teste:

python -m unittest discover -v 

então você pode enfeitá-la up with:

python -m unittest discover -v 2>&1 | colout "(.*ERROR$)|(.*FAIL$)|(\(.*\))" red,yellow,black bold 

Veja como minha regex tem três grupos (parênteses) seguidos por três cores (e opcionalmente três estilos, mas usei uma abreviação para definir todas as cores como “negrito” , então o grupo “preto”, que corresponde ao texto entre colchetes, sai em cinza escuro.)

Observe também como eu tive que adicionar 2>&1 ao final da invocação Python, porque a saída de unittest está em stderr, então eu o transferi para stdout para que eu pudesse canalizá-lo para colout.

Isso geralmente é tão fácil de usar que muitas vezes me encontro criando Colout Invocat íons dinâmicos e reutilizá-los ou modificá-los a partir do meu histórico de linha de comando.

A única desvantagem disso é que ele vem como um pacote Python, não um executável autônomo, então você precisa instalar usando pip ou sudo python setup.py install.

Considero o solarizado útil. É um projeto bacana com cores uniformes para muitos aplicativos.

http://ethanschoonover.com/solarized https://github.com/altercation/solarized

Você pode usar meu cf para colorir o nome do arquivo na linha de comando, é um pequeno colorizador baseado em awk que funciona por meio de tubos – colorindo nomes de arquivos em Truecolor sRGB.

Ele tem um colorido brilhante configuração padrão e ao contrário de ls não sofre uma penalidade de desempenho para adicionar novas cores. (ls deve varrer toda a string LS_COLORS para cada falha).

https://github.com/AdamDanischewski/cf

Para Mac, você pode usar o seguinte conforme especificado aqui

if [ "$TERM" = xterm ]; then TERM=xterm-256color; fi 

Eu uso o invólucro de cor .

cw é um invólucro de cores ANSI em tempo real não intrusivo para comandos comuns baseados em Unix no GNU / linux. cw é projetado para simular o ambiente dos comandos sendo executados, de forma que se uma pessoa digitar “du”, “df”, “ping”, etc. em seu shell, ele irá colorir automaticamente a saída em tempo real de acordo com uma definição arquivo contendo o formato de cor desejado. cw tem suporte para coloração de correspondência curinga, coloração tokenizada, cabeçalhos / rodapés, coloração de cenário de caso, coloração de definição dependente de linha de comando e inclui mais de 50 arquivos de definição predefinidos.

É quase contínuo, mas quando descobri que o ps no shell interativo retorna uma saída diferente, comparando o ps em um pipe.

se você quiser deixar seu vim colorido como eu, sugiro que siga duas etapas:

1. aprenda a ligar o recurso seguindo este link: ative o realce da sintaxe de cores no vi ou vim .

principais etapas no link:

1. Edite o arquivo ~ / .vimrc digitando o comando: vi ~ /.vimrc

2. Anexe a seguinte opção: sintaxe em

3. Salve e feche o arquivo

4. Teste executando o comando vim: vim foo.sh

2. encontre um esquema de cores de sua preferência e use-o. O esquema que uso: o esquema que estou usando

Comentários

• Ao usar links para fonte externa, você deve verificar a parte ” Fornecer contexto para links ” (citar partes importantes) da parte relevante do guia: unix.stackexchange.com/help/how-to-answer

Se bash for sua escolha, recomendo oh-my-bash . Se zsh for sua escolha, eu recomendo oh-my-zsh . Ambos suportam a colorização de seu terminal e saídas diferentes.

Eu gostaria de humildemente anunciar minha publicação recente de ta ou textattr , uma biblioteca e ferramenta de linha de comando que visa tornar a adição de cores e atributos para embelezar a saída do terminal de seu programa mais fácil, traduzindo especificações legíveis por humanos em códigos de escape ANSI.

Por exemplo:

echo "The Git repo $(ta yellow)${CUR_REPO}$(ta off) is $(ta green)up-to-date$(ta off)"

ou ainda mais curto:

echo "The Git repo $(ta y)${CUR_REPO}$(ta f) is $(ta g)up-to-date$(ta f)"

ou um alternativo:

tawrite "The Git repo " @y ${CUR_REPO} @f " is " @g up-to-date @f "\n"

fornecerá algo como:

Atualmente, esta biblioteca pode ser usada em quatro linguagens C, C ++, D e Python, além do uso da linha de comando em seu shell favorito .

Observe que ele não colore automaticamente a saída de nenhum outro programa. É um utilitário para ajudá-lo com aving para lembrar os códigos obscuros. Você só precisa usar os nomes de cores óbvios ou seus rgb cmyk w (hite) (of) f fáceis de lembrar abreviações.

Para obter mais detalhes, visite o repositório textattr .