¿Colorear su terminal y entorno de shell?

Aquí hay una un par de cosas que puede hacer:

Editores + Código
Muchos editores tienen sintaxis destacando el apoyo. vim y emacs lo tienen activado de forma predeterminada. También puede habilitarlo en nano .

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

grep
grep --color=auto destaca todas las coincidencias. También puede usar export GREP_OPTIONS="--color=auto" para hacerlo persistente sin un alias. Si usas --color=always, «ll usará color incluso al canalizar , 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 (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 muy creativo con esto. Como idea:

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

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

Deshacerse de secuencias de escape

Si algo se atasca con la salida de color cuando no quieres, utilizo este sed lí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 eliminar las líneas que comienzan con \e[8m, que indica al terminal que oculte el texto. (No se admite ampliamente.)

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

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

Comentarios

• La primera línea de PS1 debería leerse así: PS1='\e[33;1m\u@\h: \e[31m\W\e[0m\$ '. Hay una x superflua después de la cuarta barra invertida.
• Los escapes deben encerrarse en \[...\] o de lo contrario los comandos en la segunda línea sobrescribirán la primera línea. PS1 = ‘ [ \ e [33; 1m ] \ u @ \ h: [ \ e [31m ] \ W \ e [0m \ $ ‘
• El ls --color=always no ‘ no funciona.El enfoque de @Michael Durrant ‘ es mejor para esto: ls --color=al > /dev/null 2>&1 && alias ls='ls -F --color=al' || alias ls='ls -G'

También uso:

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

Y si te gusta colorear tu mensaje, las variables de color definidas pueden Ser útil:

export COLOR_NC="\e[0m" # No Color export COLOR_BLACK="\e[0;30m" export COLOR_GRAY="\e[1;30m" export COLOR_RED="\e[0;31m" export COLOR_LIGHT_RED="\e[1;31m" export COLOR_GREEN="\e[0;32m" export COLOR_LIGHT_GREEN="\e[1;32m" export COLOR_BROWN="\e[0;33m" export COLOR_YELLOW="\e[1;33m" export COLOR_BLUE="\e[0;34m" export COLOR_LIGHT_BLUE="\e[1;34m" export COLOR_PURPLE="\e[0;35m" export COLOR_LIGHT_PURPLE="\e[1;35m" export COLOR_CYAN="\e[0;36m" export COLOR_LIGHT_CYAN="\e[1;36m" export COLOR_LIGHT_GRAY="\e[0;37m" export COLOR_WHITE="\e[1;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 versiones 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:

Comentarios

• Vea aquí la solución a un problema de línea que obtuve cuando usé lo anterior PS1: stackoverflow.com/questions/5087036/…
• I ‘ he actualizado la respuesta para reflejar los corchetes de escape para los colores en el indicador. ¡Gracias!
• $LSCOLORS y $CLICOLOR son para BSD ls. GNU ls (Linux) usa $LS_COLORS con una sintaxis diferente. Como GNU se siente como en casa para mí, uso LSCOLORS=exgxfxDacxBaBaCaCaeaEa para imitar los colores de GNU ‘ en BSD.
• grep: warning: GREP_OPTIONS is deprecated; please use an alias or script
• Es posible que deba obtener el archivo .bashrc para que la modificación sea efectiva. Puedes hacerlo con el siguiente comando. source /path/to/.bashrc

grep y ls ya se han mencionado, si quieres muchos más colores, echa un vistazo a Generic Coloriser , su propósito inicial era colorear archivos de registro, pero desde el primer momento también colorea ping, traceroute, gcc, make, netstat, diff, last, ldap y cvs.

Se puede ampliar fácilmente si conocer las expresiones regulares. He «agregado ps y nmap a la lista (si ingresas en 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 tal vez tengas más suerte buscando para «grc»)

Comentarios

• grc ahora admite ps por defecto. Me ‘ me interesarían tus colores nmap. Vea también mi respuesta para asignar un alias a todos estos de una manera que absorba nuevos comandos cuando actualice grc.
• Me di cuenta de eso. aquí ‘ es mi conf.nmap (y todo lo demás, en realidad) gist.github.com/sygo/844982#file-conf -nmap – Me di cuenta de que trabajas en infosec, puede que conf.hexdump te parezca interesante, aunque ‘ todavía no lo he terminado.
• Gracias @Sygo. ‘ he bifurcado y revisado su esencia. Yo ‘ nunca he comprometido datos con git (y mucho menos github ‘ s gists) y no puedo entender cómo proponer la fusión de nuevo para ti (‘ supongo que esto se debe a que las esencias están demasiado simplificadas).
• Sospecho que puedes ‘ t porque es ‘ una esencia y no un repositorio adecuado. Sin embargo, revisé tu fork y ‘ definitivamente estoy probando tu versión. Tengo ‘ curiosidad sobre en qué se convertirá ese volcado hexadecimal …

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;32 es 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 

Instalar grc ( Coloreador 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 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 

Comentarios

• Votar a favor de una captura de pantalla
• Mi PSWD() solía ser compatible con POSIX, pero ‘ es mucho más fácil de facilitar utilizando el manejo de subcadenas bash / zsh. Consulte la revisión 6 para la versión POSIX, que incluye muchos signos de interrogación y no era ‘ t en absoluto adaptable a la terminal ancho. No ‘ t actualicé la captura de pantalla, pero ‘ es solo un ligero cambio en el ancho de 80 caracteres.
• CLICOLOR=1 no ‘ no me funciona con FREEBSD 11.2
• @SimonC. – Es posible que esté utilizando utilidades GNU en su sistema FreeBSD en lugar de BSD. CLICOLOR=1 ls debería hacer lo mismo que ls -G usando BSD (ls -g en BSD más antiguos). Si ls --color funciona (sin error), ‘ estás usando GNU ‘ s ls comando y $CLICOLOR se ignora.
• @SimonC. – Tienes que cargar tu ~/.bashrc para que los cambios surtan efecto. Ejecute source ~/.bashrc o inicie una nueva sesión de bash (inicie una terminal o ejecute bash).

Establezca un mensaje en negrita / coloreado. De 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 me las arreglé para encontrar configuraciones de color que son ampliamente compatibles y que no imprimen caracteres tontos en entornos más 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 

Comentarios

• O si desea utilizar ZSH, Phil Gold ‘ s indicador en aperiodic.net/phil/prompt es una obra de arte.

Cosas que aún no se han dicho aquí:

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

Para colorear registros, hay multitail

Para colorear cualquier stdout, coloco xcol

Yo personalmente uso estos 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 colorEcho (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 siento, no puedo publicar más enlaces

Comentarios

• Hola, ¿cómo se hacen las banderas para la ruta del mensaje? Estoy mencionando las barras rectangulares con extremos triangulares. Gracias
• ¿Funciona también en una terminal ubuntu gnu?
• lnav también es una gran herramienta para mostrar archivos de registro coloreados

Existe una buena herramienta para configurar los colores del comando ls: http://geoff.greer.fm/lscolors/

Le sugiero que consulte ZSH y su complemento oh-my-zsh , que tiene una de las funciones de consola más poderosas que he visto. Una de ellas es elegir un tema para tu 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á!

Comentarios

• Si pudiera, rechazaría esto por Oh-My-ZSH sugerencia. Como ingeniero de sistemas que trabaja extensamente en la Terminal, y como alguien que intentó adoptar zsh / oh-my-zsh en mi flujo de trabajo, Puedo decir honestamente que nunca recomendaría ZSH a nadie. Claro, puede enlazar zsh a un archivo con el nombre de cualquier otro shell y emular ese shell, pero cuando lo hace, no ‘ lee su .bashrc, .bash_profile, etc. , no puede poner emulate bash en sus archivos .zprofile o .zshrc. Para cualquiera que trabaje con funciones avanzadas en BASH, hay muchas sutilezas que lo morderán. BASH es un mejor sh.
• Lo único que ZSH tiene listo para usar que es mejor que BASH es la finalización de comandos, pero incluso eso es programable en BASH. Tal vez alguien que no ‘ no use el shell, excepto para tareas mundanas ocasionales, debería adoptar ZSH, pero ‘ no es para nadie que lo necesite. use la concha extensamente. el operador =~ puede morderlo, la forma en que ZSH maneja las matrices puede morderlo, etc. Después de usar ZSH / Oh-My-ZSH durante aproximadamente 9 meses, tuve suficiente. Estaba usando un tema personalizado que escribí yo mismo, lo porté a BASH y escribí mi propia línea de aviso de git y ‘ nunca miré hacia atrás. Ahora ya no me preocupo por la portabilidad
• «, tiene una de las funciones de consola más poderosas que vi. Uno de ellos es elegir el tema para su terminal. »
• @JonathanHartley, parece que su comentario lo dejó incompleto. ?
• Gracias por su preocupación, pero mi comentario dice todo lo que pretendía decir.

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

sudo apt-get install colordiff 

Pipe cualquier salida de formato diff en colordiff:

Esto incluye algunos de los formatos alternativos de diff, como -y (en paralelo.)

Alternativamente, si se invoca de forma independiente ( sin nada conectado) entonces actúa como un envoltorio 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 

Comentarios

• Al ejemplo de .bashrc le falta el fi, y podría convertirse en un comando de una sola línea: type colordiff &> /dev/null && alias diff='colordiff'

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

Escribo envoltorios bash alrededor de llamadas a programas y canalizo su salida a través de sed. Lo que me gusta de sed es que modificará y repetirá 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 sed el código se analiza y compila.

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 mensaje, 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 similar a esto:

user@host(bash): ~/bin > 

El directorio de trabajo está en verde Y el nombre de usuario está en negrita y cian a menos que ejecuté el shell con sudo, en cuyo caso el nombre de usuario («root») se muestra en negrita y rojo.

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

La razón por la que uso tput es que se supone que tiene un soporte más universal que las secuencias raras 033[01;31m\]. Además, como una ventaja adicional, si hace echo $PS1 en 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 la salida de scripts, su nombre ScriptEchoColor en la fragua de origen: http://scriptechocolor.sourceforge.net/

ej .:

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 excelente herramienta Python de uso general para colorear la salida de comandos es « colout «

Le da una expresión regular con N grupos, seguida 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 algún resultado de prueba:

python -m unittest discover -v 

, entonces puede 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) seguidos de tres colores (y opcionalmente tres estilos, pero «he usado una abreviatura para establecer todos los colores en» negrita » , por lo que el grupo «negro», que coincide con el texto entre corchetes, aparece en gris oscuro.)

Tenga en cuenta también cómo tuve que agregar 2>&1 al final de la invocación de Python, porque la salida de unittest está en stderr, así que la transferí a stdout para poder canalizarla a colout.

Esto generalmente es tan fácil de usar que a menudo me encuentro creando nuevos colout invocat iones sobre la marcha, y reutilizándolos o modificándolos de 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 instalar usando pip, o sudo python setup.py install.

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

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

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

Tiene un color brillante configuración predeterminada y, a diferencia de ls, no sufre una penalización de rendimiento por agregar nuevos colores. (Deben escanear toda la cadena LS_COLORS para cada error).

https://github.com/AdamDanischewski/cf

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

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

Yo uso envoltorio de color .

cw es un contenedor de color ANSI en tiempo real no intrusivo para comandos comunes basados en Unix en GNU / linux. cw está diseñado para simular el entorno de los comandos que se están ejecutando, 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 tokenizados, encabezados / pies de página, colores de escenarios de casos, colores de definiciones dependientes de la línea de comandos e incluye más de 50 archivos de definición predefinidos.

Es casi perfecto, pero una vez que descubrí que ps en el shell interactivo devuelve una salida diferente comparando ps en una tubería.

si quieres que tu vim sea colorido como yo, te sugiero que sigas dos pasos:

1. aprende a activar la función siguiendo este enlace: activa 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. busque un esquema de color que le guste y úselo. El esquema que utilizo: el esquema que estoy usando

Comentarios

• Cuando uses enlaces a fuentes externas, debes marcar la parte » Proporcionar contexto para enlaces » (Citar partes importantes) de la parte relevante de la guía: unix.stackexchange.com/help/how-to-answer

Si bash es su elección, le 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.

Me gustaría anunciar humildemente mi reciente publicación de ta o textattr , una biblioteca y una 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 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"

le dará algo como:

Actualmente, esta biblioteca se puede usar en cuatro lenguajes C, C ++, D y Python, además 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 ayudarle con no h ansioso por recordar los códigos abstrusos. Solo necesita usar los nombres de colores obvios o su rgb cmyk w (hite) (of) f fáciles de recordar abreviaturas.

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