Zbarvení prostředí terminálu a prostředí Shell?

Také používám:

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

A pokud se vám líbí zbarvení Prompt, mohou být užitečné definované barevné variace:

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 pak je můj Prompt něco podobného:

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) volá skript python v mém ~/sbin, který tiskne informace o verzi pro aktuální cestu. Zahrnuje podporu pro Mercurial, Git, Svn, Cvs atd.) skript má zde zdroj .

Toto je plný zdroj mé konfigurace Prompt:

grep a ls již byly zmíněny, pokud chcete mnohem více barev, podívejte se Generic Coloriser , jeho původním účelem bylo zbarvení logfiles, ale přímo z box také zbarví ping, traceroute, gcc, make, netstat, diff, last, ldap a cvs.

Je to snadno rozšířitelné, pokud znáte regexy. Do seznamu jsem přidal ps a nmap (pokud se dostanete do grc budu víc než rád sdílen .conf soubory pro tyto dva nástroje)

(Btw, nainstalujte jej pomocí synaptic, pacman a podobně byste mohli mít štěstí při hledání výrazu grc)

V průběhu let jsem honil svůj .bashrc, abych pracoval na OSX i Ubuntu.
Také jsem ji zmenšil na 28 řádků s kompaktními podmínkami.
S tím můj PS1 Prompt vypadá takto: 

s časem v červené barvě, uživatelské jméno v zelené barvě, název stroje ve světle modré, pwd v tmavší modré a git větev ve žluté.

Funkce mé výzvy PS1:

• ukazuje git větev!
• dlouhé cesty k adresářům (více než 6 prvků) jsou „oříznuty“, aby zobrazovaly první 3 a spodní 3 adresáře s _ mezi tím (to je pwd sed část LOCATION).
• návrat vozíku na konci, takže Prompt je vždy vlevo!

Relevantní řádky z mého .bashrc file jsou:

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

Pro ls s barvami, pokud jsou k dispozici, a bez chyb, pokud nejsou (tj. OSX):

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

Barvy pro manuálové stránky ( více podrobností ):

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

Barvy pro grep (1;32 je jasně zelená, další barvy naleznete zde):

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'

Více barev pro 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

Nainstalujte grc ( Generic Colouriser ) a přidejte jej do aliasu:

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

Barvy pro diff : Příliš mnoho obsahu pro funkci, použijte skript a aliasy v souboru rc (zbytečné, pokud jste nainstalovali 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;

Barvy pro 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

Nastavte tučné/barevné Prompt. Od cyberciti.biz a 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 \$ "

Také se mi podařilo najít nastavení barev, která jsou široce podporována a která netisknou znaky gobbledygook ve starších prostředích (i FreeBSD4!), A zdá se, že funguje dobře, pokud TERM = vt100, xterm, xterm-color. (Z větší části). Z mého .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

Existuje dobrý nástroj pro nastavení barev pro příkaz ls - http://geoff.greer.fm/lscolors/

Věci, které zde ještě nebyly řečeny:

Pro vybarvení výstupu kompilací pomocí gcc je zde colorgcc od Johannes Schlüter

K obarvení protokolů je k dispozici vícesměrná komunikace

Abych vybarvil jakýkoli stdout, dal jsem dohromady xcol

Osobně je používám z nástroje 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

Tyto proměnné používám ve svých skriptech

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

Líbí se mi také tato malá funkce coloredEcho (nalezená na 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

Litujeme, není dovoleno zveřejňovat další odkazy

Doporučuji vyzkoušet ZSH a jeho plugin oh-my-zsh , který má jednu z nejvýkonnějších funkcí konzole, kterou jsem viděl . Jedním z nich je výběr tématu pro váš terminál. Toto je příklad mého tématu ... Ve ttych barvách nejsou tak teplé, ale jsou stejné jako na tomto obrázku ... Ať už se vám bude líbit!

Pro zobrazení barevného výstupu rozdílu použijte colordiff .

Sudo apt-get install colordiff

Potrubí libovolného výstupu ve formátu diff do kolordiffu:

To zahrnuje některé alternativní formáty diffu, například -y (vedle sebe.)

Alternativně, pokud je vyvolán samostatný (bez toho, aby do něj bylo něco vloženo), pak funguje jako obal kolem 'diff' a zbarví výstup. Tohle mám v mém .bashrc, aby se alias „diff“ na colordiff.

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

Pro nastavení výzvy mám toto v mém souboru .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 mi dává výzvu, která vypadá takto:

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

Pracovní adresář je zelený. A uživatelské jméno je tučné a azurové, pokud jsem nespustil Shell s Sudo, v tomto případě se uživatelské jméno ("root") zobrazuje tučně a červeně.

Osobně se mi líbí, když mají řídicí znaky formátování uložené v proměnných, protože to usnadňuje čtení kódu pro nastavení výzvy. Rovněž usnadňuje úpravy Prompt .

Důvod, proč používám tput, je ten, že by měl být více univerzálně podporován než divný 033[01;31m\] sekvence. Jako bonus navíc, pokud uděláte echo $PS1 Na výzvu uvidíte namísto těch nesrozumitelných kontrolních sekvencí surový Prompt s colours.

Některé textové dekorace (tučné) snadno rozlišit mezi kořenovým a nekořenovým Shellem. Pro Zsh:

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

Pro Bash:

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

Jen jsem přemýšlel o stejné věci. Mám svůj vlastní přístup, ale hledám alternativy.

Okolo programových volání píšu obálky bash a dávám jejich výstupy sed. Co se mi na sed líbí, je to, že to okamžitě změní a ozve každý řádek => není moc vyrovnávací paměti. Nelíbí se mi však, že pro každé volání zabaleného programu je kód sed analyzován a kompilován.

Například to je to, co dělám pro vybarvení výstupu 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} [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'

Můžete použít můj cf pro barvení názvů souborů na příkazovém řádku, je to rychlý malý awk-založený colorizer, který pracuje prostřednictvím potrubí - barvení názvů souborů v Truecolor sRGB.

Má pestrobarevnou výchozí konfiguraci a na rozdíl od toho netrpí pokutou za přidávání nových barev. (Pro každou slečnu je nutné prohledat celý řetězec LS_COLORS).

https://github.com/AdamDanischewski/cf

Považuji Solarized za užitečnou. Je to elegantní projekt s jednotnými barvami pro mnoho aplikací.

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

Velkým univerzálním Pythonovým nástrojem pro barvení výstupu příkazů je ' colout '

Dejte mu regex se skupinami N, následovaný čárkami odděleným seznamem N barev. Text, který odpovídá skupině, bude zobrazen v odpovídající barvě.

Pokud se například díváte na nějaký testovací výstup:

python -m unittest discover -v

pak to můžete smrkovat:

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

Podívejte se, jak má můj regex tři skupiny (závorky) následované třemi barvami (a případně třemi styly, ale pomocí zkratky jsem nastavil všechny barvy na „tučné“, tedy na „černou“ skupinu, která odpovídá textu v závorkách) , vychází jako tmavě šedá.)

Všimněte si také, jak jsem musel přidat 2>&1 na konec vyvolání Python), protože výstup unittestu je na stderr, takže jsem jej přenesl do stdout, abych jej mohl přenést do coloru.

