Kolorowanie terminala i środowiska powłoki?

Większość czasu spędzam pracując w środowisku Unix i używając emulatorów terminali. Próbuję użyć koloru w wierszu poleceń, ponieważ kolor sprawia, że ​​wydruk jest bardziej użyteczny i intuicyjny.

Jakie są opcje dodania koloru do mojego środowiska terminalowego? Jakich trików używasz? Jakie napotkaliście pułapki?

Niestety obsługa kolorów różni się w zależności od typu terminala, systemu operacyjnego, ustawienia TERM, narzędzia, implementacji błędów itp.

Oto kilka wskazówek z mojej konfiguracji, po wielu eksperymentach:

1. Zazwyczaj ustawiam TERM=xterm-color, który jest obsługiwany na większości hostów (ale nie na wszystkich).
2. Pracuję na wielu różnych hostach, różnych wersjach systemu operacyjnego itp. Używam wszystkiego od macOS X, Ubuntu Linux, RHEL / CentOS / Scientific Linux i FreeBSD. Staram się, aby rzeczy były proste i ogólne, jeśli to możliwe.
3. Robię sporo pracy przy użyciu GNU screen, co dodaje kolejną warstwę zabawy.
4. Wiele systemów operacyjnych ustawia takie rzeczy jak dircolorsi domyślnie, i nie chcę modyfikować tego na stu różnych hostach. Staram się więc trzymać wartości domyślnych. Zamiast tego poprawiam konfigurację kolorów mojego terminala.

5. Zastosowanie koloru jakiegoś Unix poleceń ( ls, grep, less, vim) oraz zachęty Bash . Wydaje się, że te polecenia używają standardowych „ sekwencji ucieczki ANSI ”. Na przykład:

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

Zamieszczę moje .bashrci odpowiem na własne pytanie Jeopardy Style.

Oto kilka rzeczy, które możesz zrobić:

Edytory + kod
Wiele edytorów obsługuje podświetlanie składni. vimi emacsmieć to domyślnie włączone. Możesz również włączyć to wnano .

Możesz także składnić kod podświetlenia na terminalu, używając narzędzia Pygments jako narzędzia wiersza polecenia.

grep
grep --color=auto wyróżnia wszystkie mecze. Możesz także użyć export GREP_OPTIONS='--color=auto'go, aby był trwały bez aliasu. Jeśli użyjesz --color=always, użyje koloru nawet podczas orurowania , co dezorientuje rzeczy.

ls

ls --color=always

Kolory określone przez:

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

(wskazówka: dircolorsmoże być pomocna)

PS1
Możesz ustawić swój PS1 (monit powłoki) na używanie kolorów. Na przykład:

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

Wyprodukuje PS1, takie jak:

[żółty] lucas @ ubuntu: [czerwony] ~ [normalny] $

Dzięki temu możesz być naprawdę kreatywny. Jako pomysł:

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

Umieszcza pasek na górze terminalu z losowymi informacjami. (Aby uzyskać najlepsze wyniki, użyj również alias clear="echo -e '\e[2J\n\n'".)

Pozbywanie się sekwencji ucieczki

Jeśli coś utknęło podczas generowania koloru, gdy nie chcesz, używam tego sedwiersza, aby usunąć sekwencje specjalne:

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

