Colorare l'ambiente terminale e shell?

Trascorro la maggior parte del mio tempo lavorando in ambienti Unix e usando emulatori di terminali. Cerco di usare il colore dalla riga di comando, perché il colore rende l'output più utile e intuitivo.

Quali opzioni esistono per aggiungere colore al mio ambiente terminale? Quali trucchi usi? Quali insidie ​​hai riscontrato?

Sfortunatamente, il supporto per il colore varia a seconda del tipo di terminale, sistema operativo, impostazione TERM, utilità, implementazioni errate, ecc.

Ecco alcuni suggerimenti dal mio setup, dopo molta sperimentazione:

1. Tendo a impostare TERM=xterm-color, che è supportato sulla maggior parte degli host (ma non su tutti).
2. Lavoro su diversi host, diverse versioni del sistema operativo, ecc. Uso tutto da macOS X, Ubuntu Linux, RHEL / CentOS / Scientific Linux e FreeBSD. Sto cercando di mantenere le cose semplici e generiche, se possibile.
3. Faccio un sacco di lavoro usando GNU screen, il che aggiunge un altro livello di divertimento.
4. Molti sistemi operativi impostano cose come dircolorse di default, e non voglio modificarlo su cento host diversi. Quindi provo a mantenere le impostazioni predefinite. Invece, ottimizzo la configurazione del colore del mio terminale.

5. Usa il colore per alcuni comandi Unix ( ls, grep, less, vim) e il prompt di Bash . Questi comandi sembrano utilizzare le " sequenze di escape ANSI " standard . Per esempio:

   alias less='less --RAW-CONTROL-CHARS'
   export LS_OPTS='--color=auto'
   alias ls='ls ${LS_OPTS}'
   

Pubblicherò il mio .bashrce risponderò alla mia domanda Jeopardy Style.

Ecco un paio di cose che puoi fare:

Editor + codice
Molti editor hanno il supporto per l'evidenziazione della sintassi. vime emacsaverlo acceso per impostazione predefinita. Puoi anche abilitarlo innano .

È inoltre possibile sintassi evidenziare il codice sul terminale utilizzando Pygments come strumento da riga di comando.

grep
grep --color=auto evidenzia tutte le partite. Puoi anche usarlo export GREP_OPTIONS='--color=auto'per renderlo persistente senza un alias. Se lo usi --color=always, userà il colore anche durante le tubazioni , il che confonde le cose.

ls

ls --color=always

Colori specificati da:

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

(suggerimento: dircolorspuò essere utile)

PS1
È possibile impostare la PS1 (prompt della shell) per utilizzare i colori. Per esempio:

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

Produrrà una PS1 come:

[giallo] lucas @ ubuntu: [rosso] ~ [normale] $

Puoi diventare davvero creativo con questo. Come idea:

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

Mette una barra nella parte superiore del terminale con alcune informazioni casuali. (Per risultati ottimali, utilizzare anche alias clear="echo -e '\e[2J\n\n'".)

Sbarazzarsi delle sequenze di escape

Se qualcosa è bloccato emettendo colore quando non lo vuoi, uso questa sedlinea per eliminare le sequenze di escape:

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

Se vuoi un'esperienza più autentica, puoi anche sbarazzarti delle linee che iniziano \e[8m, che indica al terminale di nascondere il testo. (Non ampiamente supportato.)

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

