Coloriser votre terminal et votre environnement Shell?
Je passe la plupart de mon temps à travailler dans des environnements Unix et à utiliser des émulateurs de terminaux. J'essaie d'utiliser la couleur sur la ligne de commande, car la couleur rend la sortie plus utile et intuitive.
Quelles options existent pour ajouter de la couleur à mon environnement de terminal? Quelles astuces utilisez-vous? Quels pièges avez-vous rencontrés?
Malheureusement, la prise en charge de la couleur varie en fonction du type de terminal, du système d'exploitation, du paramètre TERM, de l'utilitaire, des implémentations de buggy, etc.
Voici quelques conseils de ma configuration, après beaucoup d'expérimentation:
- J'ai tendance à définir
TERM=xterm-color, qui est pris en charge sur la plupart des hôtes (mais pas tous). - Je travaille sur plusieurs hôtes différents, différentes versions de système d'exploitation, etc. J'utilise tout de macOS X, Ubuntu Linux, RHEL/CentOS/Scientific Linux et FreeBSD. J'essaie de garder les choses simples et génériques, si possible.
- Je fais beaucoup de travail en utilisant GNU
screen, ce qui ajoute une autre couche de plaisir. - De nombreux systèmes d'exploitation définissent des choses comme
dircolorset par défaut, et je ne veux pas le modifier sur une centaine d'hôtes différents. J'essaie donc de m'en tenir aux valeurs par défaut. Au lieu de cela, je modifie la configuration des couleurs de mon terminal. Utilisez la couleur pour certaines commandes Unix (
ls,grep,less,vim) et Bash Prompt . Ces commandes semblent utiliser le standard " séquences d'échappement ANSI ". Par exemple:alias less='less --RAW-CONTROL-CHARS' export LS_OPTS='--color=auto' alias ls='ls ${LS_OPTS}'
Je posterai mon .bashrc et répondre à ma propre question Jeopardy Style.
Voici deux ou trois choses que vous pouvez faire:
Éditeurs + Code
De nombreux éditeurs prennent en charge la coloration syntaxique. vim et emacs l'ont par défaut. Vous pouvez également l'activer sous nano .
Vous pouvez également mettre en évidence le code de coloration syntaxique sur le terminal en utilisant Pygments comme outil de ligne de commande.
grep grep --color=auto met en surbrillance tous les matchs. Vous pouvez aussi utiliser export GREP_OPTIONS='--color=auto' pour le rendre persistant sans alias. Si tu utilises --color=always, ça va tiliser la couleur même lors de la tuyauterie , ce qui confond les choses.
ls
ls --color=always
Couleurs spécifiées par:
export LS_COLORS='rs=0:di=01;34:ln=01;36:mh=00:pi=40;33'
(indice: dircolors peut être utile)
PS1
Vous pouvez configurer votre PS1 (Shell Prompt) pour utiliser des couleurs. Par exemple:
PS1='\e[33;1m\u@\h: \e[31m\W\e[0m\$ '
Produira une PS1 comme:
[jaune] lucas @ ubuntu: [rouge] ~ [normal] $
Vous pouvez devenir vraiment créatif avec cela. Comme idée:
PS1='\e[s\e[0;0H\e[1;33m\h \t\n\e[1;32mThis is my computer\e[u[\u@\h: \w]\$ '
Met une barre en haut de votre terminal avec des informations aléatoires. (Pour de meilleurs résultats, utilisez également alias clear="echo -e '\e[2J\n\n'".)
Se débarrasser des séquences d'échappement
Si quelque chose est bloqué en sortie de couleur alors que vous ne le souhaitez pas, j'utilise cette ligne sed pour supprimer les séquences d'échappement:
sed "s/\[^[[0-9;]*[a-zA-Z]//gi"
Si vous voulez une expérience plus authentique, vous pouvez également vous débarrasser des lignes commençant par \e[8m, qui demande au terminal de masquer le texte. (Pas largement pris en charge.)
sed "s/^\[^[8m.*$//gi"
Notez également que ces ^ [s doivent être réels, littéraux ^ [s. Vous pouvez les saisir en appuyant sur ^ V ^ [en bash, c'est-à-dire Ctrl + V, Ctrl + [.
J'utilise également:
export TERM=xterm-color
export GREP_OPTIONS='--color=auto' GREP_COLOR='1;32'
export CLICOLOR=1
export LSCOLORS=ExFxCxDxBxegedabagacad
Et si vous aimez coloriser votre invite, des variables de couleur définies peuvent être utiles:
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'
Et puis mon invite est quelque chose comme ceci:
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) appelle un script python dans mon ~/sbin qui affiche les informations de contrôle de version sur le chemin actuel. Il inclut la prise en charge de Mercurial, Git, Svn, Cvs, etc. L'auteur de le script a le source ici .
C'est le source complète de ma configuration d'invite:
grep et ls ont déjà été mentionnés, si vous voulez beaucoup plus de couleurs, vérifiez Generic Coloriser , son but initial était de coloriser les fichiers journaux, mais tout de suite il colorise également ping, traceroute, gcc, make, netstat, diff, last, ldap et cvs.
Il est facilement étendu si vous connaissez les expressions rationnelles. J'ai ajouté ps et nmap à la liste (si vous entrez dans grc je serai plus qu'heureux de partager les fichiers .conf pour ces deux outils)
(Btw, pour l'installer via synaptic, pacman, et de même vous pourriez avoir plus de chance en recherchant "grc")
J'ai perfectionné mon .bashrc au fil des ans pour travailler sur OSX et Ubuntu.
Je l'ai également réduit en taille à 28 lignes avec des déclarations d'état compactes.
Avec elle, mon invite PS1 ressemble à: 
avec l'heure en rouge, nom d'utilisateur en vert, nom de la machine en bleu clair, pwd en bleu foncé et branche git en jaune.
Fonctionnalité de mon invite PS1:
- montre git branch!
- les longs chemins de répertoire (plus de 6 éléments) sont "coupés" pour afficher les 3 premiers et 3 derniers répertoires avec
_entre-temps (c'est lepwd sedpartie de LOCATION). - retour chariot à la fin pour que l'invite soit toujours à gauche!
Les lignes pertinentes de mon .bashrc les fichiers sont:
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\]>'
Pour les ls avec des couleurs lorsqu'ils sont disponibles et aucune erreur dans le cas contraire (c'est-à-dire OSX):
ls --color=al > /dev/null 2>&1 && alias ls='ls -F --color=al' || alias ls='ls -G'
Couleurs des pages de manuel ( plus de détails ):
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 -; }
Couleurs pour grep (1;32 est vert vif, voir les autres articles ici pour d'autres couleurs):
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'
Plus de couleurs pour 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
Installez grc ( Generic Colouriser ) et ajoutez-le à vos alias:
# 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
}
Couleurs pour diff : Trop de contenu pour une fonction, utilisez un script et alias-le dans votre fichier rc (inutile si vous avez installé 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;
Couleurs pour Invite 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
Définissez une invite en gras/coloré. De cyberciti.biz et le 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 \$ "
J'ai également réussi à trouver des paramètres de couleur qui sont largement pris en charge, et qui n'impriment pas les caractères engloutis dans les environnements plus anciens (même FreeBSD4!), Et semble fonctionner correctement si TERM = vt100, xterm, xterm-color. (Pour la plupart). De mon .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
Il existe un bon outil pour configurer vos couleurs pour la commande ls - http://geoff.greer.fm/lscolors/
Des choses qui n'ont pas déjà été dites ici:
Pour coloriser la sortie de vos compilations avec gcc, il y a colorgcc par Johannes Schlüter
Pour coloriser les journaux, il y a multitail
Pour coloriser n'importe quelle stdout, j'ai mis en place xcol
Je les utilise personnellement depuis l'outil 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
J'utilise ces variables dans mes scripts comme ça
echo "${red}hello ${yellow}this is ${green}coloured${normal}"
J'aime aussi cette petite fonction colouredcho (trouvée sur 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
Désolé, pas autorisé à publier plus de liens
Je vous suggère de vérifier ZSH et son plugin oh-my-zsh qui possède l'une des fonctionnalités de console les plus puissantes que j'ai vues . L'un d'eux est le choix du thème pour votre terminal. Ceci est un exemple de mon thème ... En tty les couleurs ne sont pas si chaudes mais elles sont les mêmes que sur cette photo ... De toute façon vous allez l'adorer!
Pour visualiser la sortie diff en couleur, utilisez colordiff .
Sudo apt-get install colordiff
Canalisez n'importe quelle sortie au format diff dans colordiff:
Cela inclut certains des formats alternatifs de diff, comme -y (cote à cote.)
Alternativement, si elle est invoquée de façon autonome (sans rien y ajouter), elle agit comme un wrapper autour de 'diff' et colore la sortie. Par conséquent, j'ai ceci dans mon .bashrc, à alias "diff" à colordiff.
# if colordiff is installed, use it
if type colordiff &>/dev/null ; then
alias diff=colordiff
Pour définir l'invite, je l'ai dans mon fichier .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
Cela me donne une invite qui ressemble à ceci:
user@Host(bash): ~/bin >
Le répertoire de travail est en vert. Et le nom d'utilisateur est en gras et cyan, sauf si j'ai exécuté le shell avec Sudo, auquel cas le nom d'utilisateur ("root") s'affiche en gras et en rouge.
Personnellement, j'aime vraiment avoir les caractères de contrôle de mise en forme stockés dans des variables, car cela facilite la lecture du code pour définir l'invite. Cela facilite également la modification de l'invite .
La raison pour laquelle j'utilise tput est qu'il est censé être plus universellement pris en charge que l'étrange 033[01;31m\] séquences. De plus, en prime, si vous faites echo $PS1 à l'invite, vous verrez l'invite brute avec couleurs au lieu de ces séquences de contrôle inintelligibles.
Une décoration de texte (en gras) pour différencier facilement le shell racine et non root. Pour Zsh:
if test $UID = 0
then PS1="%B${PS1}%b "
fi
Pour Bash:
if test $UID = 0
then PS1="\033[1m${PS1}\033[0m"
fi
Je me demandais juste la même chose. J'ai ma propre approche, mais je cherche des alternatives.
J'écris des wrappers bash autour des appels de programme et je dirige leur sortie par sed. Ce que j'aime dans sed, c'est qu'il modifiera et fera écho à chaque ligne immédiatement => pas beaucoup de tampon. Cependant, je n'aime pas que pour chaque appel à un programme encapsulé, le code sed soit analysé et compilé.
Par exemple, voici ce que je fais pour colorer la sortie de 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'
Vous pouvez utiliser mon cf pour la coloration des noms de fichiers sur la ligne de commande, c'est un petit coloriseur rapide basé sur awk qui fonctionne via des tuyaux - colorant les noms de fichiers dans Truecolor sRGB.
Il a une configuration par défaut aux couleurs vives et contrairement à ls, il ne souffre pas d'une pénalité de performance pour l'ajout de nouvelles couleurs. (ls doit balayer la chaîne LS_COLORS entière pour chaque échec).
https://github.com/AdamDanischewski/cf
Je trouve Solarized utile. C'est un projet soigné avec des couleurs uniformes pour de nombreuses applications.
http://ethanschoonover.com/solarizedhttps://github.com/altercation/solarized
Un excellent outil à usage général Python pour colorer la sortie des commandes est ' colout '
Vous lui donnez une expression régulière avec N groupes, suivie d'une liste de N couleurs séparées par des virgules. Tout texte correspondant à un groupe sera affiché dans la couleur correspondante.
Ainsi, par exemple, si vous regardez une sortie de test:
python -m unittest discover -v
alors vous pouvez l'embellir avec:
python -m unittest discover -v 2>&1 | colout '(.*ERROR$)|(.*FAIL$)|(\(.*\))' red,yellow,black bold
Voyez comment mon expression régulière a trois groupes (les parenthèses) suivis de trois couleurs (et éventuellement trois styles, mais j'ai utilisé un raccourci pour définir toutes les couleurs en gras, donc le groupe 'noir', qui correspond au texte entre crochets) , apparaît en gris foncé.)
Notez également comment j'ai dû ajouter 2>&1 à la fin de l'invocation Python, car la sortie de unittest est sur stderr, donc je l'ai transférée vers stdout pour pouvoir la rediriger vers colout.
C'est généralement si facile à utiliser que je me retrouve souvent à créer de nouvelles invocations de colout à la volée et à les réutiliser ou à les modifier à partir de mon historique de ligne de commande.
Le seul inconvénient est qu'il s'agit d'un package Python, pas un exécutable autonome, vous devez donc l'installer à l'aide de pip ou Sudo python setup.py install.
Vous pouvez également essayer un projet qui aide à coloriser la sortie des scripts, son nom ScriptEchoColor à la forge source: 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
Les couleurs automatiques sont configurables.
Voici un exemple fait avec: 
J'utilise wrapper de couleur .
cw est un wrapper de couleur ANSI en temps réel non intrusif pour les commandes communes basées sur Unix sur GNU/Linux. cw est conçu pour simuler l'environnement des commandes en cours d'exécution, de sorte que si une personne tape "du", "df", "ping", etc. dans son Shell, elle colorera automatiquement la sortie en temps réel selon une définition fichier contenant le format de couleur souhaité. cw prend en charge la coloration des correspondances génériques, la coloration par jetons, les en-têtes/pieds de page, la coloration des scénarios de cas, la coloration des définitions en fonction de la ligne de commande et comprend plus de 50 fichiers de définitions prédéfinis.
C'est presque transparent, mais une fois que j'ai trouvé que ps dans Shell interactif renvoie une sortie différente comparant ps dans un tuyau.
si vous voulez rendre votre vim coloré comme moi, je vous suggère de suivre deux étapes:
- apprenez à activer la fonctionnalité en suivant ce lien: activez la coloration syntaxique en surbrillance dans vi ou vim .
étapes clés du lien:
Modifiez le fichier ~/.vimrc en tapant la commande: vi ~/.vimrc
Ajoutez l'option suivante: syntaxe activée
Enregistrez et fermez le fichier
Testez-le en exécutant la commande vim: vim foo.sh
- trouvez un jeu de couleurs que vous aimez et utilisez-le. Le schéma que j'utilise: le schéma que j'utilise
Je voudrais humblement faire de la publicité ma publication récente de ta ou textattr , une bibliothèque et une commande- outil en ligne qui vise à faciliter l'ajout de couleurs et d'attributs pour embellir la sortie du terminal de votre programme en traduisant des spécifications lisibles par l'homme en codes d'échappement ANSI.
Par exemple:
echo "The Git repo $(ta yellow)${CUR_REPO}$(ta off) is $(ta green)up-to-date$(ta off)"
ou encore plus court:
echo "The Git repo $(ta y)${CUR_REPO}$(ta f) is $(ta g)up-to-date$(ta f)"
ou un remplaçant:
tawrite "The Git repo " @y ${CUR_REPO} @f " is " @g up-to-date @f "\n"
vous donnera quelque chose comme:
Actuellement, cette bibliothèque est utilisable à partir de quatre langues C, C++, D et Python en dehors de l'utilisation en ligne de commande de votre Shell préféré.
Notez qu'il ne colore pas automatiquement la sortie des autres programmes. Il s'agit plutôt d'un utilitaire pour vous aider à ne pas avoir à vous souvenir des codes abstraits. Il vous suffit d'utiliser les noms de couleurs évidents ou leurs noms faciles à mémoriser rgb cmyk w(hite) (of) f abréviations.
Pour plus de détails, visitez le dépôt textattr .
Pour Mac, vous pouvez utiliser ce qui suit comme spécifié ici
if [ "$TERM" = xterm ]; then TERM=xterm-256color; fi
Si bash est votre choix, je recommande oh-my-bash . Si zsh est votre choix, je recommande oh-my-zsh . Les deux prennent en charge la colorisation de votre terminal et une sortie différente.