Kolorowanie terminala i środowiska powłoki?

262

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.

Stefan Lasiewski
źródło
fyi moje podejście (patrz odpowiedź poniżej) dotyczy problemów z różnicami w OSX i Linux, na przykład kolor na jednym to ls -G, a na drugim ls --color-auto
Michael Durrant
1
Czy ktoś widział narzędzie do kolorowania kolumn? To jest column -t --color?
Tomáš Pospíšek

Odpowiedzi:

121

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+ [.

Lucas Jones
źródło
1
Pierwsza linia PS1 powinien brzmieć tak: PS1='\e[33;1m\u@\h: \e[31m\W\e[0m\$ '. Po czwartym odwrotnym ukośniku występuje zbędny x.
Chris
3
Ucieczki powinny być zawarte w środku, w \[...\]przeciwnym razie polecenia w drugim wierszu zastąpią pierwszy wiersz. PS1 = „[\ e [33; 1m] \ u @ \ h: [\ e [31m] \ W \ e [0m \ $ '
yanglifu90,
To ls --color=alwaysnie działa. Podejście Michaela Durranta jest lepsze:ls --color=al > /dev/null 2>&1 && alias ls='ls -F --color=al' || alias ls='ls -G'
Simon C.
83

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 .

Zrzut ekranu zachęty

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

Kris
źródło
Zobacz tutaj rozwiązanie problemu z linią, który otrzymałem, gdy użyłem powyższego PS1: stackoverflow.com/questions/5087036/…
Xander Dunn
Zaktualizowałem odpowiedź, aby odzwierciedlić znaki zmiany znaczenia dla kolorów w monicie. Dzięki!
Kris,
1
$LSCOLORSi $CLICOLORsą dla BSD ls. GNU ls (Linux) używa $LS_COLORSinnej składni. Ponieważ GNU wydaje mi się domem, LSCOLORS=exgxfxDacxBaBaCaCaeaEanaśladuję kolory GNU na BSD.
Adam Katz
grep: warning: GREP_OPTIONS is deprecated; please use an alias or script
Steven Almeroth
1
Konieczne może być źródło .bashrcpliku, aby modyfikacja była skuteczna. Możesz to zrobić za pomocą następującego polecenia. source /path/to/.bashrc
François
18

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”)

Sygo
źródło
grcteraz obsługuje psdomyślnie. Byłbym zainteresowany twoimi nmapkolorami. Zobacz także moją odpowiedź dotyczącą aliasingu wszystkich tych elementów w sposób, który wchłonie nowe polecenia podczas aktualizacji grc.
Adam Katz
Zauważyłem to. oto moja conf.nmap (i wszystko inne, naprawdę) gist.github.com/sygo/844982#file-conf-nmap - Zauważyłem, że pracujesz w infosec, może być interesujący dla conf.hexdump, jeszcze go nie skończyłem chociaż.
Sygo,
Dzięki @Sygo. Rozwidliłem i poprawiłem twoją treść. W rzeczywistości nigdy nie popełniłem danych za pomocą git (nie mówiąc już o gistubie githuba) i nie mogę wymyślić, jak zaproponować Ci połączenie go z powrotem (wydaje mi się, że to dlatego, że gist są zbyt uproszczone).
Adam Katz
Podejrzewam, że nie możesz, bo to istota, a nie właściwe repozytorium. Jednak sprawdziłem twój widelec i zdecydowanie wypróbowałem twoją wersję. Jestem ciekawy, jak zmieni się ten
zrzut heksowy
11

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: wprowadź opis zdjęcia tutaj

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'
Michael Durrant
źródło
1
Kolory są dostępne lsw systemie OS X, ale można to zrobić za pomocą export CLICOLOR=1.
ThomasW
3
@ThomasW, ale nie na Linuksie :-p Facet używa obu.
Jimmy Kane
1
Niemniej jednak ThomasW słusznie wskazuje, że odpowiedź jest błędna, mówiąc, że kolory nie są dostępne lsw systemie MacOS 10. Odpowiedź jest również błędna, ponieważ ciągi znaków tutaj są w rzeczywistości błędne. Nie prawidłowo równowagi \[i\] , i spowodowały problemy dla co najmniej jednej osoby kopiowania Ta odpowiedź .
JdeBP,
9

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

wersja demonstracyjna bash

Adam Katz
źródło
1
Głosowanie za zrzut ekranu
Green
Moja PSWD()funkcja była kompatybilna z POSIX, ale jest o wiele łatwiejsza dzięki obsłudze podciągów bash / zsh. Zobacz wersję 6 dla wersji POSIX, która zawiera wiele znaków zapytania i w ogóle nie można jej było dostosować do szerokości terminala. Nie zaktualizowałem zrzutu ekranu, ale to tylko niewielka zmiana przy szerokości 80 znaków.
Adam Katz
CLICOLOR=1nie działa dla mnie z FREEBSD 11.2
Simon C.
1
@SimonC. - Być może korzystasz z narzędzi GNU w systemie FreeBSD, a nie BSD. CLICOLOR=1 lspowinien robić to samo, co ls -Gprzy użyciu BSD ( ls -gna starszych BSD). Jeśli ls --colordziała (bez błędu), używasz lspolecenia GNU i $CLICOLORjest ignorowany.
Adam Katz
1
@SimonC. - Musisz faktycznie załadować swój, ~/.bashrcaby zmiany odniosły skutek. Albo uruchomić source ~/.bashrclub rozpocząć nową sesję bash (uruchomienia terminala lub uruchomić bash).
Adam Katz
8

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
Stefan Lasiewski
źródło
1
Lub jeśli chcesz korzystać z ZSH, monit Phila Golda na aperiodic.net/phil/prompt jest dziełem sztuki.
tsvallender,
5

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

przykład 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

nachoparker
źródło
2
Witaj, jak tworzysz flagi dla szybkiej ścieżki? Wspominam o prostokątnych prętach z trójkątnymi końcami Dzięki
Artur Vieira
czy to działa również w terminalu Ubuntu GNU?
helle
lnav jest również doskonałym narzędziem do wyświetlania pokolorowanych plików dziennika
Cyril Chaboisseau
4

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!

wprowadź opis zdjęcia tutaj


źródło
2
Gdybym mógł, głosowałbym za propozycją Oh-My-ZSH. Jako inżynier systemów, który intensywnie pracuje w Terminalu i jako ktoś, kto próbował zaadaptować zsh / oh-my-zsh do mojego przepływu pracy, mogę szczerze powiedzieć, że nigdy nie poleciłbym ZSH komukolwiek. Jasne, możesz dowiązać zsh do pliku o nazwie innej powłoki i emulować tę powłokę, ale kiedy to zrobisz, nie czyta ona twojego .bashrc, .bash_profile itp. Nie możesz również umieścić emulate bashswojego .zprofile lub .zshrc akta. Dla każdego, kto pracuje z zaawansowanymi funkcjami BASH, istnieje wiele subtelności, które cię ugryzą. BASH to lepszy sh.
Charles Addis,
2
Jedyną rzeczą, którą ZSH ma po wyjęciu z pudełka, która jest lepsza niż BASH, jest uzupełnianie poleceń, ale nawet to jest programowalne w BASH. Być może ktoś, kto nie korzysta z powłoki, z wyjątkiem sporadycznych, przyziemnych zadań, powinien przyjąć ZSH, ale to nie dla każdego, kto musi intensywnie korzystać z powłoki. =~operator może cię ugryźć, drogę ZSH obsługuje macierze może cię ugryźć, itd. Po użyciu zsh / Oh-my-zsh przez około 9 miesięcy miałem dosyć. Używałem niestandardowego motywu, który sam napisałem, przeniosłem go do BASH i napisałem własną linię poleceń git i nigdy nie oglądałem się za siebie. Teraz już nie martwię się o przenośność
Charles Addis,
1
„ma jedną z najpotężniejszych funkcji konsoli, jakie widziałem. Jedną z nich jest wybór motywu dla twojego terminala”.
Jonathan Hartley,
@JonathanHartley, twój komentarz wygląda tak, jakbyś pozostawił go niekompletny. ?
Wildcard,
2
Dziękuję za troskę, ale mój komentarz mówi wszystko, co chciałem powiedzieć.
Jonathan Hartley,
4

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:

wyjście diff przesyłane 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
Jonathan Hartley
źródło
1
W .bashrcprzykładzie brakuje finału fii można go przekonwertować na polecenie type colordiff &> /dev/null && alias diff='colordiff'
jednowierszowe
3

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
Mischa Arefiev
źródło
Podaj swoją powłokę. Jedynym znacznikiem specyficznym dla powłoki jest bash , ale czuję, że twój kod nie jest bash.
manatwork
@manatwork: przepraszam, zapomniałem wspomnieć, że to był Zsh. Zaktualizowano mój post.
Mischa Arefiev
3

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'
Bananguin
źródło
3

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.

Sildoreth
źródło
2

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: wprowadź opis zdjęcia tutaj

Wodnik Moc
źródło
2

Ś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

Niekolorowane wyjście niektórych unittestów Pythona

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

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

Kolorowy wynik niektórych Pythona

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.

Jonathan Hartley
źródło
1

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.

użytkownik3132194
źródło
0

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

if [ "$TERM" = xterm ]; then TERM=xterm-256color; fi
doesnt_matter
źródło
0

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

  1. znajdź odpowiedni schemat kolorów i użyj go. Schemat, którego używam: schemat, którego używam
ZhaoGang
źródło
Korzystając z linków do zewnętrznego źródła, należy sprawdzić część „Podaj kontekst dla linków” ( cytuj
Gert van den Berg
0

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.

TimWirtjes
źródło
0

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:

wprowadź opis zdjęcia tutaj

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 .

jamadagni
źródło