it-swarm.com.de

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

Ich verbringe die meiste Zeit damit, in Unix-Umgebungen zu arbeiten und Terminalemulatoren zu verwenden. 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? Auf welche Fallstricke sind Sie gestoßen?

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 nach vielen Experimenten:

  1. Ich neige dazu, TERM=xterm-color, das auf den meisten Hosts (aber nicht auf allen) unterstützt wird.
  2. Ich arbeite auf verschiedenen Hosts, verschiedenen Betriebssystemversionen usw. Ich verwende alles von MacOS X, Ubuntu Linux, RHEL/CentOS/Scientific Linux und FreeBSD. Ich versuche, die Dinge möglichst einfach und allgemein zu halten.
  3. Ich mache eine Menge Arbeit mit GNU screen, was eine weitere Ebene des Spaßes hinzufügt.
  4. Viele Betriebssysteme setzen Dinge wie dircolors und standardmäßig, und ich möchte dies nicht auf hundert verschiedenen Hosts ändern. Also versuche ich, mich an die Standardeinstellungen zu halten. Stattdessen optimiere ich die Farbkonfiguration meines Terminals.
  5. Verwenden Sie Farbe für einige nix-Befehle (ls, grep, less, vim) und die Bash-Eingabeaufforderung . Diese Befehle scheinen den 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 werde meine .bashrc und beantworte meine eigene Frage Jeopardy Style.

267

Hier sind einige Dinge, die Sie tun können:

Editoren + Code
Viele Editoren unterstützen die Syntaxhervorhebung. vim und emacs haben es standardmäßig aktiviert. Sie können auch aktivieren Sie es unter nano .

Sie können den Highlight-Code auch auf dem Terminal syntaxieren, indem Sie Pylements als Befehlszeilenprogramm verwenden.

grep
grep --color=auto Markiert alle Übereinstimmungen. Sie können auch export GREP_OPTIONS='--color=auto' Verwenden, um es ohne Alias ​​dauerhaft zu machen. Wenn Sie --color=always Verwenden, wird es verwenden Sie Farbe auch beim Piping , was die Dinge verwirrt.

ls

ls --color=always

Farben angegeben durch:

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

(Hinweis: dircolors kann hilfreich sein)

PS1
Du kannst deine PS1 (Shell Prompt) so einstellen, dass sie Farben verwendet. Zum Beispiel:

PS1='\e[33;1m\[email protected]\h: \e[31m\W\e[0m\$ '

Produziert eine PS1 wie:

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

Damit können Sie 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[\[email protected]\h:  \w]\$ '

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

Escape-Sequenzen loswerden

Wenn etwas bei der Ausgabe von Farben hängen bleibt, wenn Sie dies nicht möchten, verwende ich diese sed -Zeile, um die Escape-Sequenzen zu entfernen:

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

