¿Colorear su terminal y 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 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, lo que agrega otra capa de diversión.
4. Muchos sistemas operativos establecen cosas como dircolorsy de forma predeterminada, y no quiero modificar esto en un centenar de hosts diferentes. Así que trato de mantener los valores predeterminados. En cambio, modifico la configuración de color de mi terminal.

5. El uso del color para algunos comandos de Unix ( ls, grep, less, vim) y la pronta Bash . Estos comandos parecen usar las " secuencias de escape ANSI " estándar . Por ejemplo:

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

Publicaré mi .bashrcy responderé mi propia pregunta Jeopardy Style.

Aquí hay un par de cosas que puedes hacer:

Editores + Código
Muchos editores tienen soporte para resaltar la sintaxis. vimy emacstenerlo activado por defecto. También puede habilitarlo ennano .

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

grep
grep --color=auto destaca todos los partidos. También puede usar export GREP_OPTIONS='--color=auto'para hacerlo persistente sin un alias. Si lo usas --color=always, usará 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: dircolorspuede ser útil)

PS1
Puede configurar su PS1 (indicador de shell) para usar colores. Por ejemplo:

PS1='\e[33;1m\u@\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[\u@\h:  \w]\$ '

Pone una barra en la parte superior de su terminal con información aleatoria. (Para 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 sedlínea 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 \e[8m, lo que le 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 escribir pulsando ^ V ^ [en bash, que es Ctrl+ V, Ctrl+ [.

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 solicitud, los colores 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 mensaje 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 script de 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 del script tiene la fuente aquí .

Esta es la fuente completa de mi configuración de solicitud:

grepy lsya se han mencionado, si quieres un montón más colores echa un vistazo a coloriser genérico , su propósito inicial era para colorear los archivos de registro, pero nada más sacarlo de la caja en la que también se colorea ping, traceroute, gcc, make, netstat, diff, last, ldap, y cvs.

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

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

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 él, mi indicador de PS1 se ve así:

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 indicador de PS1:

• muestra git branch!
• las rutas de directorio largas (más de 6 elementos) se 'recortan' para mostrar los directorios de los 3 primeros y los 3 inferiores _entre ellos (esa es la pwd sedparte de LOCATION).
• ¡retorno de carro al final para que el aviso siempre esté a la izquierda!

Las líneas relevantes de mi .bashrcarchivo 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'

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") \
      "$@"
}
function man() { _colorman man "$@"; }
function perldoc() { command perldoc -n less "$@" |man -l -; }

Colores para grep ( 1;32es 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 "$@"; 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 "$@"
  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
}

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

# Shorten home dir, cygwin drives, paths that are too long
if [ -d /cygdrive ] && uname -a |grep -qi cygwin; then CYGWIN_OS=1; fi
function PSWD() {
  local p="$*" space A B cols="${COLUMNS:-`tput cols 2>/dev/null || echo 80`}"
  p="${p/$HOME/\~}"         # shrink home down to a tilde
  if [ -n "$CYGWIN_OS" ] && [ "${p#/cygdrive/?/}" != "$p" ]; then
    p="${p:10:1}:${p:11}"   # /cygdrive/c/hi -> c:/hi
  fi
  space="$((${#USER}+${#HOSTNAME}+6))"  # width w/out the path
  if [ "$cols" -lt 60 ]; then echo -n "$N "; space=-29; p="$p$N\b"; fi
  if [ "$cols" -lt "$((space+${#p}+20))" ]; then # < 20 chars for the command
    A=$(( (cols-20-space)/4 ))      # a quarter of the space (-20 for cmd)
    if [ $A -lt 4 ]; then A=4; fi   # 4+ chars from beginning
    B=$(( cols-20-space-A*2 ))      # half (plus rounding) of the space
    if [ $B -lt 8 ]; then B=8; fi   # 8+ chars from end
    p="${p:0:$A}..${p: -$B}"
  fi
  echo "$p"
}

PSC() { echo -ne "\[\033[${1:-0;38}m\]"; }
PR="0;32"       # default color used in prompt is green
if [ "$(id -u)" = 0 ]; then
    sudo=41     # root is red background
  elif [ "$USER" != "${SUDO_USER:-$USER}" ]; then
    sudo=31     # not root, not self: red text
  else sudo="$PR"   # standard user color
fi
PROMPT_COMMAND='[ $? = 0 ] && PS1=${PS1[1]} || PS1=${PS1[2]}'
PSbase="$(PSC $sudo)\u$(PSC $PR)@\h $(PSC 33)\$(PSWD \w)"
PS1[1]="$PSbase$(PSC $PR)\$ $(PSC)"
PS1[2]="$PSbase$(PSC  31)\$ $(PSC)"
PS1="${PS1[1]}"
unset sudo PR PSbase

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

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

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

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, armé xcol

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

Te sugiero que eches un vistazo a ZSH y su complemento oh-my-zsh, que tiene una de las funciones 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á!

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

sudo apt-get install colordiff

Canalice cualquier salida de formato diff en el 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

Parte de la decoración del texto (negrita) para diferenciar fácilmente entre la raíz y la cáscara no raíz. 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

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

Sin embargo, escribo envoltorios de bash alrededor de las llamadas al programa y canalizo su salida sed. Lo que me gusta sedes 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 elsed código 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} $@ | 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'

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 aviso que se parece a esto:

user@host(bash): ~/bin >

El directorio de trabajo está en verde. Y el nombre de usuario es negrita y cian a menos que haya ejecutado el shell consudo , en cuyo caso el nombre de usuario ("raíz") aparece 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 hace que editar la solicitud sea mucho más fácil.

La razón que uso tputes que se supone que es más universalmente compatible que las 033[01;31m\]secuencias extrañas . Además, como una ventaja adicional, si lo hace echo $PS1en el indicador, verá el indicador sin procesar con colores en lugar de esas secuencias de control ininteligibles.

También puede probar un proyecto que ayude a colorear los scripts de salida, llamado 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:

Una gran herramienta de Python de uso general 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

entonces puedes arreglarlo con:

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

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>&1al final de la invocación de Python, porque el resultado de unittest está en stderr, por lo que lo transfirí a stdout para poder canalizarlo en colout.

En general, esto es 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 de Python, no como un ejecutable independiente, por lo que debe instalarlo usando pip, o sudo python setup.py install.

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

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

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 descubrí que ps en el shell interactivo devuelve resultados diferentes comparando ps en una tubería.

Para Mac puede usar lo siguiente como se especifica aquí

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

si quieres hacer tu vimcolorido como yo, te sugiero que sigas dos pasos:

1. aprenda cómo 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

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

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

Me gustaría anunciar humildemente mi reciente publicación de tao textattr , una biblioteca y herramienta de línea de comandos que tiene como objetivo facilitar la adición de color y atributos para embellecer la salida del terminal de su programa mediante la traducción de 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:

Actualmente, esta biblioteca se puede usar desde cuatro idiomas C, C ++, D y Python, aparte del uso de la línea de comandos desde 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 colores obvios o sus abreviaturas rgb cmyk w (hite) (of) f fáciles de recordar .

Para más detalles, visite el repositorio textattr .