Colorizing din terminal och skalmiljö?

Här är en några saker du kan göra:

Redigerare + kod
Många redaktörer har syntax framhäver stöd. vim och emacs har det som standard. Du kan också aktivera det under nano .

Du kan också syntax markera kod på terminal med Pygments som ett kommandoradsverktyg.

grep
grep --color=auto markerar alla matcher. Du kan också använda export GREP_OPTIONS="--color=auto" för att göra det bestående utan ett alias. Om du använder --color=always använder den ”ll färg även när du rör pipa , vilket förvirrar saker.

ls

ls --color=always

Färger som anges av:

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

(tips: dircolors kan vara till hjälp)

PS1
Du kan ställa in din PS1 (skalprompt) för att använda färger. Till exempel:

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

Skapar en PS1 som:

[gul] lucas @ ubuntu: [röd] ~ [normal] $

Du kan bli riktigt kreativ med detta. Som en idé:

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

Sätter en stapel högst upp på din terminal med lite slumpmässig information. (För bästa resultat, använd också alias clear="echo -e "\e[2J\n\n"".)

Att bli av med Escape-sekvenser

Om något fastnar med färg när du inte vill ha det, använder jag den här sed rad för att ta bort escape-sekvenser:

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

Om du vill ha en mer autentisk upplevelse kan du också bli av med rader som börjar med \e[8m, som instruerar terminalen att dölja texten. (Stöds inte allmänt.)

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

Observera också att dessa ^ [s bör vara faktiska, bokstavliga ^ [s. Du kan skriva dem genom att trycka på ^ V ^ [i bash, det vill säga Ctrl + V , Ctrl + [ .

Kommentarer

• Den första PS1-raden ska vara så här: PS1='\e[33;1m\u@\h: \e[31m\W\e[0m\$ '. Det finns ett överflödigt x efter det fjärde snedstrecket.
• Flykt ska ingå i \[...\] eller annars kommer kommandon i andra raden att skriva över den första raden. PS1 = ’ [ \ e [33; 1m ] \ u @ \ h: [ \ e [31m ] \ W \ e [0m \ $ ’
• ls --color=always fungerar inte ’.@Michael Durrant ’ s strategi är bättre för detta: ls --color=al > /dev/null 2>&1 && alias ls='ls -F --color=al' || alias ls='ls -G'

Jag använder också:

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

Och om du gillar att färga din fråga kan definierade färgvaror vara användbar:

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" 

Och då är min uppmaning ungefär så här:

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) anropar ett python-skript i mitt ~ / sbin som skriver ut versionskontrollinformation om den aktuella sökvägen. Det inkluderar stöd för Mercurial, Git, Svn, Cvs, etc. Författaren till skriptet har källan här .

Detta är fullständig källa för min snabbkonfiguration:

Kommentarer

• Se här för lösningen på ett radproblem som jag fick när jag använde ovan PS1: stackoverflow.com/questions/5087036/…
• I ’ har uppdaterat svaret så att de återspeglar parenteserna för färgerna i prompten. Tack!
• $LSCOLORS och $CLICOLOR är för BSD ls. GNU ls (Linux) använder $LS_COLORS med en annan syntax. Eftersom GNU känns som hemma för mig använder jag LSCOLORS=exgxfxDacxBaBaCaCaeaEa för att efterlikna GNU ’ s färger på BSD.
• grep: warning: GREP_OPTIONS is deprecated; please use an alias or script
• Du kan behöva källa till .bashrc -filen för att ändringen ska vara effektiv. Du kan göra det med följande kommando. source /path/to/.bashrc

grep och ls har redan nämnts, om du vill ha många fler färger, kolla in Generic Coloriser , dess ursprungliga syfte var att färga loggfiler, men direkt ur lådan färgar det också ping, traceroute, gcc, make, netstat, diff, last, ldap och cvs.

Det kan enkelt förlängas om du vet regexer. Jag har lagt till ps och nmap till listan (om du hamnar i grc Jag är mer än glad att dela .conf-filerna för de två verktygen)

(Btw, att installera den via synaptic, pacman, och du kan ha bättre tur att söka för ”grc”)

Kommentarer

• grc stöder nu ps som standard. Jag ’ Jag är intresserad av dina nmap färgämnen. Se också mitt svar för att aliasera alla dessa på ett sätt som kommer att absorbera nya kommandon när du uppgraderar grc.
• Jag märkte det. här ’ är min conf.nmap (och allt annat, verkligen) gist.github.com/sygo/844982#file-conf -nmap – Jag märkte att du arbetar i infosec, du kanske tycker att conf.hexdump är intressant, jag har dock inte ’ det än.
• Tack @Sygo. Jag ’ har gafflat och reviderat din kärna. Jag ’ har aldrig faktiskt begått data med git (än mindre github ’ s gists) och jag kan inte räkna ut hur jag kan föreslå att slå samman det till dig (jag ’ jag gissar att detta beror på att gists är för förenklade).
• Jag misstänker att du kan ’ t eftersom det ’ är en kärnan och inte ett korrekt förvar. Jag kollade dock på din gaffel och jag ’ ger definitivt din version en chans. Jag ’ jag är nyfiken på vad den hexdumpen kommer att förvandlas till …

Färger för man-sidor ( mer detaljer ):

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

Färger för grep (1;32 är ljusgrön, se andra inlägg här för andra färger):

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" 

Fler färger för 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 

Installera grc ( Generic Colouriser ) och lägg till det i dina 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 } 

Färger för diff : För mycket innehåll för en funktion, använd ett skript och alias det i din rc-fil (onödigt om du installerade 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; 

Färger för bash prompt :

# 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 

Kommentarer

• Rösta på en skärmdump
• Min PSWD() -funktion brukade vara POSIX-kompatibel men den ’ är så mycket lättare använder bash / zsh underlagshantering. Se version 6 för POSIX-versionen, som involverar många frågetecken och var inte ’ t alls anpassningsbar till terminal bredd. Jag ’ t uppdaterade skärmdumpen, men den ’ är bara en liten förändring vid 80 tecken bredd.
• CLICOLOR=1 fungerar inte ’ för mig med FREEBSD 11.2
• @SimonC. – Du kanske använder GNU-verktyg på ditt FreeBSD-system snarare än BSD-enheterna. CLICOLOR=1 ls bör göra samma sak som ls -G med BSD (ls -g på äldre BSD). Om ls --color fungerar (inget fel) använder du ’ GNU ’ s ls kommando och $CLICOLOR ignoreras.
• @SimonC. – Du måste faktiskt ladda din ~/.bashrc för att alla ändringar ska träda i kraft. Kör antingen source ~/.bashrc eller starta en ny bash-session (starta en terminal eller kör bash).

Ställ in en fet / färgad fråga. Från cyberciti.biz och 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 \$ " 

Jag har också lyckats hitta färginställningar som stöds allmänt och som inte skriver ut gobbledygook-tecken i äldre miljöer (även FreeBSD4!), och verkar fungera bra om TERM = vt100, xterm , xterm-färg. (För det mesta). Från min .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 

Kommentarer

• Eller om du vill använda ZSH, Phil Gold ’ s prompt vid aperiodic.net/phil/prompt är ett konstverk.

Saker som inte har sagts redan här:

Att färglägga resultatet av dina samlingar med gcc , det finns colorgcc av Johannes Schlüter

För att färga loggar finns det flera svansar

För att färga alla stdout sätter jag ihop xcol

Jag använder personligen dessa från xcol-verktyget.

#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 

Jag använder dessa variabler i mina skript som så

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

Jag gillar även den här lilla funktionen colouredEcho (finns på 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 

Tyvärr får jag inte lägga upp fler länkar

Kommentarer

• Hej, hur skapar du flaggorna för snabbvägen? Jag nämner de rektangulära staplarna med triangeländar Tack
• fungerar det också i en ubuntu GNU-terminal?
• lnav är också ett utmärkt verktyg för att visa färgade loggfiler

Det finns ett bra verktyg för att ställa in dina färger för kommandot ls – http://geoff.greer.fm/lscolors/

Jag föreslår att du kolla in ZSH och dess plugin oh-my-zsh som har en av de mest kraftfulla konsolfunktionerna som jag såg. En av dem är att välja tema för din terminal. Detta är ett exempel på mitt tema … Färgerna är inte så varma men de är desamma som på den här bilden … Hur som helst kommer du att älska det!

Kommentarer

• Om jag kunde skulle jag nedrösta detta för Oh-My-ZSH Som systemtekniker som arbetar mycket i terminalen, och som någon som försökte använda zsh / oh-my-zsh i mitt arbetsflöde, kan ärligt säga att jag aldrig skulle rekommendera ZSH till någon. Visst, du kan länka zsh till en fil som är uppkallad efter något annat skal och efterlikna det skalet, men när du gör det läser det inte ’ din .bashrc, .bash_profile osv. Också , du kan inte placera emulate bash i dina .zprofile- eller .zshrc-filer. För alla som arbetar med avancerade funktioner i BASH finns det många finesser som kommer att bita dig. BASH är en bättre sh.
• Det enda som ZSH har ur lådan som är bättre än BASH är kommandofullförande, men även det är programmerbart i BASH. Kanske någon som inte ’ inte använder skalet förutom enstaka vardagliga uppgifter bör anta ZSH, men det ’ är inte för någon som behöver använd skalet i stor utsträckning. =~ operatören kan bita dig, hur ZSH hanterar arrays kan bita dig osv. Efter att ha använt ZSH / Oh-My-ZSH i ungefär 9 månader hade jag nog av det. Jag använde ett anpassat tema som jag skrev själv, jag portade det till BASH och skrev min egen git promptline och jag ’ har aldrig sett mig tillbaka. Nu oroar jag mig inte längre för bärbarhet
• ” den har en av de mest kraftfulla konsolfunktionerna som jag såg. En av dem väljer tema för din terminal. ”
• @JonathanHartley, din kommentar ser ut som om du lämnade den ofullständig. ?
• Tack för din oro men min kommentar säger allt jag tänkte säga.

För att visa diff-utdata i färg, använd colordiff .

sudo apt-get install colordiff 

Pipe alla diff-format utdata till colordiff:

Detta inkluderar några av diff ”s alternativa format, som -y (sida vid sida.)

Alternativt, om åberopat fristående ( utan att något rörs in i det) fungerar det som ett omslag runt ”diff” och färgar utdata. Därför har jag det här i min .bashrc, till alias ”diff” till colordiff.

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

Kommentarer

• .bashrc -exemplet saknas det sista fi och kan konverteras till ett enradig kommando: type colordiff &> /dev/null && alias diff='colordiff'

Jag undrade bara samma sak. Jag har mitt eget tillvägagångssätt, men jag letar efter alternativ.

Jag skriver bash-omslag runt programsamtal och rör deras utdata ändå sed. Vad jag tycker om sed är att det kommer att modifiera och eka varje rad direkt => inte mycket buffring. Jag tycker dock inte om att för varje samtal till ett inslaget program ska sed -koden analyseras och kompileras.

Till exempel gör jag det för att färga utdata från 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" 

För att ställa in prompten har jag detta i min .bashrc-fil.

#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 

Detta ger mig en uppmaning som ser ungefär så här ut:

user@host(bash): ~/bin > 

Arbetskatalogen är i grönt Och användarnamnet är fet och cyan om jag inte körde skalet med sudo, i vilket fall användarnamnet (”root”) visar fet och rött.

Jag gillar personligen verkligen att formateringskontrolltecken lagras i variabler eftersom det gör det lättare att läsa koden för att ställa in prompten. Det gör också redigering av prompten mycket enklare.

Anledningen till att jag använder tput är att den ska stödjas mer allmänt än de konstiga 033[01;31m\] sekvenserna. Om du gör echo $PS1 som en extra bonus kommer du också att se den råa prompten med färger istället för de obegripliga kontrollsekvenserna.

Du kan prova ett projekt som också hjälper till att färga skriptutskrifter, dess namn ScriptEchoColor vid källsmedjan: 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 

De automatiska färgerna kan konfigureras.

Detta är ett exempel gjort med det:

Ett fantastiskt Python -verktyg för allmänt ändamål för att färglägga kommandon är ” colout ”

Du ger det en regex med N-grupper följt av en kommaseparerad lista med N-färger. All text som matchar en grupp visas i motsvarande färg.

Så om du till exempel tittar på någon testutmatning:

python -m unittest discover -v 

så kan du spruce upp med:

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

Se hur min regex har tre grupper (parentes) följt av tre färger (och valfritt tre stilar, men jag har använt en stenografi för att ställa in alla färger till ”fet” , så ”svart” -gruppen, som matchar text inom parentes, blir mörkgrå.)

Observera också hur jag var tvungen att lägga till 2>&1 till slutet av Python-anropet, eftersom produktionen av unittest är på stderr, så jag överförde den till stdout så att jag kunde leda den till colout.

Detta är i allmänhet så lätt att använda att jag ofta befinner mig i att skapa nya colout invocat joner on-the-fly, och återanvändning eller ändring av dem från min kommandoradshistorik.

Den enda nackdelen med det är att det kommer som ett Python-paket, inte som en fristående körbar, så du måste installera det med pip, eller sudo python setup.py install.

Jag tycker att Solarized är användbart. Det är ett snyggt projekt med enhetliga färger för många applikationer.

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

Du kan använda min cf för filnamnfärgning på kommandoraden, det är en snabb liten awk-baserad färg som fungerar via rör – färgning av filnamn i Truecolor sRGB.

Den har en stark färg standardkonfiguration och till skillnad från ls lider det inte av prestationsstraff för att lägga till nya färger. (ls måste skanna hela LS_COLORS-strängen för varje miss).

https://github.com/AdamDanischewski/cf

För Mac kan du använda följande som specificerat här

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

Jag använder färgomslag .

cw är ett icke-påträngande ANSI-färgomslag i realtid för vanliga unix-baserade kommandon på GNU / linux. cw är utformad för att simulera miljön för de kommandon som körs, så att om en person skriver ”du”, ”df”, ”ping”, etc. i sitt skal, kommer den automatiskt att färga utdata i realtid enligt en definition fil som innehåller önskat färgformat. cw har stöd för färgläggning av jokertecken, tokeniserad färgning, sidhuvuden / sidfot, färgläggning av fall, kommandoradsberoende definitionsfärgning och innehåller över 50 färdiga definitionsfiler.

Det är nästan sömlöst, men en gång upptäckte jag att ps i interaktivt skal returnerar olika utdata jämfört med ps i ett rör.

om du vill göra din vim färgstark precis som jag, föreslår jag att du följer två steg:

1. lär dig hur du aktiverar funktionen genom att följa den här länken: aktivera färgsyntaxmarkering i vi eller vim .

viktiga steg i länken:

1. Redigera ~ / .vimrc-fil genom att skriva kommandot: vi ~ /.vimrc

2. Lägg till följande alternativ: syntax på

3. Spara och stäng filen

4. Testa det genom att köra vim-kommandot: vim foo.sh

2. hitta ett färgschema du vill ha och använd det. Schemat som jag använder: det schema som jag använder

Kommentarer

• När du använder länkar till extern källa bör du kontrollera ” Ange sammanhang för länkar ” -del (Citera viktiga delar) av den relevanta delen av guiden: unix.stackexchange.com/help/how-to-answer

Om bash är ditt val, rekommenderar jag oh-my-bash . Om du väljer zsh rekommenderar jag oh-my-zsh . Båda stöder färgläggning av din terminal och olika utdata.

Jag vill ödmjukt annonsera min senaste publikation av ta eller textattr , ett bibliotek och kommandoradsverktyg som syftar till att göra det lättare att lägga till färg och attribut för att försköna programmets terminalutgång genom att översätta mänskliga läsbara specifikationer till ANSI-flyktkoder.

Till exempel:

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

eller ännu kortare:

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

eller en alternativ:

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

ger dig något som:

För närvarande är detta bibliotek användbart från fyra språk C, C ++, D och Python förutom kommandoradsanvändning från ditt favoritskal .

Observera att det inte automatiskt färgar utdata från andra program. Det är snarare ett verktyg som hjälper dig att inte h aving att komma ihåg de abstrusa koder. Du behöver bara använda de uppenbara färgnamnen eller deras lätt att komma ihåg rgb cmyk w (hite) (of) f förkortningar.

För mer information besök textattr repo .