¿Colorear su terminal y entorno de shell?

262

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.

Stefan Lasiewski
fuente
Para mi enfoque (vea la respuesta a continuación) se abordan problemas con las diferencias de OSX y Linux, por ejemplo, el color en uno es ls -G y en el otro es ls --color-auto
Michael Durrant
1
¿Alguien vio una herramienta para colorear columnas? Eso es un column -t --color?
Tomáš Pospíšek

Respuestas:

121

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+ [.

Lucas Jones
fuente
1
La primera línea PS1 debe leer como esto: PS1='\e[33;1m\u@\h: \e[31m\W\e[0m\$ '. Hay una x superflua después de la cuarta barra invertida.
Chris
3
Los escapes deben estar encerrados \[...\]o los comandos en la segunda línea sobrescribirán la primera línea. PS1 = '[\ e [33; 1m] \ u @ \ h: [\ e [31m] \ W \ e [0m \ $'
yanglifu90
El ls --color=alwaysno 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'
Simon C.
83

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í .

Captura de pantalla de solicitud de bash

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

Kris
fuente
Vea aquí la solución a un problema de línea que obtuve cuando utilicé la PS1 anterior: stackoverflow.com/questions/5087036/…
Xander Dunn
He actualizado la respuesta para reflejar los corchetes escapados para los colores en el mensaje. ¡Gracias!
Kris
1
$LSCOLORSy $CLICOLORson para BSD ls. GNU ls (Linux) usa $LS_COLORScon una sintaxis diferente. Como GNU se siente como mi hogar, yo uso LSCOLORS=exgxfxDacxBaBaCaCaeaEapara imitar los colores de GNU en BSD.
Adam Katz
grep: warning: GREP_OPTIONS is deprecated; please use an alias or script
Steven Almeroth
1
Es posible que necesite obtener el .bashrcarchivo para que la modificación sea efectiva. Puedes hacerlo con el siguiente comando. source /path/to/.bashrc
François
18

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

Sygo
fuente
grcahora es compatible pspor defecto. Me interesarían tus nmapcoloraciones. Vea también mi respuesta para alias de todos estos de una manera que absorberá nuevos comandos cuando actualice grc.
Adam Katz
Me di cuenta que. aquí está 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, puedes encontrar interesante conf.hexdump, aún no lo he terminado aunque.
Sygo
Gracias @Sygo. He bifurcado y revisado tu esencia. En realidad, nunca he confirmado datos con git (por no hablar de lo esencial de github) y no puedo encontrar la manera de proponerle que se los fusione (supongo que esto se debe a que las esencias están demasiado simplificadas).
Adam Katz
Sospecho que no puedes porque es una esencia y no un repositorio adecuado. Sin embargo, revisé tu tenedor y definitivamente estoy probando tu versión. Tengo curiosidad por saber en qué se convertirá ese basurero hexagonal ...
Sygo
11

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í: ingrese la descripción de la imagen aquí

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'
Michael Durrant
fuente
1
Los colores están disponibles para lsOS X, pero se hace mediante el uso export CLICOLOR=1.
ThomasW
3
@ThomasW pero no en Linux :-p El chico usa ambos.
Jimmy Kane
1
No obstante, ThomasW tiene razón al señalar que la respuesta es errónea al decir que los colores no están disponibles lsen MacOS 10. La respuesta también es errónea en el sentido de que las cadenas de comandos aquí son de hecho defectuosas. No se equilibran correctamente \[y\] , y han causado problemas a al menos una persona copia de esta respuesta .
JdeBP
9

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

demostración de bash prompt

Adam Katz
fuente
1
Votación a favor para una captura de pantalla
Verde
Mi PSWD()función solía ser compatible con POSIX, pero es mucho más fácil de usar con el manejo de subcadenas bash / zsh. Consulte la revisión 6 para la versión POSIX, que implica muchos signos de interrogación y no se adaptaba en absoluto al ancho del terminal. No actualicé la captura de pantalla, pero es solo un ligero cambio en el ancho de 80 caracteres.
Adam Katz
CLICOLOR=1no funciona para mí con FREEBSD 11.2
Simon C.
1
@SimonC. - Es posible que esté utilizando utilidades GNU en su sistema FreeBSD en lugar de las BSD. CLICOLOR=1 lsdebería hacer lo mismo que ls -Gusar BSD ( ls -gen BSD anteriores). Si ls --colorfunciona (sin error), está utilizando el lscomando de GNU y $CLICOLORse ignora.
Adam Katz
1
@SimonC. - Debe cargar su ~/.bashrcpara que los cambios surtan efecto. Ejecute source ~/.bashrco inicie una nueva sesión de bash (inicie una terminal o ejecute bash).
Adam Katz
8

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
Stefan Lasiewski
fuente
1
O si desea utilizar ZSH, el aviso de Phil Gold en aperiodic.net/phil/prompt es una obra de arte.
tsvallender
5

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

ejemplo de 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

nachoparker
fuente
2
Hola, ¿cómo haces las banderas para la ruta de acceso? Menciono las barras rectangulares con extremos triangulares Gracias
Artur Vieira
¿funciona también en un terminal ubuntu gnu?
helle
lnav también es una gran herramienta para mostrar archivos de registro coloreados
Cyril Chaboisseau
4

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á!

ingrese la descripción de la imagen aquí


fuente
2
Si pudiera, lo rechazaría por la sugerencia de Oh-My-ZSH. Como ingeniero de sistemas que trabaja extensamente en la Terminal, y como alguien que trató de adoptar zsh / oh-my-zsh en mi flujo de trabajo, honestamente puedo decir que nunca recomendaría ZSH a nadie. Claro, puede vincular 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. Además, no puede colocar emulate bashsu .zprofile o .zshrc archivos Para cualquiera que trabaje con funciones avanzadas en BASH, hay muchas sutilezas que lo morderán. BASH es un mejor sh.
Charles Addis
2
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 usa el shell, excepto para tareas mundanas ocasionales, debería adoptar ZSH, pero no es para cualquiera que necesite usar el shell ampliamente. el =~operador puede morderte, la forma en que ZSH maneja las matrices puede morderte, 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 comandos de git y nunca he mirado hacia atrás. Ahora ya no me preocupo por la portabilidad
Charles Addis
1
"Tiene una de las funciones de consola más potentes que vi. Una de ellas es elegir el tema para su terminal".
Jonathan Hartley
@ JonathanHartley, tu comentario parece que lo dejaste incompleto. ?
Comodín el
2
Gracias por su preocupación, pero mi comentario dice todo lo que tenía la intención de decir.
Jonathan Hartley
4

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:

salida de diff entubado en 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
Jonathan Hartley
fuente
1
Al .bashrcejemplo le falta la final fi, y podría convertirse en un comando de una sola línea:type colordiff &> /dev/null && alias diff='colordiff'
Teemu Leisti,
3

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
Mischa Arefiev
fuente
Por favor especifique su caparazón. La única etiqueta específica de shell de la pregunta es bash , pero creo que su código no lo es bash.
manatwork
@manatwork: lo siento, olvidé mencionar que fue Zsh. Actualicé mi publicación.
Mischa Arefiev
3

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'
Bananguin
fuente
3

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.

Sildoreth
fuente
2

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: ingrese la descripción de la imagen aquí

Poder de acuario
fuente
2

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

Salida incolora de algunas pruebas unitarias de Python

entonces puedes arreglarlo con:

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

Salida coloreada de algunas pruebas unitarias de Python

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.

Jonathan Hartley
fuente
1

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.

usuario3132194
fuente
0

Para Mac puede usar lo siguiente como se especifica aquí

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

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

  1. encuentre un esquema de color que le guste y úselo. El esquema que uso: el esquema que estoy usando
ZhaoGang
fuente
Al usar enlaces a fuentes externas, debe verificar la parte "Proporcionar contexto para enlaces" (Citar partes importantes) de la parte relevante de la guía: unix.stackexchange.com/help/how-to-answer
Gert van den Berg
0

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.

TimWirtjes
fuente
0

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:

ingrese la descripción de la imagen aquí

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 .

jamadagni
fuente