Jeśli chcesz uzyskać bardziej autentyczne wrażenia, możesz także pozbyć się linii zaczynających się od \e[8m, co instruuje terminal, aby ukrył tekst. (Nie jest powszechnie obsługiwane).

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

Zauważ też, że te ^ [s powinny być rzeczywiste, dosłowne ^ [s. Możesz je wpisać, naciskając ^ V ^ [bash, czyli Ctrl+ V, Ctrl+ [.

Używam również:

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

A jeśli podoba Ci się kolorowanie podpowiedzi, przydatne mogą być zdefiniowane zmienne kolorów:

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'

A potem mój monit jest mniej więcej taki:

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) wywołuje skrypt Pythona w mojej ~ / sbin, który wyświetla informacje o kontroli wersji dotyczące bieżącej ścieżki. Obejmuje obsługę Mercurial, Git, Svn, Cvs itp. Autor skryptu ma tutaj źródło .

To jest pełne źródło mojej szybkiej konfiguracji:

grepi lsjuż wspomniano, jeśli chcesz dużo więcej kolorów sprawdzeniu Generic Coloriser jego Początkowym celem było kolorowania logów, ale od razu po wyjęciu z pudełka to także koloruje ping, traceroute, gcc, make, netstat, diff, last, ldap, i cvs.

Można go łatwo rozszerzyć, jeśli znasz wyrażenia regularne. Dodałem psi nmapdo listy (jeśli wejdziesz do grc, chętnie podzielę się plikami .conf dla tych dwóch narzędzi)

(Btw, aby zainstalować go przez synaptic, pacmani podobnie możesz mieć szczęście, szukając „grc”)

Przez lata doskonaliłem mój .bashrc do pracy zarówno na OSX, jak i Ubuntu.
Zmniejszyłem go również do 28 wierszy za pomocą zwartych instrukcji warunkowych.
Dzięki temu mój monit PS1 wygląda następująco:

z czasem na czerwono, nazwa użytkownika na zielono, nazwa maszyny na jasnoniebiesko, pwd na ciemnoniebiesko i gałąź git na żółto.

Funkcja mojego monitu PS1:

• pokazuje gałąź git!
• długie ścieżki katalogu (więcej niż 6 elementów) są „przycinane”, aby pokazywać _pomiędzy nimi 3 katalogi górny i dolny 3 (to pwd sedczęść LOCATION).
• powrót karetki na końcu, aby monit był zawsze po lewej stronie!

Odpowiednie wiersze z mojego .bashrcpliku to:

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

Dla ls z kolorami, jeśli są dostępne i bez błędów, gdy nie są (tj. OSX):

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

Kolory stron podręcznika ( więcej szczegółów ):

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

Kolory dla grep ( 1;32jest jasnozielony, zobacz inne posty tutaj dla innych kolorów):

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'

Więcej kolorów dla 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

Zainstaluj grc( Generic Colouriser ) i dodaj go do swoich aliasów:

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

Kolory dla diff : Zbyt dużo zawartości dla funkcji, użyj skryptu i alias w pliku rc (niepotrzebne, jeśli zainstalowano 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;

Kolory dla zachęty 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

Ustaw pogrubioną / kolorową podpowiedź. Od cyberciti.biz i 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 \$ "

Udało mi się również znaleźć ustawienia kolorów, które są szeroko obsługiwane i które nie drukują znaków gobbledygook w starszych środowiskach (nawet FreeBSD4!) I wydaje się działać dobrze, jeśli TERM = vt100, xterm, xterm-color. (Przez większą część). Z mojego .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

Istnieje dobre narzędzie do ustawiania kolorów dla polecenia ls - http://geoff.greer.fm/lscolors/

Rzeczy, o których tu jeszcze nie powiedziano:

Aby pokolorować dane wyjściowe twoich kompilacji za pomocą gcc, możesz użyć colorgcc autorstwa Johannesa Schlütera

Aby pokolorować dzienniki, jest wielopasmowy

Aby pokolorować każdy standard, zestawiłem xcol

Osobiście używam ich z narzędzia 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

Używam tych zmiennych w moich skryptach w ten sposób

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

Podoba mi się również ta mała funkcja coloredEcho (znaleziona w 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

Przepraszamy, nie wolno dodawać więcej linków

Sugeruję, abyś wypróbował ZSH i jego wtyczkę oh-my-zsh, która ma jedną z najpotężniejszych funkcji konsoli, jakie widziałem. Jednym z nich jest wybór motywu dla twojego terminala. To jest przykład mojego motywu ... W tty kolory nie są tak ciepłe, ale są takie same jak na tym zdjęciu ... W każdym razie pokochasz to!

Aby wyświetlić wyjście różnic w kolorze, użyj colordiff .

sudo apt-get install colordiff

Potokuj dowolne wyjście w formacie diff do colordiff:

Obejmuje to niektóre alternatywne formaty diff, takie jak -y(obok siebie).

Alternatywnie, jeśli wywoływany jest jako samodzielny (bez dołączania do niego żadnych elementów), wówczas działa on jak wrapper wokół „diff” i koloruje dane wyjściowe. Dlatego mam to w moim .bashrc, alias „diff” na colordiff.

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

Niektóre ozdoby tekstowe (pogrubione), aby łatwo odróżnić powłokę root i inną niż root. Dla Zsh:

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

W przypadku Bash:

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

Zastanawiałem się tylko nad tym samym. Mam własne podejście, ale szukam alternatyw.

Piszę bash otoki wokół wywołań programów i przesyłam ich wyniki sed. Podoba mi się sedto, że od razu zmodyfikuje i powtórzy każdą linię => niewiele buforowania. Jednak nie podoba mi się, że dla każdego wywołania owiniętego programu sedkod jest analizowany i kompilowany.

Na przykład to robię, aby pokolorować dane wyjściowe 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'

Aby ustawić monit, mam to w moim pliku .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

To daje mi monit, który wygląda mniej więcej tak:

user@host(bash): ~/bin >

Katalog roboczy jest w kolorze zielonym. A nazwa użytkownika jest pogrubiona i niebieskozielona, ​​chyba że uruchomiłem powłokę sudo, w którym to przypadku nazwa użytkownika („root”) jest pogrubiona i czerwona.

Osobiście bardzo podoba mi się przechowywanie znaków sterujących formatowaniem w zmiennych, ponieważ ułatwia to czytanie kodu do ustawiania pytania. To również sprawia, edycję wiersza znacznie łatwiejsze.

Powodem, dla którego używam tputjest to, że powinna być bardziej uniwersalnie wspierana niż dziwne 033[01;31m\]sekwencje. Jako dodatkowy bonus, jeśli zrobisz to echo $PS1w monicie, zobaczysz surowe monity z kolorami zamiast tych niezrozumiałych sekwencji kontrolnych.

Możesz wypróbować projekt, który pomaga również w kolorowaniu danych wyjściowych skryptów, o nazwie ScriptEchoColor w źródłowej kuźni: http://scriptechocolor.sourceforge.net/

dawny.:

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

Automatyczne kolory można konfigurować.

Oto przykład z tym zrobiony:

Świetnym uniwersalnym narzędziem Pythona do kolorowania danych wyjściowych poleceń jest „ colout ”

Dajesz regex z N grupami, a następnie rozdzieloną przecinkami listą N kolorów. Każdy tekst pasujący do grupy zostanie wyświetlony w odpowiednim kolorze.

Na przykład, jeśli patrzysz na jakieś wyniki testowe:

python -m unittest discover -v

możesz to upiększać za pomocą:

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

Zobacz, jak moje wyrażenie regularne ma trzy grupy (nawiasy), po których następują trzy kolory (i opcjonalnie trzy style, ale użyłem skrótu, aby ustawić wszystkie kolory na „pogrubienie”, a więc na grupę „czarną”, która pasuje do tekstu w nawiasach , pojawia się jako ciemnoszary.)

Zauważ też, jak musiałem dodać 2>&1na końcu wywołania Pythona, ponieważ wyjście unittest jest na stderr, więc przeniosłem je na stdout, aby móc potokować je do colout.

Jest to na ogół tak łatwe w użyciu, że często zdarza mi się tworzyć nowe inwokacje colout w locie oraz ponownie je wykorzystywać lub modyfikować z mojej historii wiersza poleceń.

Jedynym minusem jest to, że jest dostarczany jako pakiet Python, a nie jako samodzielny plik wykonywalny, więc musisz go zainstalować za pomocą pipa lub sudo python setup.py install.

Uważam, że Solarized jest użyteczny. To zgrabny projekt o jednolitych kolorach do wielu zastosowań.

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

Używam owijarki w kolorze .

cw jest nieinwazyjnym opakowaniem kolorów ANSI w czasie rzeczywistym dla popularnych poleceń opartych na Uniksie na GNU / Linux. cw jest zaprojektowany do symulacji środowiska wykonywanych poleceń, aby osoba wpisująca w swojej powłoce „du”, „df”, „ping” itd. automatycznie pokolorowała dane wyjściowe w czasie rzeczywistym zgodnie z definicją plik zawierający żądany format koloru. cw obsługuje kolorowanie przy użyciu symboli wieloznacznych, kolorowanie tokenizowane, nagłówki / stopki, kolorowanie scenariuszy, kolorowanie definicji zależne od wiersza poleceń i zawiera ponad 50 gotowych plików definicji.

Jest prawie bezproblemowy, ale kiedy odkryłem, że ps w interaktywnej powłoce zwraca inne dane wyjściowe, porównując ps w potoku.

W przypadku komputerów Mac możesz użyć następujących opcji określonych tutaj

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

jeśli chcesz, aby Twoje vimkolorowe były takie jak ja, proponuję wykonać dwa kroki:

1. dowiedz się, jak włączyć tę funkcję, klikając ten link: włącz podświetlanie składni kolorów w vi lub vim .

kluczowe kroki w linku:

1. Edytuj plik ~ / .vimrc, wpisując polecenie: vi ~ / .vimrc

2. Dodaj następującą opcję: składnia włączona

3. Zapisz i zamknij plik

4. Przetestuj to, uruchamiając komendę vim : vim foo.sh

2. znajdź odpowiedni schemat kolorów i użyj go. Schemat, którego używam: schemat, którego używam

Jeśli wybrałeś bash, polecam och-bash . Jeśli zsh jest twoim wyborem, polecam oh-my-zsh . Zarówno obsługują kolorowanie twojego terminala, jak i inne wyjście.

Chciałbym pokornie reklamować moją niedawną publikację z talub textattr , biblioteki i narzędzia wiersza polecenia, które ma na celu dodanie koloru i atrybuty, aby upiększyć wyjście terminal programie łatwiej tłumacząc specyfikacje czytelnej dla człowieka na kody ucieczki ANSI.

Na przykład:

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

lub jeszcze krótszy:

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

lub alternatywny:

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

da ci coś takiego:

Obecnie ta biblioteka jest dostępna w czterech językach C, C ++, D i Python, oprócz użycia wiersza poleceń z ulubionej powłoki.

Zauważ, że nie koloryzuje on automatycznie wyników innych programów. Jest to raczej narzędzie, które pomoże ci nie pamiętać niepotrzebnych kodów. Wystarczy użyć oczywistych nazw kolorów lub ich łatwych do zapamiętania skrótów rgb cmyk w (hite) (of) .

Aby uzyskać więcej informacji, odwiedź repozytorium textattr .