it-swarm-es.tech

¿Colorear su terminal y el entorno de Shell?

Paso la mayor parte de mi tiempo trabajando en entornos Unix y usando emuladores de terminal. Intento usar el color en la línea de comando, porque el color hace que la salida sea más útil e intuitiva.

¿Qué opciones existen para agregar color a mi entorno de terminal? ¿Qué trucos usas? ¿Qué escollos has encontrado?

Desafortunadamente, la compatibilidad con el color varía según el tipo de terminal, el sistema operativo, la configuración de TERM, la utilidad, las implementaciones con errores, etc.

Aquí hay algunos consejos de mi configuración, después de mucha experimentación:

  1. Tiendo a configurar TERM=xterm-color, que es compatible con la mayoría de los hosts (pero no con todos).
  2. Trabajo en varios hosts diferentes, diferentes versiones de SO, etc. Utilizo todo, desde macOS X, Ubuntu Linux, RHEL/CentOS/Scientific Linux y FreeBSD. Estoy tratando de mantener las cosas simples y genéricas, si es posible.
  3. Hago un montón de trabajo usando GNU screen, que agrega otra capa de diversión.
  4. Muchos sistemas operativos configuran cosas como dircolors y de forma predeterminada, y no quiero modificar esto en cientos de hosts diferentes. Así que trato de mantener los valores predeterminados. En cambio, modifico la configuración de color de mi terminal.
  5. Use el color para algunos comandos Unix (ls, grep, less, vim) y el Bash Prompt . Estos comandos parecen usar el estándar " secuencias de escape ANSI ". Por ejemplo:

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

Publicaré mi .bashrc y respondo mi propia pregunta Jeopardy Style.

267
Stefan Lasiewski

Aquí hay un par de cosas que puedes hacer:

Editores + Código
Muchos editores tienen soporte para resaltar la sintaxis. vim y emacs lo tienen activado por defecto. También puede habilitarlo en nano .

También puede sintaxis resaltar código en el terminal utilizando Pygments como herramienta de línea de comandos.

grep
grep --color=auto resalta todos los partidos. También puedes usar export GREP_OPTIONS='--color=auto' para que sea persistente sin un alias. Si utiliza --color=always, lo hará se color incluso cuando se canaliza , lo que confunde las cosas.

ls

ls --color=always

Colores especificados por:

export LS_COLORS='rs=0:di=01;34:ln=01;36:mh=00:pi=40;33'

(pista: dircolors puede ser útil)

PS1
Puede configurar su PS1 (Shell Prompt) para usar colores. Por ejemplo:

PS1='\e[33;1m\[email protected]\h: \e[31m\W\e[0m\$ '

Producirá una PS1 como:

[amarillo] lucas @ ubuntu: [rojo] ~ [normal] $

Puedes ser realmente creativo con esto. Como una idea:

PS1='\e[s\e[0;0H\e[1;33m\h    \t\n\e[1;32mThis is my computer\e[u[\[email protected]\h:  \w]\$ '

Pone una barra en la parte superior de su terminal con información aleatoria. (Para obtener los mejores resultados, también use alias clear="echo -e '\e[2J\n\n'".)

Deshacerse de las secuencias de escape

Si algo está atascado generando color cuando no lo desea, utilizo esta línea sed para quitar las secuencias de escape:

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