To se obecně používá tak snadno, že se často setkávám s vytvářením nových vyvolání zbarvení za běhu a jejich opakovaným používáním nebo úpravou z mé historie příkazového řádku.

Jedinou nevýhodou je, že je dodáván jako balíčekPython, nikoli samostatný spustitelný soubor, takže jej musíte nainstalovat pomocí pip nebo Sudo python setup.py install.

Můžete vyzkoušet projekt, který pomáhá také s výstupem zbarvení skriptů, s názvem ScriptEchoColor na zdrojovém kovárně: http://scriptechocolor.sourceforge.net/

příklad:

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

Automatické barvy jsou konfigurovatelné.

Toto je příklad s tím: 

Používám obálka barev .

cw je neobtěžující ANSI barevný obal v reálném čase pro běžné unixové příkazy na GNU/linux. cw je navržen tak, aby simuloval prostředí prováděných příkazů, takže pokud osoba ve svém shellu napíše „du“, „df“, „ping“ atd., bude automaticky definovat výstup v reálném čase podle definice soubor obsahující požadovaný barevný formát. cw má podporu pro obarvení zástupných znaků, tokenizované zbarvení, záhlaví/zápatí, obarvení scénářů, zbarvení definice závislé na příkazovém řádku a zahrnuje více než 50 předem vytvořených definičních souborů.

Je to téměř plynulé, ale jakmile jsem zjistil, že ps v interaktivním prostředí Shell vrací jiný výstup ve srovnání s psem v potrubí.

pokud chcete, aby váš barevný vim byl barevný stejně jako já, doporučuji postupovat dvěma kroky:

1. naučte se, jak tuto funkci zapnout, pomocí následujícího odkazu: zapněte zvýraznění barevné syntaxe ve vi nebo vim .

klíčové kroky v odkazu:

1. Upravte ~/.vimrc soubor zadáním příkazu: vi ~/.vimrc

2. Připojte následující možnost: syntaxe zapnuta

3. Uložte a zavřete soubor

4. Otestujte jej spuštěním příkazu vim: vim foo.sh

2. najděte barevné schéma, které se vám líbí, a použijte je. Schéma, kterou používám: schéma, které používám

Chtěl bych pokorně inzerovat moje nedávná publikace z ta nebo textattr, knihovnu a nástroj příkazového řádku, jehož cílem je přidání barev a Atributy pro zkrácení výstupů z terminálu vašeho programu tím, že převedou lidsky čitelné specifikace do únikových kódů ANSI.

Například:

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

nebo ještě kratší:

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

nebo alternativa:

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

vám dá něco jako:

V současné době je tato knihovna použitelná ze čtyř jazyků C, C++, D a Python kromě použití příkazového řádku z vašeho oblíbeného prostředí Shell).

Všimněte si, že automaticky nezbarví výstup žádných jiných programů. Je to spíše nástroj, který vám pomůže s tím, abyste si nemuseli pamatovat kódy abstruse. Stačí použít zřejmé názvy barev nebo jejich snadno zapamatovatelné rgb cmyk w(hite) (of) f zkratky.

Pro více informací navštivte textattr repo .

Pro Mac můžete použít následující, jak je uvedeno zde

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

Pokud je váš výběr bash, doporučuji oh-my-bash . Pokud si vyberete zsh, doporučuji oh-my-zsh . Oba podporují zbarvení vašeho terminálu a různé výstupy.