Colorare il terminale e lambiente della shell?

Ecco una un paio di cose che puoi fare:

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

Puoi anche evidenziare la sintassi del codice terminale utilizzando Pygments come strumento da riga di comando.

grep
grep --color=auto evidenzia tutte le corrispondenze. Puoi anche utilizzare export GREP_OPTIONS="--color=auto" per renderlo persistente senza un alias. Se utilizzi --color=always, “ll usa 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: dircolors può essere utile)

PS1
Puoi impostare la PS1 (prompt della shell) in modo che utilizzi i colori. Ad 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 tuo terminale con alcune informazioni casuali. (Per risultati migliori, utilizza anche alias clear="echo -e "\e[2J\n\n"".)

Eliminazione delle sequenze di escape

Se qualcosa si blocca emettendo colore quando non lo vuoi, lo uso sed riga per eliminare le sequenze di escape:

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

Se desideri unesperienza più autentica, puoi anche eliminare le righe che iniziano con \e[8m, che indica al terminale di nascondere il testo. (Non ampiamente supportato.)

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

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

Commenti

• La prima riga di PS1 dovrebbe essere così: PS1='\e[33;1m\u@\h: \e[31m\W\e[0m\$ '. Cè una x superflua dopo la quarta barra rovesciata.
• Gli escape dovrebbero essere racchiusi tra \[...\] altrimenti i comandi nella seconda riga sovrascriveranno la prima riga. PS1 = ‘ [ \ e [33; 1m ] \ u @ \ h: [ \ e [31m ] \ W \ e [0m \ $ ‘
• ls --color=always ‘ t funziona.Lapproccio di @Michael Durrant ‘ è migliore per questo: ls --color=al > /dev/null 2>&1 && alias ls='ls -F --color=al' || alias ls='ls -G'

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 variabili di colore definite possono essere utile:

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

Questo è sorgente completa della mia configurazione del prompt:

Commenti

• Vedi qui per la soluzione a un problema di linea che ho avuto quando ho usato quanto sopra PS1: stackoverflow.com/questions/5087036/…
• I ‘ ho aggiornato la risposta per riflettere le parentesi con caratteri di escape per i colori nel prompt. Grazie!
• $LSCOLORS e $CLICOLOR sono per BSD ls. GNU ls (Linux) utilizza $LS_COLORS con una sintassi diversa. Dato che GNU mi sembra di essere a casa, uso LSCOLORS=exgxfxDacxBaBaCaCaeaEa per imitare i colori di GNU ‘ su BSD.
• grep: warning: GREP_OPTIONS is deprecated; please use an alias or script
• Potrebbe essere necessario creare il file .bashrc affinché la modifica sia effettiva. Puoi farlo con il seguente comando. source /path/to/.bashrc

grep e ls sono già stati menzionati, se vuoi molti più colori dai unocchiata a Colorizzatore generico , il suo scopo iniziale era colorare i file di log, ma immediatamente colora anche ping, traceroute, gcc, make, netstat, diff, last, ldap e cvs.

È facilmente estendibile se conosco le espressioni regolari. Ho “aggiunto ps e nmap allelenco (se entri in grc Sarò più che felice di condividere i file .conf per questi due strumenti)

(Btw, per installarlo tramite synaptic, pacman, e allo stesso modo potresti avere più fortuna nella ricerca per “grc”)

Commenti

• grc ora supporta ps per impostazione predefinita. ‘ sarei interessato ai tuoi nmap colorazioni. Vedi anche la mia risposta per laliasing di tutti questi in un modo che assorbirà nuovi comandi quando aggiorni grc.
• Lho notato. qui ‘ la mia conf.nmap (e tutto il resto, davvero) gist.github.com/sygo/844982#file-conf -nmap – Ho notato che lavori in infosec, potresti trovare interessante conf.hexdump, non lho ancora ‘ finito.
• Grazie @Sygo. Ho ‘ biforcato e rivisto il tuo succo. ‘ non ho mai effettivamente eseguito il commit dei dati con git (per non parlare dei riassunti di github ‘) e non riesco a capire come proporre di unirli nuovamente a te (‘ immagino sia perché i concetti sono troppo semplificati).
• Sospetto che tu possa ‘ Questo perché ‘ è una sintesi e non è un vero e proprio repository. Ho comunque controllato il tuo fork e ‘ sto decisamente provando la tua versione. ‘ sono curioso di sapere cosa si trasformerà in quel file hex dump …

Ho “affinato il mio .bashrc nel corso degli anni per lavorare sia su OSX che su Ubuntu.
Lho anche ridotto di dimensione a 28 righe con istruzioni di condizione compatte.
Con esso , il mio messaggio PS1 ha il seguente aspetto:

con lora in rosso, il nome utente in verde, il nome della macchina in azzurro, pwd in blu più scuro e git branch in giallo.

Caratteristica del mio prompt PS1:

• mostra git branch!
• percorsi di directory lunghi (più di 6 elementi) sono ” trimmed “per mostrare le prime 3 e le ultime 3 directory con _ tra allora (quella” è la pwd sed parte di LOCATION).
• ritorno a capo alla fine in modo che il prompt sia sempre a sinistra!

Le righe pertinenti del mio file .bashrc 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 disponibile un d nessun errore quando no (es.OSX):

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

Commenti

• I colori sono disponibili per ls su OS X, ma è fatto usando export CLICOLOR=1.
• @ThomasW ma non su linux :-p Il ragazzo usa entrambi.
• Tuttavia, ThomasW ha ragione nel sottolineare che la risposta è errata nel dire che i colori non sono disponibili con ls su MacOS 10. La risposta è errata anche in quanto il le stringhe di prompt qui sono infatti difettose. Non bilanciano correttamente \[ e \] e hanno causato problemi ad almeno una persona che copia questa risposta .

Colori per pagine man ( più 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 ( Coloratore 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 : Troppo contenuto per una funzione, utilizza uno script e crea un 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 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 

Commenti

• Voto positivo per uno screenshot
• La mia funzione PSWD() era compatibile con POSIX ma ‘ è molto più semplice utilizzando la gestione della sottostringa bash / zsh. Vedi la revisione 6 per la versione POSIX, che include molti punti interrogativi e non era ‘ adattabile al terminale larghezza. Non ho ‘ aggiornato lo screenshot, ma ‘ è solo una leggera modifica alla larghezza di 80 caratteri.
• CLICOLOR=1 ‘ non funziona per me con FREEBSD 11.2
• @SimonC. – Potresti usare le utilità GNU sul tuo sistema FreeBSD invece di quelle BSD. CLICOLOR=1 ls dovrebbe fare la stessa cosa di ls -G utilizzando BSD (ls -g su BSD meno recenti). Se ls --color funziona (nessun errore), ‘ stai utilizzando GNU ‘ s ls e $CLICOLOR vengono ignorati.
• @SimonC. – Devi effettivamente caricare il tuo ~/.bashrc affinché le modifiche abbiano effetto. Esegui source ~/.bashrc o avvia una nuova sessione bash (avvia un terminale o esegui bash).

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 del 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 

Commenti

• Oppure, se desideri utilizzare ZSH, Phil Gold ‘ Il prompt di aperiodic.net/phil/prompt è unopera darte.

Cose che non sono già state dette qui:

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

Per colorare i log, cè multitail

Per colorare qualsiasi stdout, metto insieme xcol

Io personalmente uso queste 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 colouredEcho (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 

Spiacente, non è consentito pubblicare più link

Commenti

• Ciao, come crei i flag, per il percorso del prompt? Sto menzionando le barre rettangolari con estremità triangolari Grazie
• funziona anche in un terminale Ubuntu GNU?
• lnav è anche un ottimo strumento per mostrare file di log colorati

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

Ti suggerisco di dare unocchiata a ZSH e il suo plug-in oh-my-zsh che ha una delle funzionalità della console più potenti 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 lo adorerai!

Commenti

• Se potessi, farei un voto negativo per Oh-My-ZSH suggerimento. In qualità di ingegnere di sistema che lavora a lungo nel terminale e come qualcuno che ha cercato di adottare zsh / oh-my-zsh nel mio flusso di lavoro, ho posso dire onestamente che non consiglierei mai ZSH a nessuno. Certo, puoi creare un link simbolico zsh a un file chiamato dopo qualsiasi altra shell ed emulare quella shell, ma quando lo fai non ‘ leggerà i tuoi .bashrc, .bash_profile, ecc. , non puoi inserire emulate bash nei tuoi file .zprofile o .zshrc. Per chiunque lavori con funzionalità avanzate in BASH, ci sono molte sottigliezze che ti morderanno. BASH è un modo migliore.
• Lunica cosa che ZSH ha fuori dagli schemi che è migliore di BASH è il completamento del comando, ma anche quello è programmabile in BASH. Forse qualcuno che non ‘ usa la shell tranne che per attività banali occasionali dovrebbe adottare ZSH, ma ‘ non è adatto a chiunque ne abbia bisogno utilizzare ampiamente la shell. loperatore =~ può morderti, il modo in cui ZSH gestisce gli array può morderti, ecc. Dopo aver usato ZSH / Oh-My-ZSH per circa 9 mesi ne ho avuto abbastanza. Stavo usando un tema personalizzato che ho scritto io stesso, lho portato su BASH e ho scritto il mio promptline git e ‘ non ho mai guardato indietro. Ora non mi preoccupo più della portabilità
• ” ha una delle caratteristiche della console più potenti che ho visto. Uno di questi è scegliere il tema per il tuo terminale. ”
• @JonathanHartley, il tuo commento sembra che tu labbia lasciato incompleto. ?
• Grazie per la tua preoccupazione, ma il mio commento dice tutto quello che volevo dire.

Per visualizzare loutput delle differenze a colori, utilizza colordiff .

sudo apt-get install colordiff 

Pipe qualsiasi output in formato diff in colordiff:

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

In alternativa, se invocato standalone ( senza alcun collegamento in esso) quindi funge da wrapper attorno a “diff” e colora loutput. Quindi ho questo nel mio .bashrc, ad alias “diff” in colordiff.

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

Commenti

• Nellesempio .bashrc manca il fi e potrebbe essere convertito in un comando a riga singola: type colordiff &> /dev/null && alias diff='colordiff'

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

Scrivo wrapper bash attorno alle chiamate di programma e convoglia il loro output anche se sed. Cosa mi piace di sed è che modificherà e visualizzerà immediatamente ogni riga => non molto buffering. Tuttavia, non mi piace che per ogni chiamata a un programma avvolto il sed il codice viene analizzato e compilato.

Ad esempio, questo è ciò che faccio per colorare loutput 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, ce lho 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 è in 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 nelle variabili perché semplifica la lettura del codice per limpostazione del prompt. Rende anche la modifica del prompt molto più semplice.

Il motivo per cui utilizzo tput è che dovrebbe essere supportato universalmente rispetto alle strane 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.

Puoi anche provare un progetto che aiuta a colorare loutput degli script, chiamato ScriptEchoColor su source forge: http://scriptechocolor.sourceforge.net/

es .:

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 ottimo strumento Python generico per colorare loutput dei comandi è “ colout “

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

Quindi, ad esempio, se “stai guardando un output di prova:

python -m unittest discover -v 

quindi puoi abbellirlo con:

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

Guarda come la mia regex ha tre gruppi (le parentesi) seguiti da tre colori (e facoltativamente tre stili, ma ho usato una scorciatoia per impostare tutti i colori in “grassetto” , quindi il gruppo “nero”, che corrisponde al testo tra parentesi, risulta grigio scuro.)

Nota anche come ho dovuto aggiungere 2>&1 alla fine dellinvocazione di Python, perché loutput di unittest è su stderr, quindi lho trasferito a stdout in modo da poterlo convogliare in colout.

Questo è generalmente così facile da usare che spesso mi trovo a creare nuovi colout invocat ioni al volo e riutilizzandoli o modificandoli dalla cronologia della riga di comando.

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

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

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

Puoi usare il mio cf per colorare il nome del file sulla riga di comando, è un “piccolo coloratore veloce basato su awk che funziona tramite pipe – colorando i nomi dei file in Truecolor sRGB.

Ha un colore brillante configurazione predefinita e, a differenza di ls, non subisce una penalizzazione delle prestazioni per laggiunta di nuovi colori. (ls deve scansionare lintera stringa LS_COLORS per ogni errore).

https://github.com/AdamDanischewski/cf

Per Mac puoi utilizzare quanto segue qui

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

Uso wrapper colore .

cw è un wrapper ANSI a colori in tempo reale non intrusivo per i comuni comandi basati su Unix su GNU / linux. cwèprogettato per simulare lambiente dei comandi in esecuzione, in modo che se una persona digita “du”, “df”, “ping”, ecc. nella sua shell colorerà automaticamente loutput in tempo reale secondo una definizione file contenente il formato colore desiderato. cw supporta la colorazione delle corrispondenze con caratteri jolly, la colorazione con token, intestazioni / piè di pagina, la colorazione dello scenario 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 scoperto che ps nella shell interattiva restituisce un output diverso confrontando ps in una pipe.

se vuoi rendere il tuo vim colorato come me, ti suggerisco di seguire due passaggi:

1. impara ad accenderlo la funzione seguendo questo link: attiva levidenziazione 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 su

3. Salva e chiudi il file

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

2. trova uno schema di colori che ti piace e usalo. Lo schema che utilizzo: lo schema che sto utilizzando

Commenti

• Quando si utilizzano collegamenti a una fonte esterna, è necessario controllare la parte ” Fornisci contesto per i collegamenti ” (Cita parti importanti) della parte pertinente della guida: unix.stackexchange.com/help/how-to-answer

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 “pubblicizzare umilmente la mia recente pubblicazione di ta o textattr , una libreria e uno strumento da riga di comando che mira a rendere più facile laggiunta di colori e attributi per abbellire loutput del terminale del programma traducendo le specifiche leggibili dalluomo in codici di escape ANSI.

Ad esempio:

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

o anche più breve:

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

o unalternativa:

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

ti darà qualcosa del tipo:

Attualmente questa libreria è utilizzabile da quattro linguaggi C, C ++, D e Python a parte luso da riga di comando dalla tua shell preferita .

Nota che non colora automaticamente loutput di nessun altro programma, è piuttosto unutilità per aiutarti con non h avendo cura di ricordare i codici astrusi. Devi solo utilizzare i nomi dei colori ovvi o i loro facili da ricordare rgb cmyk w (hite) (of) f abbreviazioni.

Per maggiori dettagli, visita il repository textattr .