Si desea una experiencia más auténtica, también puede deshacerse de las líneas que comienzan con \e[8m, que indica al terminal que oculte el texto. (No es ampliamente compatible).

sed "s/^\[^[8m.*$//gi"

También tenga en cuenta que esos ^ [s deben ser reales, literales ^ [s. Puede escribirlos presionando ^ V ^ [en bash, es decir Ctrl + VCtrl + [.

123
Lucas Jones

Yo también uso:

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

Y si le gusta colorear su Prompt, los vars de color definidos pueden ser útiles:

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'

Y luego mi Aviso es algo como esto:

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) está llamando a un guión python en mi ~/sbin que imprime información de control de versión sobre la ruta actual. Incluye soporte para Mercurial, Git, Svn, Cvs, etc. El autor de el script tiene el fuente aquí .

Bash Prompt screenshot

Este es el fuente completa de mi configuración de solicitud:

86
Kris

grep y ls ya se han mencionado, si desea muchos más colores, consulte Coloriser genérico , su propósito inicial era colorear los archivos de registro, pero directamente también colorea ping, traceroute, gcc, make, netstat, diff, last, ldap y cvs.

Se extiende fácilmente si conoce expresiones regulares. He agregado ps y nmap a la lista (si ingresa a grc, estaré más que feliz de compartir los archivos .conf para esas dos herramientas)

(Por cierto, para instalarlo a través de synaptic, pacman, y por igual podría tener mejor suerte buscando "grc")

18
Sygo

He perfeccionado mi .bashrc a lo largo de los años para trabajar tanto en OSX como en Ubuntu.
También lo reduje en tamaño a 28 líneas con declaraciones de condición compactas.
Con esto, mi indicador de PS1 se ve así: enter image description here

con tiempo en rojo, nombre de usuario en verde, nombre de la máquina en azul claro, pwd en azul más oscuro y git branch en amarillo.

Característica de mi mensaje de PS1:

  • muestra git branch!
  • las rutas de directorio largas (más de 6 elementos) se 'recortan' para mostrar los directorios 3 y 3 superiores con _ entre entonces (esa es la pwd sed parte de LOCATION).
  • ¡retorno de carro al final para que Prompt esté siempre a la izquierda!

Las líneas relevantes de mi .bashrc archivo son:

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

Para ls con colores cuando están disponibles y sin errores cuando no (es decir, OSX):

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

Colores para páginas de manual ( más detalles ):

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

Colores para grep (1;32 es de color verde brillante, vea otras publicaciones aquí para otros colores):

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'

Más colores para 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

Instale grc ( Colouriser genérico ) y agréguelo a sus 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
}

Colores para diff : demasiado contenido para una función, use un script y alias en su archivo rc (innecesario si instaló 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;

Colores para indicador de 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

Establecer un indicador en negrita/color. De cyberciti.biz y el 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 \$ "

También he logrado encontrar configuraciones de color que son ampliamente compatibles y que no imprimen caracteres engominados en entornos antiguos (¡incluso FreeBSD4!), Y parece funcionar bien si TERM = vt100, xterm, xterm-color. (En la mayor parte). De mi .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

Hay una buena herramienta para configurar sus colores para el comando ls - http://geoff.greer.fm/lscolors/

5
Rob Cowell

Cosas que no se han dicho ya aquí:

Para colorear la salida de sus compilaciones con gcc, hay colorgcc de Johannes Schlüter

Para colorear los registros, hay multitail

Para colorear cualquier stdout, puse juntos xcol

xcol example

Yo personalmente los uso de la herramienta 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

Yo uso estas variables en mis scripts así

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

También me gusta esta pequeña función coloredEcho (que se encuentra en 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

Lo sentimos, no puedo publicar más enlaces

5
nachoparker

Le sugiero que revise ZSH y su complemento oh-my-zsh que tiene una de las características de consola más potentes que vi . Uno de ellos es elegir el tema para su terminal. Este es un ejemplo de mi tema ... En tty los colores no son tan cálidos, pero son los mismos que en esta imagen ... ¡De cualquier forma te encantará!

enter image description here

4
user92622

Para ver la salida de diferencias en color, use colordiff .

Sudo apt-get install colordiff

Canalice cualquier salida de formato diff en el colordiff:

output of diff piped into colordiff

Esto incluye algunos de los formatos alternativos de diff, como -y (lado a lado.)

Alternativamente, si se invoca de forma independiente (sin que se canalice nada), actúa como un contenedor alrededor de 'diff' y colorea la salida. Por lo tanto, tengo esto en mi .bashrc, alias 'diff' a colordiff.

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

Para configurar el indicador, tengo esto en mi archivo .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

Esto me da un mensaje que se parece a esto:

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

El directorio de trabajo está en verde. Y el nombre de usuario está en negrita y cian a menos que haya ejecutado el Shell con Sudo, en cuyo caso el nombre de usuario ("raíz") se muestra en negrita y rojo.

Personalmente, realmente me gusta tener los caracteres de control de formato almacenados en variables porque hace que leer el código para configurar el indicador sea más fácil. También facilita la edición del indicador mucho más fácil.

La razón por la que uso tput es porque se supone que es más universalmente compatible que el extraño 033[01;31m\] secuencias. Además, como un bono adicional, si lo haces echo $PS1 en la solicitud, verá la solicitud sin procesar con colores en lugar de esas secuencias de control ininteligibles.

3
Sildoreth

Alguna decoración de texto (negrita) para diferenciar fácilmente entre Shell raíz y no root. Para Zsh:

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

Para Bash:

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

Me preguntaba lo mismo. Tengo mi propio enfoque, pero estoy buscando alternativas.

Escribo bash wrappers alrededor de las llamadas al programa y canalizo su salida aunque sed. Lo que me gusta de sed es que modificará y hará eco de cada línea de inmediato => no hay mucho almacenamiento en búfer. Sin embargo, no me gusta que por cada llamada a un programa envuelto el código sed se analice y compile.

Por ejemplo, esto es lo que hago para colorear la salida 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

Puede usar mi cf para colorear nombres de archivos en la línea de comandos, es un pequeño y rápido colorizador basado en awk que funciona a través de tuberías: colorear nombres de archivos en Truecolor sRGB.

Tiene una configuración predeterminada de colores brillantes y, a diferencia de ls, no sufre una penalización de rendimiento por agregar nuevos colores. (ls debe escanear toda la cadena LS_COLORS para cada falta).

https://github.com/AdamDanischewski/cf

cf usage

cf screenshot

2
A.Danischewski

Me parece útil Solarized. Es un proyecto ordenado con colores uniformes para muchas aplicaciones.

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

2
Vamsi

Una gran herramienta de uso general Python para colorear la salida de comandos es ' colout '

Le da una expresión regular con N grupos, seguido de una lista de N colores separados por comas. Cualquier texto que coincida con un grupo se mostrará en el color correspondiente.

Entonces, por ejemplo, si estás viendo alguna salida de prueba:

python -m unittest discover -v

Uncolored output of some Python unittests

entonces puedes arreglarlo con:

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

Colored output of some Python unittests

Vea cómo mi expresión regular tiene tres grupos (el paréntesis) seguido de tres colores (y opcionalmente tres estilos, pero he usado una taquigrafía para establecer todos los colores en 'negrita', por lo que el grupo 'negro', que coincide con el texto entre paréntesis , sale como gris oscuro.)

Observe también cómo tuve que agregar 2>&1 al final de la invocación Python, porque el resultado de unittest está en stderr, así que lo transfirí a stdout para poder canalizarlo en colout.

Esto es generalmente tan fácil de usar que a menudo me encuentro creando nuevas invocaciones de colores sobre la marcha, y reutilizándolas o modificándolas desde mi historial de línea de comandos.

El único inconveniente es que viene como un paquete Python, no como un ejecutable independiente, por lo que debe instalarlo usando pip, o Sudo python setup.py install.

2
Jonathan Hartley

También puede probar un proyecto que ayude a colorear la salida de los scripts, se llama ScriptEchoColor en source forge: 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

Los colores automáticos son configurables.

Este es un ejemplo hecho con él: enter image description here

2
Aquarius Power

Yo uso envoltura de color .

cw es un contenedor de color ANSI no intrusivo en tiempo real para comandos comunes basados ​​en Unix en GNU/Linux. cw está diseñado para simular el entorno de los comandos que se ejecutan, de modo que si una persona escribe 'du', 'df', 'ping', etc. en su Shell, coloreará automáticamente la salida en tiempo real de acuerdo con una definición archivo que contiene el formato de color deseado. cw tiene soporte para colores de coincidencia de comodines, colores simbólicos, encabezados/pies de página, colores de escenarios de casos, colores de definición dependientes de la línea de comandos e incluye más de 50 archivos de definiciones prefabricados.

Es casi transparente, pero una vez que encontré que ps en Shell interactivo devuelve resultados diferentes comparando ps en una tubería.

1
user3132194

si desea que su vim sea tan colorida como yo, le sugiero que siga dos pasos:

  1. aprenda a activar la función siguiendo este enlace: active el resaltado de sintaxis de color en vi o vim .

pasos clave en el enlace:

  1. Edite el archivo ~/.vimrc escribiendo el comando: vi ~/.vimrc

  2. Agregue la siguiente opción: sintaxis en

  3. Guarde y cierre el archivo

  4. Pruébelo ejecutando el comando vim: vim foo.sh

  1. encuentre un esquema de color que le guste y úselo. El esquema que uso: el esquema que estoy usando
0
ZhaoGang

Me gustaría anunciar humildemente mi publicación reciente de ta o textattr , una biblioteca y comando- herramienta de línea que tiene como objetivo facilitar la adición de color y atributos para embellecer la salida del terminal de su programa al traducir las especificaciones legibles por humanos en códigos de escape ANSI.

Por ejemplo:

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

o el aún más corto:

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

o una alternativa:

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

te dará algo como:

enter image description here

Actualmente, esta biblioteca se puede usar desde cuatro idiomas C, C++, D y Python aparte del uso de la línea de comandos de su Shell favorito.

Tenga en cuenta que no colorea automáticamente la salida de ningún otro programa. Es más bien una utilidad para ayudarlo a no tener que recordar los códigos abstrusos. Solo necesita usar los nombres de color obvios o su fácil de recordar rgb cmyk w(hite) (of) f abreviaturas.

Para obtener más detalles, visite el repositorio textattr .

0
jamadagni

Para Mac, puede usar el siguiente como se especifica aquí

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

Si bash es tu elección, te recomiendo oh-my-bash . Si zsh es su elección, le recomiendo oh-my-zsh . Ambos admiten la coloración de su terminal y diferentes salidas.

0
TimWirtjes