Färben Sie Ihre Terminal- und Shell-Umgebung?

Die meiste Zeit arbeite ich in Unix-Umgebungen und verwende Terminalemulatoren. Ich versuche, Farbe in der Befehlszeile zu verwenden, da Farbe die Ausgabe nützlicher und intuitiver macht.

Welche Optionen gibt es, um meiner Terminalumgebung Farbe hinzuzufügen? Welche Tricks benutzt du? Welche Fallstricke sind Ihnen begegnet?

Leider variiert die Unterstützung für Farben je nach Terminaltyp, Betriebssystem, TERM-Einstellung, Dienstprogramm, fehlerhaften Implementierungen usw.

Hier sind einige Tipps aus meinem Setup, nachdem ich viel experimentiert habe:

1. Ich neige dazu einzustellen TERM=xterm-color, was auf den meisten Hosts (aber nicht allen) unterstützt wird.
2. Ich arbeite auf einer Reihe von verschiedenen Hosts, verschiedenen Betriebssystemversionen usw. Ich verwende alles von MacOS X, Ubuntu Linux, RHEL / CentOS / Scientific Linux und FreeBSD. Ich versuche, die Dinge so einfach und allgemein wie möglich zu halten.
3. Ich arbeite screenviel mit GNU , was mir noch mehr Spaß macht.
4. Viele Betriebssysteme stellen Dinge wie dircolorsund standardmäßig ein, und ich möchte dies nicht auf hundert verschiedenen Hosts ändern. Also versuche ich mich an die Vorgaben zu halten. Stattdessen ändere ich die Farbkonfiguration meines Terminals.

5. Verwendung Farbe für einige Unix - Befehle ( ls, grep, less, vim) und die Schlag - Eingabeaufforderung . Diese Befehle scheinen die Standard- " ANSI-Escape-Sequenzen " zu verwenden. Zum Beispiel:

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

Ich poste meine .bashrcund beantworte meine eigene Frage Jeopardy Style.

Hier sind ein paar Dinge, die Sie tun können:

Editoren + Code
Viele Editoren unterstützen die Syntaxhervorhebung. vimund emacsstandardmäßig aktiviert haben. Sie können es auch unter aktivierennano .

Sie können den Code für die Syntaxhervorhebung im Terminal auch mithilfe von Pygments als Befehlszeilentool verwenden.

grep
grep --color=auto hebt alle Übereinstimmungen hervor. Sie können es auch export GREP_OPTIONS='--color=auto'ohne Alias ​​persistent machen. Wenn Sie --color=alwaysdiese Option verwenden, wird die Farbe auch beim Leiten verwendet , was die Dinge verwirrt.

ls

ls --color=always

Farben angegeben von:

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

(Hinweis: dircolorskann hilfreich sein)

PS1
Sie können Ihre PS1 (Shell-Eingabeaufforderung) so einstellen, dass sie Farben verwendet. Zum Beispiel:

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

Erzeugt eine PS1 wie:

[gelb] lucas @ ubuntu: [rot] ~ [normal] $

Sie können damit wirklich kreativ werden. Als Idee:

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

Setzt eine Leiste mit zufälligen Informationen oben auf Ihr Terminal. (Für beste Ergebnisse auch verwenden alias clear="echo -e '\e[2J\n\n'".)

Befreien Sie sich von Escape-Sequenzen

Wenn etwas feststeckt und Farbe ausgibt, wenn Sie dies nicht möchten, benutze ich diese sedZeile, um die Escape-Sequenzen zu entfernen:

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

