it-swarm-eu.dev

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:

  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 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.
  3. Je fais beaucoup de travail en utilisant GNU screen, ce qui ajoute une autre couche de plaisir.
  4. De nombreux systèmes d'exploitation définissent des choses comme dircolors et 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.
  5. 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.

267
Stefan Lasiewski

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\[email protected]\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[\[email protected]\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 + VCtrl + [.

123
Lucas Jones

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 .

Bash Prompt screenshot

C'est le source complète de ma configuration d'invite:

86
Kris

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

18
Sygo

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 à: enter image description here

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 le pwd sed partie 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'
12
Michael Durrant

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") \
      "[email protected]"
}
function man() { _colorman man "[email protected]"; }
function perldoc() { command perldoc -n less "[email protected]" |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 "[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

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 "[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
}

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

demo of bash Prompt

9
Adam Katz

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="\[email protected]\[$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
8
Stefan Lasiewski

Il existe un bon outil pour configurer vos couleurs pour la commande ls - http://geoff.greer.fm/lscolors/

5
Rob Cowell

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

xcol example

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

5
nachoparker

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!

enter image description here

4
user92622

Pour visualiser la sortie diff en couleur, utilisez colordiff .

Sudo apt-get install colordiff

Canalisez n'importe quelle sortie au format diff dans colordiff:

output of diff piped into 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
4
Jonathan Hartley

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:

[email protected](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.

3
Sildoreth

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
3
Mischa Arefiev

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} [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'
3
Bananguin

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

cf usage

cf screenshot

2
A.Danischewski

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

2
Vamsi

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

Uncolored output of some Python unittests

alors vous pouvez l'embellir avec:

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

Colored output of some Python unittests

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.

2
Jonathan Hartley

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: enter image description here

2
Aquarius Power

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.

1
user3132194

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

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

étapes clés du lien:

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

  2. Ajoutez l'option suivante: syntaxe activée

  3. Enregistrez et fermez le fichier

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

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

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:

enter image description here

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 .

0
jamadagni

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

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

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.

0
TimWirtjes