Si noti inoltre che quei ^ [s dovrebbero essere effettivi, letterali ^ [s. Puoi digitarli premendo ^ V ^ [in bash, ovvero Ctrl+ V, Ctrl+ [.

Uso anche:

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

E se ti piace colorare il tuo prompt, le varianti di colore definite possono essere utili:

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

E poi il mio prompt è qualcosa del genere:

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) sta chiamando uno script python in my ~ / sbin che stampa le informazioni di controllo della versione sul percorso corrente. Include il supporto per Mercurial, Git, Svn, Cvs, ecc. L'autore della sceneggiatura ha la fonte qui .

Questa è la fonte completa della mia configurazione rapida:

grepe lssono già stati menzionati, se si vuole un sacco più colori check out coloriser Generico , il suo scopo iniziale era quello di colorare i file di log, ma proprio fuori dalla scatola si colora anche ping, traceroute, gcc, make, netstat, diff, last, ldap, e cvs.

È facilmente esteso se conosci regex. Ho aggiunto pse nmapalla lista (se entri grcsarò più che felice di condividere i file .conf per quei due strumenti)

(A proposito, per installarlo tramite synaptic, pacmane allo stesso modo potresti avere più fortuna cercando "grc")

Ho affinato il mio .bashrc nel corso degli anni per lavorare su OSX e Ubuntu.
L'ho anche ridotto in dimensioni a 28 righe con dichiarazioni di condizioni compatte.
Con esso, il mio prompt di PS1 assomiglia a:

con il tempo in rosso, nome utente in verde, nome macchina in azzurro, pwd in blu più scuro e ramo git in giallo.

Funzionalità del mio prompt PS1:

• mostra il ramo git!
• i percorsi di directory lunghi (più di 6 elementi) vengono "tagliati" per mostrare le prime 3 e le 3 directory inferiori con _tra di loro (questa è la pwd sedparte di LOCATION).
• ritorno a capo alla fine in modo che il prompt sia sempre sulla sinistra!

Le righe pertinenti dal mio .bashrcfile sono:

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\]>'

Per ls con colori quando disponibili e nessun errore quando non (es. OSX):

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

Colori per le pagine man ( maggiori dettagli ):

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

Colori per grep ( 1;32è verde brillante, vedi altri post qui per altri colori):

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'

Altri colori per 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

Installa grc( Colorizer generico ) e aggiungilo ai tuoi alias:

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

Colori per diff : troppi contenuti per una funzione, usa uno script e alias nel tuo file rc (non necessario se installato 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;

Colori per prompt di 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

Imposta un prompt in grassetto / colorato. Da cyberciti.biz e 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 \$ "

Sono anche riuscito a trovare impostazioni di colore che sono ampiamente supportate e che non stampano caratteri gobbledygook in ambienti più vecchi (anche FreeBSD4!), E sembra funzionare bene se TERM = vt100, xterm, xterm-color. (Per la maggior parte). Dal mio .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

C'è un buon strumento per impostare i colori per il comando ls - http://geoff.greer.fm/lscolors/

Cose che non sono state già dette qui:

Per colorare l'output delle tue compilation con gcc, c'è colorgcc di Johannes Schlüter

Per colorare i registri, esiste un multitail

Per colorare qualsiasi stdout, ho messo insieme xcol

Personalmente li uso dallo strumento 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

Uso queste variabili nei miei script in questo modo

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

Mi piace anche questa piccola funzione colorata Eco (trovata su 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

Spiacenti, non è consentito pubblicare altri collegamenti

Ti suggerisco di dare un'occhiata a ZSH e al suo plugin oh-my-zsh che ha una delle più potenti funzionalità della console che ho visto. Uno di questi è scegliere il tema per il tuo terminale. Questo è un esempio del mio tema ... In tty i colori non sono così caldi ma sono gli stessi di questa immagine ... Ad ogni modo ti piacerà!

Per visualizzare l'output diff a colori, utilizzare colordiff .

sudo apt-get install colordiff

Effettua il pipe di qualsiasi output in formato diff in colordiff:

Ciò include alcuni dei formati alternativi di diff, come -y(side-by-side.)

In alternativa, se invocato autonomo (senza nulla reindirizzato), agisce come un wrapper attorno a "diff" e colora l'output. Quindi ho questo nel mio .bashrc, alias 'diff' al colordiff.

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

Alcune decorazioni di testo (grassetto) per distinguere facilmente tra shell root e non root. Per Zsh:

if test $UID = 0
    then PS1="%B${PS1}%b "
fi

Per Bash:

if test $UID = 0
    then PS1="\033[1m${PS1}\033[0m"
fi

Mi chiedevo solo la stessa cosa. Ho il mio approccio, ma sto cercando alternative.

Scrivo involucri bash attorno alle chiamate di programma e convoglio comunque il loro output sed. Quello che mi piace sedè che modificherà ed eco ogni riga immediatamente => non molto buffering. Tuttavia, non mi piace che per ogni chiamata a un programma spostato il sedcodice venga analizzato e compilato.

Ad esempio, questo è ciò che faccio per colorare l'output di 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'

Per impostare il prompt, ho questo nel mio file .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

Questo mi dà un prompt simile a questo:

user@host(bash): ~/bin >

La directory di lavoro è in verde. E il nome utente è grassetto e ciano a meno che non abbia eseguito la shell con sudo, nel qual caso il nome utente ("root") viene visualizzato in grassetto e rosso.

Personalmente mi piace molto avere i caratteri di controllo della formattazione memorizzati in variabili perché facilita la lettura del codice per l'impostazione del prompt. Inoltre rende molto più semplice la modifica del prompt .

La ragione per cui uso tputè che dovrebbe essere supportato più universalmente delle strane 033[01;31m\]sequenze. Inoltre, come bonus aggiuntivo, se lo fai echo $PS1al prompt, vedrai il prompt grezzo con i colori anziché quelle sequenze di controllo incomprensibili.

Puoi provare un progetto che aiuta a colorare anche l'output degli script, il suo nome ScriptEchoColor alla fonte: 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

I colori automatici sono configurabili.

Questo è un esempio fatto con esso:

Un grande strumento Python generico per colorare l'output dei comandi è ' colout '

Gli dai una regex con N gruppi, seguito da un elenco separato da virgole di N colori. Qualsiasi testo corrispondente a un gruppo verrà visualizzato nel colore corrispondente.

Ad esempio, se stai osservando un output di test:

python -m unittest discover -v

allora puoi abbellirlo con:

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

Guarda come il mio regex ha tre gruppi (la parentesi) seguiti da tre colori (e facoltativamente tre stili, ma ho usato una scorciatoia per impostare tutti i colori su 'grassetto', quindi il gruppo 'nero', che corrisponde al testo tra parentesi , viene visualizzato come grigio scuro.)

Nota anche come ho dovuto aggiungere 2>&1alla fine dell'invocazione di Python, perché l'output di unittest è su stderr, quindi l'ho trasferito su stdout in modo da poterlo convogliare nel colore.

Questo è generalmente così facile da usare che spesso mi trovo a creare nuove invocazioni di colore al volo e a riutilizzarle o modificarle dalla mia cronologia della riga di comando.

L'unico aspetto negativo è che si presenta come un pacchetto Python, non un eseguibile autonomo, quindi è necessario installarlo usando pip o sudo python setup.py install.

Trovo utile Solarized. È un progetto pulito con colori uniformi per molte applicazioni.

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

Uso il wrapper a colori .

cw è un wrapper di colore ANSI in tempo reale non intrusivo per comandi comuni basati su unix su GNU / linux. cw è progettato per simulare l'ambiente dei comandi eseguiti, in modo che se una persona digita 'du', 'df', 'ping', ecc. nella loro shell, colorerà automaticamente l'output in tempo reale secondo una definizione file contenente il formato colore desiderato. cw supporta la colorazione con caratteri jolly, la colorazione tokenizzata, le intestazioni / i piè di pagina, la colorazione dello scenario del caso, la colorazione della definizione dipendente dalla riga di comando e include oltre 50 file di definizione predefiniti.

È quasi senza soluzione di continuità, ma una volta ho scoperto che ps nella shell interattiva restituisce output diversi confrontando ps in una pipe.

Per Mac puoi usare quanto segue come specificato qui

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

se vuoi rendere il tuo vimcolorato proprio come me, ti suggerisco di seguire due passaggi:

1. scopri come attivare la funzione seguendo questo link: attiva l'evidenziazione della sintassi del colore in vi o vim .

passaggi chiave nel collegamento:

1. Modifica il file ~ / .vimrc digitando il comando: vi ~ / .vimrc

2. Aggiungi la seguente opzione: sintassi attivata

3. Salva e chiudi il file

4. Provalo eseguendo il comando vim : vim foo.sh

2. trova una combinazione di colori che ti piace e usala. Lo schema che uso: lo schema che sto usando

Se bash è la tua scelta, ti consiglio oh-my-bash . Se zsh è la tua scelta, ti consiglio oh-my-zsh . Entrambi supportano la colorazione del terminale e diversi output.

Vorrei pubblicamente pubblicizzare la mia recente pubblicazione di tao textattr , una libreria e uno strumento da riga di comando che mira a rendere più semplice l'aggiunta di colore e attributi per abbellire l'output terminale del programma, traducendo le specifiche leggibili dall'uomo in codici di escape ANSI.

Per esempio:

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

o ancora più breve:

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

o un supplente:

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

ti darà qualcosa del tipo:

Attualmente questa libreria è utilizzabile in quattro lingue C, C ++, D e Python oltre all'uso della riga di comando dalla tua shell preferita.

Si noti che non colora automaticamente l'output di altri programmi. È piuttosto un'utilità per aiutarti a non dover ricordare i codici astrusi. Devi solo usare i nomi dei colori evidenti o le loro abbreviazioni rgb cmyk w (hite) (of) f facili da ricordare .

Per maggiori dettagli visita il repository textattr .