it-swarm.it

Colorare il tuo terminale e l'ambiente 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 un numero di host diversi, 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, che aggiunge un altro livello di divertimento.
  4. Molti sistemi operativi impostano cose come dircolors e per impostazione predefinita, 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 Bash Prompt . Questi comandi sembrano usare lo standard " ANSI escape sequences ". Per esempio:

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

Pubblicherò il mio .bashrc e rispondi alla mia domanda Jeopardy Style.

267
Stefan Lasiewski

Ecco un paio di cose che puoi fare:

Editor + codice
Molti editor hanno il supporto per evidenziare la sintassi. vim e emacs lo hanno attivato per impostazione predefinita. Puoi anche abilitarlo sotto nano .

È 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 usare export GREP_OPTIONS='--color=auto' per renderlo persistente senza un alias. Se usi --color=always, sa il colore anche durante il piping , 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: dircolors può essere utile)

PS1
Puoi impostare la tua PS1 (prompt della shell) per usare i colori. Per esempio:

PS1='\e[33;1m\[email protected]\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[\[email protected]\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 emette colore quando non lo vuoi, uso questa riga sed per eliminare le sequenze di escape:

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

Se desideri un'esperienza più autentica, puoi anche sbarazzarti delle linee che iniziano con \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, cioè Ctrl + VCtrl + [.

123
Lucas Jones

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 python nel mio ~/sbin che stampa le informazioni di controllo della versione sul percorso corrente. Include il supporto per Mercurial, Git, Svn, Cvs, ecc. L'autore di lo script ha fonte qui .

Bash Prompt screenshot

Questo è il fonte completa della mia configurazione del prompt:

86
Kris

grep e ls sono già stati menzionati, se desideri molti più colori, controlla Colorizer generico , il suo scopo iniziale era quello di colorare i file di log, ma subito box colora anche ping, traceroute, gcc, make, netstat, diff, last, ldap e cvs.

È facilmente esteso se conosci regex. Ho aggiunto ps e nmap all'elenco (se entri in grc sarò più che felice di condividere i file .conf per quei due strumenti)

(A proposito, per installarlo tramite synaptic, pacman e allo stesso modo potresti avere più fortuna a cercare "grc")

18
Sygo

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: enter image description here

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

Caratteristica del mio prompt di PS1:

  • mostra il ramo git!
  • i percorsi di directory lunghi (più di 6 elementi) vengono "ritagliati" per mostrare le directory 3 principali e 3 inferiori con _ tra allora (questo è il pwd sed parte di LOCATION).
  • ritorno a capo alla fine in modo che Prompt sia sempre sulla sinistra!

Le righe pertinenti dal mio .bashrc file 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'
12
Michael Durrant

Colori per 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") \
      "[email protected]"
}
function man() { _colorman man "[email protected]"; }
function perldoc() { command perldoc -n less "[email protected]" |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 "[email protected]"; 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 "[email protected]"
  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 "[email protected]"
    else ls -l "[email protected]"
  fi
}

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

demo of bash Prompt

9
Adam Katz

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="\[email protected]\[$bold\]\h\[$reset\]:\w \$ "

Sono anche riuscito a trovare impostazioni di colore che sono ampiamente supportate e che non stampano personaggi 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
8
Stefan Lasiewski

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

5
Rob Cowell

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

xcol example

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

5
nachoparker

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à!

enter image description here

4
user92622

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:

output of diff piped into colordiff

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

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
4
Jonathan Hartley

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 che assomiglia a questo:

[email protected](bash): ~/bin >

La directory di lavoro è in verde. E il nome utente è in grassetto e ciano a meno che non abbia eseguito 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 .

Il motivo per cui uso tput è che dovrebbe essere più universalmente supportato rispetto allo strano 033[01;31m\] sequenze. Inoltre, come bonus aggiuntivo, se fai echo $PS1 al Prompt, vedrai il Prompt grezzo con colori invece di quelle sequenze di controllo incomprensibili.

3
Sildoreth

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
3
Mischa Arefiev

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

Scrivo wrapper bash intorno alle chiamate di programma e installo il loro output attraverso sed. Quello che mi piace di sed è che modificherà ed eseguirà immediatamente l'eco di ogni riga => non molto buffering. Tuttavia, non mi piace che per ogni chiamata a un programma spostato il codice sed sia 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} [email protected] | 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'
3
Bananguin

Puoi usare my cf per la colorazione dei nomi di file sulla riga di comando, è un colorizer rapido basato su awk che funziona tramite pipe - colorando i nomi dei file in Truecolor sRGB.

Ha una configurazione predefinita dai colori vivaci e, a differenza di ls, non subisce una penalità prestazionale per l'aggiunta di nuovi colori. (Ls deve scansionare l'intera stringa LS_COLORS per ogni errore).

https://github.com/AdamDanischewski/cf

cf usage

cf screenshot

2
A.Danischewski

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

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

2
Vamsi

Un ottimo strumento generico Python 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

Uncolored output of some Python unittests

allora puoi abbellirlo con:

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

Colored output of some Python unittests

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>&1 alla fine dell'invocazione 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 Python, non un eseguibile autonomo, quindi è necessario installarlo usando pip o Sudo python setup.py install.

2
Jonathan Hartley

Puoi provare un progetto che aiuta anche a colorare l'output degli script, il suo nome ScriptEchoColor nella sorgente forge: 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: enter image description here

2
Aquarius Power

Io uso involucro di colore .

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 in esecuzione, 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, colorazione tokenizzata, intestazioni/piè di pagina, colorazione di scenari di casi, colorazione di 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.

1
user3132194

se vuoi rendere colorato il tuo vim 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

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

Vorrei pubblicamente umiliare la mia recente pubblicazione di ta o textattr , una libreria e un comando- strumento di linea 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 come:

enter image description here

Attualmente questa libreria è utilizzabile in quattro lingue C, C++, D e Python oltre all'uso della riga di comando dalla 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 ovvi o il loro facile da ricordare rgb cmyk w(hite) (of) f abbreviazioni.

Per maggiori dettagli visita il repo textattr .

0
jamadagni

Per Mac puoi usare quanto segue come specificato qui

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

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.

0
TimWirtjes