Wenn Sie ein authentischeres Erlebnis wünschen, können Sie auch Zeilen entfernen \e[8m, die mit beginnen , wodurch das Terminal angewiesen wird, den Text auszublenden. (Nicht weit verbreitet.)

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

Beachten Sie auch, dass diese ^ [s tatsächliche, wörtliche ^ [s sein sollten. Sie können sie eingeben, indem Sie ^ V ^ [in bash drücken, das heißt Ctrl+ V, Ctrl+ [.

Ich benutze auch:

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

Und wenn Sie Ihre Eingabeaufforderung einfärben möchten, können definierte Farbvariablen hilfreich sein:

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'

Und dann ist meine Aufforderung ungefähr so:

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) ruft in my ~ / sbin ein Python-Skript auf, das Informationen zur Versionskontrolle über den aktuellen Pfad ausgibt. Es enthält Unterstützung für Mercurial, Git, Svn, Cvs usw. Der Autor des Skripts hat hier die Quelle .

Dies ist die vollständige Quelle meiner Eingabeaufforderungskonfiguration:

grepund lswerden bereits erwähnt, wenn Sie viel mehr Farben Karo heraus wollen Generika Coloriser , sein ursprüngliches Ziel war es , Logfiles einfärben, sondern direkt aus der Box um ihn koloriert auch ping, traceroute, gcc, make, netstat, diff, last, ldap, und cvs.

Es ist leicht zu erweitern, wenn Sie reguläre Ausdrücke kennen. Ich habe psund nmapzu der Liste hinzugefügt (wenn Sie grcdazukommen, teile ich die .conf-Dateien für diese beiden Tools gerne mit Ihnen).

(Btw, zu installieren es über synaptic, pacmanund ebenso könnte man mehr Glück für „GRC“ gesucht hat)

Ich habe meine .bashrc im Laufe der Jahre verbessert, um sowohl unter OSX als auch unter Ubuntu zu arbeiten.
Ich habe es auch auf 28 Zeilen mit kompakten Bedingungsanweisungen verkleinert.
Damit sieht meine PS1-Eingabeaufforderung folgendermaßen aus:

mit der zeit in rot, benutzername in grün, maschinenname in hellblau, pwd in dunkelblau und git branch in gelb.

Funktion meiner PS1-Eingabeaufforderung:

• Zeigt Git Branch!
• Lange Verzeichnispfade (mehr als 6 Elemente) werden 'gekürzt', um die obersten 3 und untersten 3 Verzeichnisse mit _dazwischen anzuzeigen (das ist der pwd sedTeil von LOCATION).
• Wagenrücklauf am Ende, so dass die Eingabeaufforderung immer links ist!

Die relevanten Zeilen aus meiner .bashrcDatei sind:

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

Für ls mit Farben, wenn verfügbar und keine Fehler, wenn nicht (dh OSX):

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

Farben für Manpages ( mehr Details ):

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

Farben für grep ( 1;32ist hellgrün, siehe andere Beiträge hier für andere Farben):

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'

Weitere Farben 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

Installieren Sie grc( Generic Colouriser ) und fügen Sie es Ihren Aliasen hinzu:

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

Farben für Unterschiede : Zu viel Inhalt für eine Funktion, verwenden Sie ein Skript und geben Sie einen Alias ​​in Ihrer RC-Datei ein (nicht erforderlich, wenn Sie es installiert haben 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;

Farben 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

Stellen Sie eine fett / farbige Eingabeaufforderung ein. Von cyberciti.biz und der 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 \$ "

Ich habe es auch geschafft, Farbeinstellungen zu finden, die weitgehend unterstützt werden und in älteren Umgebungen (sogar FreeBSD4!) Keine Gobbledy-Gook-Zeichen ausgeben, und die gut funktionieren, wenn TERM = vt100, xterm, xterm-color. (Hauptsächlich). Aus meiner .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

Es gibt ein gutes Tool zum Einrichten der Farben für den Befehl ls - http://geoff.greer.fm/lscolors/

Dinge, die hier noch nicht gesagt wurden:

Um die Ausgabe Ihrer Zusammenstellungen mit gcc einzufärben, gibt es colorgcc von Johannes Schlüter

Zum Einfärben von Protokollen gibt es Multitail

Um etwas einzufärben, habe ich xcol zusammengestellt

Ich persönlich benutze diese aus dem Xcol-Tool.

#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

Ich benutze diese Variablen in meinen Skripten so

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

Ich mag auch diese kleine Funktion colouredEcho (gefunden bei 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

Es tut uns leid, aber ich darf keine weiteren Links posten

Ich schlage vor, dass Sie sich ZSH und sein Plugin oh-my-zsh ansehen, das eine der leistungsstärksten Konsolenfunktionen bietet, die ich gesehen habe. Eines davon ist die Themenauswahl für Ihr Terminal. Dies ist ein Beispiel für mein Thema ... In tty sind die Farben nicht so warm, aber sie sind die gleichen wie auf diesem Bild ... Wie auch immer, Sie werden es lieben!

Verwenden Sie zum Anzeigen der Diff-Ausgabe in Farbe den Farbton .

sudo apt-get install colordiff

Pipe jede Ausgabe im Diff-Format in das Colordiff:

Dies schließt einige der alternativen Formate von diff ein, wie -y(Side-by-Side.)

Alternativ dazu fungiert es, wenn es als eigenständiges Programm aufgerufen wird (ohne dass etwas in das Programm geleitet wird), als Wrapper um 'diff' und färbt die Ausgabe. Daher habe ich dies in meinem .bashrc, um alias "diff" zu Colordiff.

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

Einige Textdekorationen (fett) zur einfachen Unterscheidung zwischen Root- und Nicht-Root-Shell. Für Zsh:

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

Für Bash:

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

Ich habe mich nur das Gleiche gefragt. Ich habe meinen eigenen Ansatz, suche aber nach Alternativen.

Ich schreibe Bash-Wrapper um Programmaufrufe und leite ihre Ausgabe trotzdem weiter sed. Was mir gefällt sedist, dass es jede Zeile sofort modifiziert und wiedergibt => nicht viel Pufferung. Ich mag es jedoch nicht, dass bei jedem Aufruf eines umschlossenen Programms der sedCode analysiert und kompiliert wird.

Zum Beispiel ist das, was ich tue, um die Ausgabe von zu färben 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'

Zum Einstellen der Eingabeaufforderung habe ich diese in meiner .bashrc-Datei.

#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

Dies gibt mir eine Eingabeaufforderung, die ungefähr so ​​aussieht:

user@host(bash): ~/bin >

Das Arbeitsverzeichnis ist grün. Und der Benutzername ist fett und cyan, es sei denn, ich habe die Shell mit ausgeführt sudo. In diesem Fall wird der Benutzername ("root") fett und rot angezeigt.

Ich persönlich mag es sehr, wenn die Formatierungssteuerzeichen in Variablen gespeichert werden, da dies das Lesen des Codes zum Festlegen der Eingabeaufforderung erleichtert. Dies erleichtert auch die Bearbeitung der Eingabeaufforderung erheblich .

Der Grund, den ich benutze, tputist, dass es allgemeiner unterstützt werden soll als die seltsamen 033[01;31m\]Sequenzen. Wenn Sie dies echo $PS1an der Eingabeaufforderung tun , sehen Sie als zusätzlichen Bonus die unformatierte Eingabeaufforderung mit Farben anstelle dieser unverständlichen Kontrollsequenzen.

Sie können ein Projekt ausprobieren, das auch beim Einfärben der Skriptausgabe hilft. Es heißt ScriptEchoColor in Source 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

Die automatischen Farben sind konfigurierbar.

Dies ist ein Beispiel dafür:

Ein großartiges Allzweck- Python- Tool zum Färben der Ausgabe von Befehlen ist ' colout '.

Sie geben ihm einen regulären Ausdruck mit N Gruppen, gefolgt von einer durch Kommas getrennten Liste mit N Farben. Jeder Text, der einer Gruppe entspricht, wird in der entsprechenden Farbe angezeigt.

Wenn Sie sich zum Beispiel eine Testausgabe ansehen:

python -m unittest discover -v

dann kannst du es aufpeppen mit:

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

Sehen Sie, wie meine Regex drei Gruppen (die Klammern) hat, gefolgt von drei Farben (und optional drei Stilen), aber ich habe eine Kurzform verwendet, um alle Farben auf 'fett' zu setzen, also die 'schwarze' Gruppe, die mit Text in Klammern übereinstimmt kommt dunkelgrau heraus.)

Beachten Sie auch, wie ich 2>&1am Ende des Python-Aufrufs hinzufügen musste , da die Ausgabe von unittest auf stderr liegt. Ich habe es also auf stdout übertragen, damit ich es in colout umleiten konnte.

Dies ist im Allgemeinen so einfach zu bedienen, dass ich häufig spontan neue Colout-Aufrufe erstelle und diese aus meinem Befehlszeilenverlauf wiederverwende oder ändere.

Der einzige Nachteil ist, dass es sich um ein Python-Paket handelt und nicht um eine eigenständige ausführbare Datei. Sie müssen es also mit pip oder installieren sudo python setup.py install.

Ich finde Solarized nützlich. Es ist ein ordentliches Projekt mit einheitlichen Farben für viele Anwendungen.

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

Ich benutze Color Wrapper .

cw ist ein nicht-intrusiver Echtzeit-ANSI-Farbwrapper für allgemeine Unix-basierte Befehle unter GNU / Linux. cw soll die Umgebung der ausgeführten Befehle simulieren, sodass eine Person, die in ihrer Shell "du", "df", "ping" usw. eingibt, die Ausgabe gemäß einer Definition automatisch in Echtzeit einfärbt Datei mit dem gewünschten Farbformat. cw unterstützt Platzhalter-Übereinstimmungsfarben, Token-Farben, Kopf- / Fußzeilen, Fall-Szenario-Farben und befehlszeilenabhängige Definitionsfarben und enthält über 50 vorgefertigte Definitionsdateien.

Es ist fast nahtlos, aber als ich herausfand, dass ps in der interaktiven Shell eine andere Ausgabe liefert als ps in einer Pipe.

Für Mac können Sie wie hier angegeben Folgendes verwenden

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

wenn du dein vimfarbenfroh machen willst wie ich, empfehle ich dir zwei schritte zu befolgen:

1. Erfahren Sie, wie Sie die Funktion aktivieren, indem Sie diesem Link folgen: Aktivieren Sie die Hervorhebung der Farbsyntax in vi oder vim .

Wichtige Schritte im Link:

1. Bearbeiten Sie die ~ / .vimrc-Datei, indem Sie den folgenden Befehl eingeben: vi ~ / .vimrc

2. Fügen Sie die folgende Option hinzu: syntax on

3. Speichern und schließen Sie die Datei

4. Testen Sie es, indem Sie den Befehl vim ausführen : vim foo.sh

2. Finden Sie ein Farbschema, das Ihnen gefällt, und verwenden Sie es. Das Schema, das ich benutze: das Schema, das ich benutze

Wenn bash Ihre Wahl ist, empfehle ich oh-my-bash . Wenn Sie zsh wählen, empfehle ich oh-my-zsh . Beide unterstützen die Einfärbung Ihres Terminals und unterschiedliche Ausgaben.

Ich möchte demütig für meine kürzlich erschienene Veröffentlichung von taoder textattr werben , einem Bibliotheks- und Befehlszeilentool, mit dem das Hinzufügen von Farben und Attributen vereinfacht werden soll, um die Terminalausgabe Ihres Programms zu verschönern, indem für Menschen lesbare Spezifikationen in ANSI-Escape-Codes übersetzt werden.

Zum Beispiel:

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

oder noch kürzer:

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

oder eine Alternative:

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

wird dir etwas geben wie:

Gegenwärtig kann diese Bibliothek in vier Sprachen (C, C ++, D und Python) verwendet werden, abgesehen von der Verwendung über die Befehlszeile in Ihrer bevorzugten Shell.

Beachten Sie, dass die Ausgabe anderer Programme nicht automatisch eingefärbt wird. Es ist eher ein Hilfsprogramm, um Ihnen dabei zu helfen, sich die abstrusen Codes nicht merken zu müssen. Sie müssen nur die offensichtlichen Farbnamen oder ihre leicht zu merk verwenden rgb cmyk w (hite) (von) f Abkürzungen.

Weitere Informationen finden Sie im Textattr Repo .