Wenn Sie eine authentischere Erfahrung wünschen, können Sie auch Zeilen entfernen, die mit \e[8m 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 in Bash ^ V ^ [drücken Ctrl + VCtrl + [.

123
Lucas Jones

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 Farbvarianten 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 Eingabeaufforderung 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 ein python - Skript in meinem ~/sbin auf, das Versionskontrollinformationen über den aktuellen Pfad druckt. Es enthält Unterstützung für Mercurial, Git, Svn, Cvs usw. Der Autor von Das Skript hat das Quelle hier .

(Bash Prompt screenshot

Dies ist das vollständige Quelle meiner Eingabeaufforderungskonfiguration:

86
Kris

grep und ls wurden bereits erwähnt. Wenn Sie viel mehr Farben auschecken möchten Generic Coloriser , bestand der ursprüngliche Zweck darin, Protokolldateien zu kolorieren, jedoch direkt aus dem Box färbt es auch ping, traceroute, gcc, make, netstat, diff, last, ldap und cvs.

Es ist leicht zu erweitern, wenn Sie Regexes kennen. Ich habe ps und nmap zur Liste hinzugefügt (wenn Sie in grc einsteigen, teile ich gerne die .conf-Dateien für diese beiden Tools).

(Übrigens, um es über synaptic, pacman zu installieren, und vielleicht haben Sie auch mehr Glück bei der Suche nach "grc")

18
Sygo

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

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

Feature meiner PS1-Eingabeaufforderung:

  • zeigt Git Zweig!
  • lange Verzeichnispfade (mehr als 6 Elemente) werden "gekürzt", um die oberen 3 und unteren 3 Verzeichnisse mit _ dazwischen anzuzeigen (das ist der pwd sed Teil von LOCATION).
  • wagenrücklauf am Ende, so dass Prompt immer auf der linken Seite ist!

Die relevanten Zeilen aus meiner .bashrc - Datei 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 ohne Fehler, wenn nicht (d. H. OSX):

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

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

Farben für grep (1;32 ist 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 "[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

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 "[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
}

Farben für diff : Zu viel Inhalt für eine Funktion, verwenden Sie ein Skript und aliasen Sie es in Ihrer RC-Datei (nicht erforderlich, wenn Sie grc installiert haben ):

#!/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

demo of bash Prompt

9
Adam Katz

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

Ich habe es auch geschafft, Farbeinstellungen zu finden, die weitgehend unterstützt werden und in älteren Umgebungen (sogar FreeBSD4!) Keine Gobbledygook-Zeichen drucken, und es scheint gut zu 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
8

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

5
Rob Cowell

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 ein stdout einzufärben, habe ich xcol zusammengestellt

(xcol example

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 wie folgt

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

Ich mag auch diese kleine Funktion colouredEcho (gefunden auf 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 ist leider nicht erlaubt, weitere Links zu posten

5
nachoparker

Ich schlage vor, Sie überprüfen ZSH und sein Plugin oh-my-zsh , das eine der leistungsstärksten Konsolenfunktionen hat, die ich gesehen habe . Eines davon ist die Auswahl eines Themas 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 es lieben werden!

enter image description here

4
user92622

Verwenden Sie colordiff , um die Diff-Ausgabe in Farbe anzuzeigen.

Sudo apt-get install colordiff

Leiten Sie eine beliebige Ausgabe im Diff-Format in colordiff:

(output of diff piped into colordiff

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

Wenn es alternativ aufgerufen wird (ohne dass etwas in das Programm geleitet wird), fungiert es alternativ als Wrapper um 'diff' und färbt die Ausgabe. Daher habe ich dies in meinem .bashrc, alias 'diff' zu colordiff.

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

Zum Einstellen der Eingabeaufforderung habe ich dies 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:

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

Das Arbeitsverzeichnis ist grün. Und der Benutzername ist fett und cyan, es sei denn, ich habe die Shell mit Sudo ausgeführt. 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 Einstellen der Eingabeaufforderung erleichtert. Dies erleichtert auch das Bearbeiten der Eingabeaufforderung erheblich .

Der Grund, warum ich tput verwende, ist, dass es universeller unterstützt werden soll als das seltsame 033[01;31m\] Sequenzen. Als zusätzlichen Bonus, wenn Sie echo $PS1 an der Eingabeaufforderung sehen Sie die rohe Eingabeaufforderung mit Farben anstelle dieser unverständlichen Kontrollsequenzen.

3
Sildoreth

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

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

Ich schreibe Bash-Wrapper um Programmaufrufe und leite deren Ausgabe durch sed. Was ich an sed mag, ist, dass es jede Zeile sofort modifiziert und wiedergibt => nicht viel Pufferung. Ich mag es jedoch nicht, dass bei jedem Aufruf eines umschlossenen Programms der Code sed analysiert und kompiliert wird.

Zum Beispiel ist dies das, was ich tue, um die Ausgabe von ip einzufärben:

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

Sie können mein cf zum Färben von Dateinamen in der Befehlszeile verwenden. Es ist ein schneller kleiner awk-basierter Colorizer, der über Pipes funktioniert - das Färben von Dateinamen in Truecolor sRGB.

Es hat eine farbenfrohe Standardkonfiguration und im Gegensatz zu ls wird beim Hinzufügen neuer Farben keine Leistungseinbußen festgestellt. (ls muss den gesamten LS_COLORS-String nach jedem Fehler durchsuchen).

https://github.com/AdamDanischewski/cf

cf usage

cf screenshot

2
A.Danischewski

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

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

2
Vamsi

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

(Uncolored output of some Python unittests

dann können Sie es aufpeppen mit:

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

(Colored output of some Python unittests

Sehen Sie, wie meine Regex drei Gruppen (die Klammer) gefolgt von drei Farben (und optional drei Stilen) hat, aber ich habe eine Kurzform verwendet, um alle Farben auf "Fett" zu setzen, also die Gruppe "Schwarz", die dem Text in Klammern entspricht kommt dunkelgrau heraus.)

Beachten Sie auch, wie ich 2>&1 Am Ende des Aufrufs Python] aufrufen musste, da die Ausgabe von unittest auf stderr liegt, also habe ich sie auf stdout übertragen, damit ich sie weiterleiten kann es in colout.

Dies ist im Allgemeinen so einfach zu verwenden, dass ich häufig spontan neue Colout-Aufrufe erstelle und diese aus meinem Befehlszeilenverlauf wiederverwenden oder ändern kann.

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

2

Sie können ein Projekt ausprobieren, das auch beim Kolorieren der Skriptausgabe hilft. Es heißt ScriptEchoColor bei 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: enter image description here

2
Aquarius Power

Ich benutze Farbverpackung .

cw ist ein nicht aufdringlicher Echtzeit-ANSI-Farb-Wrapper für gängige Unix-basierte Befehle unter GNU/Linux. cw wurde entwickelt, um die Umgebung der ausgeführten Befehle zu simulieren. Wenn eine Person in ihrer Shell 'du', 'df', 'ping' usw. eingibt, wird die Ausgabe gemäß einer Definition automatisch in Echtzeit eingefärbt Datei mit dem gewünschten Farbformat. cw unterstützt das Färben von Platzhalterübereinstimmungen, das Färben von Token, Kopf-/Fußzeilen, das Färben von Fallbeispielen und das Färben von befehlszeilenabhängigen Definitionen und enthält über 50 vorgefertigte Definitionsdateien.

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

1
user3132194

wenn Sie Ihr vim genau wie ich bunt machen möchten, empfehle ich Ihnen, 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 .

schlüsselschritte im Link:

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

  2. Fügen Sie die folgende Option hinzu: Syntax ein

  3. Speichern und schließen Sie die Datei

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

  1. finden Sie ein Farbschema, das Ihnen gefällt, und verwenden Sie es. Das Schema, das ich benutze: das Schema, das ich benutze
0
ZhaoGang

Ich möchte demütig für meine jüngste Veröffentlichung von ta oder textattr werben, ein Bibliotheks- und Befehlszeilentool, mit dem Farbe und hinzugefügt werden sollen Attribute, um die Terminalausgabe Ihres Programms zu verschönern, indem 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 das noch kürzere:

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 so etwas geben wie:

(enter image description here

Derzeit kann diese Bibliothek in vier Sprachen C, C++, D und Python verwendet werden, abgesehen von der Befehlszeilenverwendung Ihrer Lieblings-Shell).

Beachten Sie, dass die Ausgabe anderer Programme nicht automatisch eingefärbt wird. Es ist eher ein Hilfsprogramm, das Ihnen hilft, sich nicht an die abstrusen Codes erinnern zu müssen. Sie müssen nur die offensichtlichen Farbnamen oder deren leicht zu merkende rgb cmyk w(hite) (of) f Abkürzungen verwenden.

Für weitere Details besuchen Sie das Textattr-Repo .

0
jamadagni

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

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

Wenn Sie Bash wählen, empfehle ich oh-my-bash . Wenn Sie zsh wählen, empfehle ich oh-my-zsh . Beide unterstützen die Kolorierung Ihres Terminals und unterschiedliche Ausgaben.

0
TimWirtjes