Coloriser votre terminal et votre environnement shell?

Je passe le plus clair 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 erronées, etc.

Voici quelques conseils de ma configuration, après de nombreuses expérimentations:

1. J'ai tendance à définir TERM=xterm-color, qui est pris en charge sur la plupart des hôtes (mais pas tous).
2. Je travaille sur différents hôtes, différentes versions de systèmes d'exploitation, etc. J'utilise tout, de MacOS X à Ubuntu, RHEL / CentOS / Scientific Linux et FreeBSD. J'essaie de garder les choses simples et génériques, si possible.
3. Je fais un tas de travail avec GNU screen, ce qui ajoute une couche de plaisir supplémentaire.
4. De nombreux systèmes d'exploitation définissent des paramètres tels que dircolorset par défaut, et je ne veux pas modifier cela sur cent hôtes différents. J'essaie donc de rester avec les valeurs par défaut. Au lieu de cela, je modifie la configuration de la couleur de mon terminal.

5. Utilisez la couleur pour certains commandes Unix ( ls, grep, less, vim) et l' invite de Bash . Ces commandes semblent utiliser les " séquences d'échappement ANSI " standard . Par exemple:

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

Je vais poster mon .bashrcet répondre à ma propre question Jeopardy Style.

Voici deux choses que vous pouvez faire:

Editeurs + Code
De nombreux éditeurs ont un support de mise en évidence de la syntaxe. vimet l' emacsavoir sur par défaut. Vous pouvez également l' activer sousnano .

Vous pouvez également mettre en évidence la syntaxe du code sur le terminal en utilisant Pygments comme outil de ligne de commande.

grep
grep --color=auto met en évidence tous les matchs. Vous pouvez également utiliser export GREP_OPTIONS='--color=auto'pour le rendre persistant sans un alias. Si vous utilisez --color=always, il utilisera la couleur même lorsque 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: dircolorspeut être utile)

PS1
Vous pouvez configurer votre PS1 (invite du shell) pour utiliser des couleurs. Par exemple:

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

Produira une PS1 comme:

[yellow] lucas @ ubuntu: [rouge] ~ [normal] $

Vous pouvez être vraiment créatif avec ça. En tant qu'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 quand vous ne le voulez pas, j'utilise cette sedligne pour effacer les séquences d'échappement:

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

Si vous voulez une expérience plus authentique, vous pouvez également supprimer les lignes commençant par \e[8m, qui indique 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 aussi:

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 couleurs 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 ça:

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 des informations de contrôle de version concernant le chemin actuel. Cela inclut le support pour Mercurial, Git, Svn, Cvs, etc. L’auteur du script a la source ici .

Voici la source complète de ma configuration d'invite:

grepet lsont déjà été mentionné, si vous voulez beaucoup plus de couleurs consultez générique coloriser , son but initial était de coloriser logfiles, mais dès la sortie de la boîte , il colorise aussi ping, traceroute, gcc, make, netstat, diff, last, ldapet cvs.

Il est facilement étendu si vous connaissez les regex. J'ai ajouté pset nmapà la liste (si vous entrez dans cet article, grcje serai ravi de partager les fichiers .conf de ces deux outils)

(Btw, pour l'installer via synaptic, pacmanet vous aurez peut-être plus de chance en recherchant "grc")

J'ai perfectionné mon .bashrc au fil des ans pour travailler à la fois sur OSX et Ubuntu.
J'ai également réduit sa taille à 28 lignes avec des instructions de condition compactes.
Avec cela, mon invite PS1 ressemble à:

avec l'heure en rouge, le nom d'utilisateur en vert, le nom de la machine en bleu clair, le pwd en bleu plus foncé et la branche git en jaune.

Fonctionnalité de mon invite PS1:

• montre la branche git!
• Les chemins de répertoires longs (plus de 6 éléments) sont "ajustés" pour afficher les 3 premiers et 3 derniers répertoires avec _entre alors (c'est la pwd sedpartie de LOCATION).
• retour de chariot à la fin pour que l'invite soit toujours à gauche!

Les lignes pertinentes de mon .bashrcdossier 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 ls avec des couleurs lorsqu'elles sont disponibles et sans erreur si ce n'est pas le cas (c.-à-d. OSX):

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

Couleurs pour les pages de manuel ( plus de détail ):

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;32vert 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 aliastez-le dans votre fichier rc (inutile si vous l'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 l' 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éfinir 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 largement pris en charge, qui n'impriment pas les caractères gobbledygook dans les environnements plus anciens (même FreeBSD4!), Et semblent 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 de Johannes Schlüter

Pour colorier les logs, il y a multitail

Pour colorier une sortie, je mets xcol

Personnellement, je les utilise 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 si

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

J'aime aussi cette petite fonction coloredEcho (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é à poster plus de liens

Je vous suggère de regarder 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 de choisir un thème pour votre terminal. C’est un exemple de mon thème ... Dans les couleurs, les couleurs ne sont pas aussi chaudes mais elles sont identiques à celles de cette image ... De toute façon, vous allez adorer!

Pour visualiser les sorties en couleur, utilisez colordiff .

sudo apt-get install colordiff

Pipe n'importe quelle sortie de format diff dans colordiff:

Cela inclut certains des formats de substitution de diff, comme -y(côte à côte).

Alternativement, si elle est appelée autonome (sans rien de particulier), elle agit comme une enveloppe autour de 'diff' et colore le résultat. C'est pourquoi j'ai ceci dans mon .bashrc, alias 'diff' pour colordiff.

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

Certaines décorations de texte (en gras) permettent de différencier facilement les coques sans racine. 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 simplement 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 transmets leur sortie sed. Ce que j’aime, sedc’est que cela modifie et renvoie immédiatement chaque ligne => pas beaucoup de mise en mémoire tampon. Cependant, je n'aime pas que pour chaque appel à un programme intégré, le sedcode 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'

Pour définir l'invite, j'ai cela 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. Dans ce cas, le nom d'utilisateur ("racine") est affiché en gras et en rouge.

Personnellement, j’aime vraiment beaucoup que les caractères de contrôle de formatage soient stockés dans des variables, car cela facilite la lecture du code permettant de définir l’invite. Il fait également l' édition de l'invite beaucoup plus facile.

La raison pour laquelle j’utilise, tputc’est qu’elle est supposée être plus universellement prise en charge que les 033[01;31m\]séquences étranges . En outre, en prime, si vous le faites echo $PS1à l'invite, vous verrez l'invite brute avec des couleurs au lieu de ces séquences de contrôle inintelligibles.

Vous pouvez aussi essayer un projet qui aide à colorier les scripts, son scriptEchoColor à la 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.

Ceci est un exemple fait avec elle:

' Colout ' est un excellent outil Python à usage général pour colorer la sortie des commandes .

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.

Donc, par exemple, si vous regardez une sortie de test:

python -m unittest discover -v

Ensuite, vous pouvez le personnaliser avec:

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

Voyez comment ma regex a trois groupes (la parenthèse) suivis de trois couleurs (et éventuellement de trois styles, mais j'ai utilisé un raccourci pour définir toutes les couleurs sur "gras", donc le groupe "noir", qui correspond au texte entre crochets. , sort en gris foncé.)

Notez aussi comment j'ai dû ajouter 2>&1à la fin de l'invocation Python, parce que la sortie de unittest est sur stderr, je l'ai donc transférée sur stdout afin de pouvoir la diriger 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, et non d’un exécutable autonome. Vous devez donc l’installer à l’aide de pip, ou sudo python setup.py install.

Je trouve que Solarized est utile. C'est un projet soigné avec des couleurs uniformes pour de nombreuses applications.

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

J'utilise un wrapper de couleur .

cw est un wrapper couleur ANSI en temps réel non intrusif destiné aux commandes communes basées sur Unix sur GNU / linux. cw est conçu pour simuler l'environnement des commandes en cours d'exécution. Ainsi, si une personne tape 'du', 'df', 'ping', etc. dans son shell, elle colorera automatiquement la sortie en temps réel conformément à une définition. fichier contenant le format de couleur souhaité. cw prend en charge la coloration de correspondance avec caractères génériques, la coloration en jetons, les en-têtes / pieds de page, la coloration de scénarios, la coloration de définition dépendante de la ligne de commande et comprend plus de 50 fichiers de définition prédéfinis.

Il est presque transparent, mais une fois, j’ai trouvé que ps dans un shell interactif renvoie un résultat différent en comparant ps dans un tube.

Pour Mac, vous pouvez utiliser ce qui suit comme spécifié ici

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

si vous voulez rendre votre vimcouleur juste comme moi, je vous suggère de suivre deux étapes:

1. Apprenez à activer la fonctionnalité en suivant ce lien: activez la coloration syntaxique dans vi ou vim .

étapes clés du lien:

1. Editez le fichier ~ / .vimrc en tapant la commande: vi ~ / .vimrc

2. Ajoutez l'option suivante: syntax on

3. Enregistrez et fermez le fichier

4. Testez-le en exécutant la commande vim : vim foo.sh

2. trouvez un jeu de couleurs que vous aimez et utilisez-le. Le schéma que j'utilise: le schéma que j'utilise

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.

Je voudrais annoncer humblement ma récente publication de taou textattr , une bibliothèque et un outil de ligne de commande qui vise à faire ajouter de la couleur et les attributs pour embellir la borne de sortie de votre programme plus facile en traduisant les spécifications lisibles par l' homme dans les 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 langages C, C ++, D et Python, à l’exception de l’utilisation en ligne de commande de votre shell préféré.

Notez que cela ne colore pas automatiquement la sortie des autres programmes. C'est plutôt un utilitaire pour vous aider à ne pas avoir à vous souvenir des codes abstrus. Vous devez uniquement utiliser les noms de couleurs évidents ou leurs abréviations rgb cmyk w (hite) (of) f faciles à retenir .

Pour plus de détails, visitez le repo textattr .