Cómo cambiar el color de salida del eco en Linux

Estoy tratando de imprimir un texto en la terminal usando el comando echo.

Quiero imprimir el texto en un color rojo. ¿Cómo puedo hacer eso?

Puede usar estos códigos de escape ANSI :

Black 0;30 Dark Gray 1;30 Red 0;31 Light Red 1;31 Green 0;32 Light Green 1;32 Brown/Orange 0;33 Yellow 1;33 Blue 0;34 Light Blue 1;34 Purple 0;35 Light Purple 1;35 Cyan 0;36 Light Cyan 1;36 Light Gray 0;37 White 1;37 

Y luego utilícelos así en su script:

 # .---------- constant part! # vvvv vvvv-- the code from above RED='\033[0;31m' NC='\033[0m' # No Color printf "I ${RED}love${NC} Stack Overflow\n" 

que imprime love en rojo.

Del comentario de @ james-lim, si está utilizando el comando echo , asegúrese de usar el indicador -e para permitir escapes de barra invertida.

 # Continued from above example echo -e "I ${RED}love${NC} Stack Overflow" 

(no agregue "\n" cuando use echo a menos que desee agregar una línea vacía adicional)

Puede usar el impresionante comando tput (sugerido en la respuesta de Ignacio ) para producir códigos de control de terminal para todo tipo de cosas.


Uso

tput específicos se discuten más adelante.

Directo

Call tput como parte de una secuencia de comandos:

 tput setaf 1; echo "this is red text" 

Uso ; en lugar de && por lo que si se tput errores, el texto aún se muestra.

Variables de Shell

Otra opción es usar variables de shell:

 red=`tput setaf 1` green=`tput setaf 2` reset=`tput sgr0` echo "${red}red text ${green}green text${reset}" 

tput produce secuencias de caracteres que el terminal interpreta que tienen un significado especial. No se mostrarán ellos mismos. Tenga en cuenta que todavía se pueden guardar en archivos o procesados ​​como entrada por progtwigs que no sean el terminal.

Sustitución de comando

Puede ser más conveniente insertar la salida de tput directamente en sus cadenas de echo usando la sustitución de comandos :

 echo "$(tput setaf 1)Red text $(tput setab 7)and white background$(tput sgr 0)" 

Ejemplo

El comando anterior produce esto en Ubuntu:

Captura de pantalla del texto del terminal de color


Comandos de color de primer plano y fondo

 tput setab [1-7] # Set the background colour using ANSI escape tput setaf [1-7] # Set the foreground colour using ANSI escape 

Los colores son los siguientes:

 Num Colour #define RGB 0 black COLOR_BLACK 0,0,0 1 red COLOR_RED 1,0,0 2 green COLOR_GREEN 0,1,0 3 yellow COLOR_YELLOW 1,1,0 4 blue COLOR_BLUE 0,0,1 5 magenta COLOR_MAGENTA 1,0,1 6 cyan COLOR_CYAN 0,1,1 7 white COLOR_WHITE 1,1,1 

También hay versiones que no son ANSI de las funciones de configuración de color ( setb lugar de setab y setf lugar de setaf ) que usan números diferentes, que no figuran aquí.

Comandos de modo de texto

 tput bold # Select bold mode tput dim # Select dim (half-bright) mode tput smul # Enable underline mode tput rmul # Disable underline mode tput rev # Turn on reverse video mode tput smso # Enter standout (bold) mode tput rmso # Exit standout mode 

Comandos de movimiento del cursor

 tput cup YX # Move cursor to screen postion X,Y (top left is 0,0) tput cuf N # Move N characters forward (right) tput cub N # Move N characters back (left) tput cuu N # Move N lines up tput ll # Move to last line, first column (if no cup) tput sc # Save the cursor position tput rc # Restore the cursor position tput lines # Output the number of lines of the terminal tput cols # Output the number of columns of the terminal 

Borrar e insertar comandos

 tput ech N # Erase N characters tput clear # Clear screen and move the cursor to 0,0 tput el 1 # Clear to beginning of line tput el # Clear to end of line tput ed # Clear to end of screen tput ich N # Insert N characters (moves rest of line forward!) tput il N # Insert N lines 

Otros comandos

 tput sgr0 # Reset text format to the terminal's default tput bel # Play a bell 

Con compiz windows wobbly , el comando bel hace que el terminal se tambalee por un segundo para llamar la atención del usuario.


Guiones

tput acepta scripts que contienen un comando por línea, que se ejecutan en orden antes de que tput salga.

Evite los archivos temporales haciendo eco de una cadena multilínea y conectándola a la tubería:

 echo -e "setf 7\nsetb 1" | tput -S # set fg white and bg red 

Ver también

  • Ver man 1 tput
  • Consulte man 5 terminfo para obtener la lista completa de comandos y más detalles sobre estas opciones. (El comando tput correspondiente se enumera en la columna Cap-name de la enorme tabla que comienza en la línea 81).

algunas variables que puedes usar:

 # Reset Color_Off='\033[0m' # Text Reset # Regular Colors Black='\033[0;30m' # Black Red='\033[0;31m' # Red Green='\033[0;32m' # Green Yellow='\033[0;33m' # Yellow Blue='\033[0;34m' # Blue Purple='\033[0;35m' # Purple Cyan='\033[0;36m' # Cyan White='\033[0;37m' # White # Bold BBlack='\033[1;30m' # Black BRed='\033[1;31m' # Red BGreen='\033[1;32m' # Green BYellow='\033[1;33m' # Yellow BBlue='\033[1;34m' # Blue BPurple='\033[1;35m' # Purple BCyan='\033[1;36m' # Cyan BWhite='\033[1;37m' # White # Underline UBlack='\033[4;30m' # Black URed='\033[4;31m' # Red UGreen='\033[4;32m' # Green UYellow='\033[4;33m' # Yellow UBlue='\033[4;34m' # Blue UPurple='\033[4;35m' # Purple UCyan='\033[4;36m' # Cyan UWhite='\033[4;37m' # White # Background On_Black='\033[40m' # Black On_Red='\033[41m' # Red On_Green='\033[42m' # Green On_Yellow='\033[43m' # Yellow On_Blue='\033[44m' # Blue On_Purple='\033[45m' # Purple On_Cyan='\033[46m' # Cyan On_White='\033[47m' # White # High Intensity IBlack='\033[0;90m' # Black IRed='\033[0;91m' # Red IGreen='\033[0;92m' # Green IYellow='\033[0;93m' # Yellow IBlue='\033[0;94m' # Blue IPurple='\033[0;95m' # Purple ICyan='\033[0;96m' # Cyan IWhite='\033[0;97m' # White # Bold High Intensity BIBlack='\033[1;90m' # Black BIRed='\033[1;91m' # Red BIGreen='\033[1;92m' # Green BIYellow='\033[1;93m' # Yellow BIBlue='\033[1;94m' # Blue BIPurple='\033[1;95m' # Purple BICyan='\033[1;96m' # Cyan BIWhite='\033[1;97m' # White # High Intensity backgrounds On_IBlack='\033[0;100m' # Black On_IRed='\033[0;101m' # Red On_IGreen='\033[0;102m' # Green On_IYellow='\033[0;103m' # Yellow On_IBlue='\033[0;104m' # Blue On_IPurple='\033[0;105m' # Purple On_ICyan='\033[0;106m' # Cyan On_IWhite='\033[0;107m' # White 

el personaje de escape en bash , hex y octal respectivamente:

 | | bash | hex | octal | NOTE | |-------+-------+--------+---------+------------------------------| | start | \e | \x1b | \033 | | | start | \E | \x1B | - | x cannot be capital | | end | \e[0m | \x1m0m | \033[0m | | | end | \e[m | \x1b[m | \033[m | 0 is appended if you omit it | | | | | | | 

pequeño ejemplo:

 | color | bash | hex | octal | NOTE | |-------------+--------------+----------------+----------------+---------------------------------------| | start green | \e[32m | \x1b[32m | \033[32m | m is NOT optional | | reset | \e[0m | \1xb[0m | \033[om | o is optional (do it as best practice | | | | | | | 

excepción de bash:

Si vas a usar estos códigos en tus variables especiales de bash

  • PS0
  • PS1
  • PS2 (= esto es para preguntar)
  • PS4

debe agregar caracteres de escape adicionales para que bash pueda interpretarlos correctamente. Sin esto, agregar caracteres de escape adicionales funciona, pero usted enfrentará problemas cuando use Ctrl + r para buscar en su historial.

regla de excepción para bash

Debería agregar \[ antes de cualquier código ANSI inicial y agregar \] después de cualquiera de los finales.
Ejemplo:
en uso regular: \033[32mThis is in green\033[0m
para PS0 / 1/2/4: \[\033[32m\]This is in green\[\033[m\]

\[ es para el inicio de una secuencia de caracteres no imprimibles
\] es para el final de una secuencia de caracteres no imprimibles

Consejo: para memorizarlo, primero puede agregar \[\] y luego poner su código ANSI entre ellos:
\[start-ANSI-code\]
\[end-ANSI-code\]

tipo de secuencia de color:

  1. 3/4 bit
  2. 8 bits
  3. 24 bits

Antes de sumergirte en estos colores, debes conocer 4 modos con estos códigos:

1. modo de color

Modifica el estilo del color NO el texto. Por ejemplo, haz que el color sea más claro o más oscuro.

  • 0 reinicio
  • 1; Más ligero de lo normal
  • 2; más oscuro de lo normal

Este modo no es compatible ampliamente. Es totalmente compatible con Gnome-Terminal.

2. modo de texto

Este modo es para modificar el estilo del texto NO el color.

  • 3; itálico
  • 4; subrayar
  • 5; parpadeando (lento)
  • 6; parpadeando (rápido)
  • 7; marcha atrás
  • 8; esconder
  • 9; tachar

y son casi compatibles.
Por ejemplo, KDE-Konsole admite 5; pero Gnome-Terminal no lo hace y Gnome es compatible con 8; pero KDE no.

3. modo de primer plano

Este modo es para colorear el primer plano.

4. modo de fondo

Este modo es para colorear el fondo.

La siguiente tabla muestra un resumen de la versión de 3/4 bits del color ANSI

 |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | color-mode | octal | hex | bash | description | example (= in octal) | NOTE | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 0 | \033[0m | \x1b[0m | \e[0m | reset any affect | echo -e "\033[0m" | 0m equals to m | | 1 | \033[1m | | | light (= bright) | echo -e "\033[1m####\033[m" | - | | 2 | \033[2m | | | dark (= fade) | echo -e "\033[2m####\033[m" | - | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | text-mode | ~ | | | ~ | ~ | ~ | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 3 | \033[3m | | | italic | echo -e "\033[3m####\033[m" | | | 4 | \033[4m | | | underline | echo -e "\033[4m####\033[m" | | | 5 | \033[5m | | | blink (slow) | echo -e "\033[3m####\033[m" | | | 6 | \033[6m | | | blink (fast) | ? | not wildly support | | 7 | \003[7m | | | reverse | echo -e "\033[7m####\033[m" | it affects the background/foreground | | 8 | \033[8m | | | hide | echo -e "\033[8m####\033[m" | it affects the background/foreground | | 9 | \033[9m | | | cross | echo -e "\033[9m####\033[m" | | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | foreground | ~ | | | ~ | ~ | ~ | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 30 | \033[30m | | | black | echo -e "\033[30m####\033[m" | | | 31 | \033[31m | | | red | echo -e "\033[31m####\033[m" | | | 32 | \033[32m | | | green | echo -e "\033[32m####\033[m" | | | 33 | \033[32m | | | yellow | echo -e "\033[33m####\033[m" | | | 34 | \033[32m | | | blue | echo -e "\033[34m####\033[m" | | | 35 | \033[32m | | | purple | echo -e "\033[35m####\033[m" | real name: magenta = reddish-purple | | 36 | \033[32m | | | cyan | echo -e "\033[36m####\033[m" | | | 37 | \033[32m | | | white | echo -e "\033[37m####\033[m" | | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 38 | 8/24 | This is for special use of 8-bit or 24-bit | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | background | ~ | | | ~ | ~ | ~ | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 40 | \033[40m | | | black | echo -e "\033[40m####\033[m" | | | 41 | \033[41m | | | red | echo -e "\033[41m####\033[m" | | | 42 | \033[42m | | | green | echo -e "\033[42m####\033[m" | | | 43 | \033[43m | | | yellow | echo -e "\033[43m####\033[m" | | | 44 | \033[44m | | | blue | echo -e "\033[44m####\033[m" | | | 45 | \033[45m | | | purple | echo -e "\033[45m####\033[m" | real name: magenta = reddish-purple | | 46 | \033[46m | | | cyan | echo -e "\033[46m####\033[m" | | | 47 | \033[47m | | | white | echo -e "\033[47m####\033[m" | | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| | 48 | 8/24 | This is for special use of 8-bit or 24-bit | | |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------| 

La siguiente tabla muestra un resumen de la versión de 8 bits del color ANSI

 |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------| | foreground | octal | hex | bash | description | example | NOTE | |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------| | 0-7 | \033[38;5 | \x1b[38;5 | \e[38;5 | standard. normal | echo -e '\033[38;5;1m####\033[m' | | | 8-15 | | | | standard. light | echo -e '\033[38;5;9m####\033[m' | | | 16-231 | | | | more resolution | echo -e '\033[38;5;45m####\033[m' | has no specific pattern | | 232-255 | | | | | echo -e '\033[38;5;242m####\033[m' | from black to white | |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------| | foreground | octal | hex | bash | description | example | NOTE | |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------| | 0-7 | | | | standard. normal | echo -e '\033[48;5;1m####\033[m' | | | 8-15 | | | | standard. light | echo -e '\033[48;5;9m####\033[m' | | | 16-231 | | | | more resolution | echo -e '\033[48;5;45m####\033[m' | | | 232-255 | | | | | echo -e '\033[48;5;242m####\033[m' | from black to white | |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------| 

La prueba rápida de 8 bits:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

La siguiente tabla muestra un resumen de la versión de 24 bits del color ANSI

 |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------| | foreground | octal | hex | bash | description | example | NOTE | |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------| | 0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | R = red | echo -e '\033[38;2;255;0;02m####\033[m' | R=255, G=0, B=0 | | 0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | G = green | echo -e '\033[38;2;;0;255;02m####\033[m' | R=0, G=255, B=0 | | 0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | B = blue | echo -e '\033[38;2;0;0;2552m####\033[m' | R=0, G=0, B=255 | |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------| | background | octal | hex | bash | description | example | NOTE | |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------| | 0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | R = red | echo -e '\033[48;2;255;0;02m####\033[m' | R=255, G=0, B=0 | | 0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | G = green | echo -e '\033[48;2;;0;255;02m####\033[m' | R=0, G=255, B=0 | | 0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | B = blue | echo -e '\033[48;2;0;0;2552m####\033[m' | R=0, G=0, B=255 | |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------| 

algunas capturas de pantalla

resumen de 8 bits en primer plano en un .gif

foreground.gif

resumen de 8 bits de fondo en un .gif

background.gif

resumen de color con sus valores

enter image description here enter image description here enter image description here enter image description here

blinking en KDE-Terminal

KDE-parpadeando

un simple código C que te muestra más

cecho_screenshot

una herramienta más avanzada que desarrollé para tratar estos colores:
Bline


modo de color disparo

fade-normal-bright

modo de texto disparado

solo-modo-texto

la combinación está bien

combinar

más disparos

Consejos y trucos para usuarios avanzados y progtwigdores:

¿Podemos usar estos códigos en un lenguaje de progtwigción?

Sí tu puedes. Experimenté en bash , c , c ++ , d perl , python

¿Reducen la velocidad de un progtwig?

Creo que no.

¿Podemos usar estos en Windows?

3/4-bit Sí, si comstack el código con gcc
algunas capturas de pantalla en Win-7

Cómo calcular la longitud del código?

\033[ = 2, otras partes 1

¿Dónde podemos usar estos códigos?

En cualquier lugar que tenga un intérprete tty
xterm , gnome-terminal , kde-terminal , mysql-client-CLI etc.
Por ejemplo, si quieres colorear tu salida con mysql puedes usar Perl

 #!/usr/bin/perl -n print "\033[1m\033[31m$1\033[36m$2\033[32m$3\033[33m$4\033[m" while /([|+-]+)|([0-9]+)|([a-zA-Z_]+)|([^\w])/g; 

almacene este código en un nombre de archivo: pcc (= Perl Colorize Character) y luego coloque el archivo a en PATH válido y luego utilícelo en cualquier lugar que desee.

ls | pcc
df | pcc

dentro de mysql primero regístralo para buscar y luego prueba:

 [user2:db2] pager pcc PAGER set to 'pcc' [user2:db2] select * from table-name; 

pcc

NO maneja Unicode.

¿Estos códigos solo colorean?

No, pueden hacer muchas cosas interesantes. Tratar:

 echo -e '\033[2K' # clear the screen and do not move the position 

o:

 echo -e '\033[2J\033[u' # clear the screen and reset the position 

Hay muchos principiantes que desean borrar la pantalla con el system( "clear" ) para que pueda usar esta llamada en lugar del system(3)

¿Están disponibles en Unicode?

Sí. \u001b

¿Qué versión de estos colores es preferible?

Es fácil de utilizar 3/4-bit , pero es mucho más preciso y atractivo usar 24-bit .
Si no tienes experiencia con html, aquí tienes un tutorial rápido:
24 bits significa: 00000000 y 00000000 y 00000000 . Cada 8 bits es para un color específico.
24..17 es para y 16..9 para y 8..1 para
Entonces en html #FF0000 significa y aquí está: 255;0;0
en html #00FF00 significa que aquí está: 0;255;0
¿Tiene sentido? de qué color quieres combinarlo con estos tres valores de 8 bits.

referencia:
Wikipedia
Secuencias de escape ANSI
tldp.org
tldp.org
misc.flogisoft.com
algunos blogs / páginas web que no recuerdo

insignias:

Use tput con la capacidad de setaf y un parámetro de 1 .

 echo "$(tput setaf 1)Hello, world$(tput sgr0)" 
 echo -e "\033[31m Hello World" 

El [31m controla el color del texto:

  • 3037 conjuntos de color de primer plano
  • 4047 establece el color de fondo

Aquí puede encontrar una lista más completa de códigos de color.

Es una buena práctica restablecer el color del texto a \033[0m al final de la cadena.

Este es el interruptor de color \033[ . Vea la historia .

Los códigos de color son como 1;32 (Verde claro), 0;34 (Azul), 1;34 (Azul claro), etc.

Terminamos las secuencias de color con un interruptor de color \033[ y 0m , el código sin color. Al igual que abrir y cerrar tabs en un lenguaje de marcado.

  SWITCH="\033[" NORMAL="${SWITCH}0m" YELLOW="${SWITCH}1;33m" echo "${YELLOW}hello, yellow${NORMAL}" 

Solución de función de echo color simple:

 cecho() { local code="\033[" case "$1" in black | bk) color="${code}0;30m";; red | r) color="${code}1;31m";; green | g) color="${code}1;32m";; yellow | y) color="${code}1;33m";; blue | b) color="${code}1;34m";; purple | p) color="${code}1;35m";; cyan | c) color="${code}1;36m";; gray | gr) color="${code}0;37m";; *) local text="$1" esac [ -z "$text" ] && local text="$color$2${code}0m" echo "$text" } cecho "Normal" cecho y "Yellow!" 

Una forma clara de cambiar el color solo para un echo es definir dicha función:

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

Uso:

 coloredEcho "This text is green" green 

O puede usar directamente los códigos de color mencionados en la respuesta de Drew :

 coloredEcho "This text is green" 2 

Use tput para calcular los códigos de color. Evite utilizar el código de escape ANSI (por ejemplo, \E[31;1m para el rojo] porque es menos portátil). Bash en OS X, por ejemplo, no lo admite.

 BLACK=`tput setaf 0` RED=`tput setaf 1` GREEN=`tput setaf 2` YELLOW=`tput setaf 3` BLUE=`tput setaf 4` MAGENTA=`tput setaf 5` CYAN=`tput setaf 6` WHITE=`tput setaf 7` BOLD=`tput bold` RESET=`tput sgr0` echo -e "hello ${RED}some red text${RESET} world" 

Esta pregunta ha sido respondida una y otra vez 🙂 pero ¿por qué no?

tput primero tput es más portátil en entornos modernos que inyectar códigos ASCII manualmente a través de echo -E

Aquí hay una función rápida de bash:

  say() { echo "$@" | sed \ -e "s/\(\(@\(red\|green\|yellow\|blue\|magenta\|cyan\|white\|reset\|b\|u\)\)\+\)[[]\{2\}\(.*\)[]]\{2\}/\1\4@reset/g" \ -e "s/@red/$(tput setaf 1)/g" \ -e "s/@green/$(tput setaf 2)/g" \ -e "s/@yellow/$(tput setaf 3)/g" \ -e "s/@blue/$(tput setaf 4)/g" \ -e "s/@magenta/$(tput setaf 5)/g" \ -e "s/@cyan/$(tput setaf 6)/g" \ -e "s/@white/$(tput setaf 7)/g" \ -e "s/@reset/$(tput sgr0)/g" \ -e "s/@b/$(tput bold)/g" \ -e "s/@u/$(tput sgr 0 1)/g" } 

Ahora puedes usar:

  say @b@green[[Success]] 

Llegar:

Éxito Bold-Green

Notas sobre la portabilidad de tput

La primera vez que se tput(1) código fuente tput(1) en septiembre de 1986

tput(1) ha estado disponible en la semántica X / Open curses en 1990 (el estándar de 1997 tiene la semántica mencionada a continuación).

Entonces, es ( bastante ) omnipresente.

Estos códigos funcionan en mi caja de Ubuntu:

enter image description here

 echo -e "\x1B[31m foobar \x1B[0m" echo -e "\x1B[32m foobar \x1B[0m" echo -e "\x1B[96m foobar \x1B[0m" echo -e "\x1B[01;96m foobar \x1B[0m" echo -e "\x1B[01;95m foobar \x1B[0m" echo -e "\x1B[01;94m foobar \x1B[0m" echo -e "\x1B[01;93m foobar \x1B[0m" echo -e "\x1B[01;91m foobar \x1B[0m" echo -e "\x1B[01;90m foobar \x1B[0m" echo -e "\x1B[01;89m foobar \x1B[0m" echo -e "\x1B[01;36m foobar \x1B[0m" 

Esto imprime las letras abcd todo en diferentes colores:

 echo -e "\x1B[0;93m a \x1B[0m b \x1B[0;92m c \x1B[0;93m d \x1B[0;94m" 

En bucle:

 for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done 

enter image description here

Gracias a @ k-five por esta respuesta

 declare -A colors #curl www.bunlongheng.com/code/colors.png # Reset colors[Color_Off]='\033[0m' # Text Reset # Regular Colors colors[Black]='\033[0;30m' # Black colors[Red]='\033[0;31m' # Red colors[Green]='\033[0;32m' # Green colors[Yellow]='\033[0;33m' # Yellow colors[Blue]='\033[0;34m' # Blue colors[Purple]='\033[0;35m' # Purple colors[Cyan]='\033[0;36m' # Cyan colors[White]='\033[0;37m' # White # Bold colors[BBlack]='\033[1;30m' # Black colors[BRed]='\033[1;31m' # Red colors[BGreen]='\033[1;32m' # Green colors[BYellow]='\033[1;33m' # Yellow colors[BBlue]='\033[1;34m' # Blue colors[BPurple]='\033[1;35m' # Purple colors[BCyan]='\033[1;36m' # Cyan colors[BWhite]='\033[1;37m' # White # Underline colors[UBlack]='\033[4;30m' # Black colors[URed]='\033[4;31m' # Red colors[UGreen]='\033[4;32m' # Green colors[UYellow]='\033[4;33m' # Yellow colors[UBlue]='\033[4;34m' # Blue colors[UPurple]='\033[4;35m' # Purple colors[UCyan]='\033[4;36m' # Cyan colors[UWhite]='\033[4;37m' # White # Background colors[On_Black]='\033[40m' # Black colors[On_Red]='\033[41m' # Red colors[On_Green]='\033[42m' # Green colors[On_Yellow]='\033[43m' # Yellow colors[On_Blue]='\033[44m' # Blue colors[On_Purple]='\033[45m' # Purple colors[On_Cyan]='\033[46m' # Cyan colors[On_White]='\033[47m' # White # High Intensity colors[IBlack]='\033[0;90m' # Black colors[IRed]='\033[0;91m' # Red colors[IGreen]='\033[0;92m' # Green colors[IYellow]='\033[0;93m' # Yellow colors[IBlue]='\033[0;94m' # Blue colors[IPurple]='\033[0;95m' # Purple colors[ICyan]='\033[0;96m' # Cyan colors[IWhite]='\033[0;97m' # White # Bold High Intensity colors[BIBlack]='\033[1;90m' # Black colors[BIRed]='\033[1;91m' # Red colors[BIGreen]='\033[1;92m' # Green colors[BIYellow]='\033[1;93m' # Yellow colors[BIBlue]='\033[1;94m' # Blue colors[BIPurple]='\033[1;95m' # Purple colors[BICyan]='\033[1;96m' # Cyan colors[BIWhite]='\033[1;97m' # White # High Intensity backgrounds colors[On_IBlack]='\033[0;100m' # Black colors[On_IRed]='\033[0;101m' # Red colors[On_IGreen]='\033[0;102m' # Green colors[On_IYellow]='\033[0;103m' # Yellow colors[On_IBlue]='\033[0;104m' # Blue colors[On_IPurple]='\033[0;105m' # Purple colors[On_ICyan]='\033[0;106m' # Cyan colors[On_IWhite]='\033[0;107m' # White color=${colors[$input_color]} white=${colors[White]} # echo $white for i in "${!colors[@]}" do echo -e "$i = ${colors[$i]}I love you$white" done 

Resultado

enter image description here

Espero que esta imagen te ayude a elegir tu color para tu fiesta: D

Para legibilidad

Si desea mejorar la legibilidad del código, primero puede hacer echo la cadena y luego agregar el color mediante el uso de sed :

 echo 'Hello World!' | sed $'s/World/\e[1m&\e[0m/' 

Mi respuesta favorita hasta ahora es de colorEcho.

Solo para publicar otra opción, puedes echar un vistazo a esta pequeña herramienta xcol

https://ownyourbits.com/2017/01/23/colorize-your-stdout-with-xcol/

lo usa igual que grep, y coloreará su stdin con un color diferente para cada argumento, por ejemplo

 sudo netstat -putan | xcol httpd sshd dnsmasq pulseaudio conky tor Telegram firefox "[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+" ":[[:digit:]]+" "tcp." "udp." LISTEN ESTABLISHED TIME_WAIT 

Ejemplo de xcol

Tenga en cuenta que acepta cualquier expresión regular que sed acepte.

Esta herramienta usa las siguientes definiciones

 #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 

Utilizo estas variables en mis scripts como tal

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

Para ampliar esta respuesta , para los perezosos de nosotros:

 function echocolor() { # $1 = string COLOR='\033[1;33m' NC='\033[0m' printf "${COLOR}$1${NC}\n" } echo "This won't be colored" echocolor "This will be colorful" 

Y esto es lo que solía ver toda la combinación y decidir qué se lee genial:

 for (( i = 0; i < 8; i++ )); do for (( j = 0; j < 8; j++ )); do printf "$(tput setab $i)$(tput setaf $j)(b=$i, f=$j)$(tput sgr0)\n" done done 

He escrito botín para lograr eso.

Puedes simplemente hacer

 pip install swag 

Ahora puede instalar todos los comandos de escape como archivos txt en un destino dado a través de:

 swag install -d  

O incluso más fácil a través de:

 swag install 

Que instalará los colores en ~/.colors .

O los usa así:

 echo $(cat ~/.colors/blue.txt) This will be blue 

O de esta manera, que encuentro realmente más interesante:

 swag print -c red -t underline "I will turn red and be underlined" 

¡Compruébalo en asciinema !

Nadie notó la utilidad del video invertido del código 7 de ANSI.

Permanece legible en cualquier esquema de terminal de colores, fondos en blanco y negro u otras paletas de fantasía, intercambiando colores de primer plano y de fondo.

Ejemplo, para un fondo rojo que funciona en todas partes:

 echo -e "\033[31;7mHello world\e[0m"; 

Así es como se ve cuando se cambian los esquemas integrados en el terminal:

enter image description here

Este es el script de bucle utilizado para el gif.

 for i in {30..49};do echo -e "\033[$i;7mReversed color code $i\e[0m Hello world!";done 

Ver https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters

Definitivamente debería usar tput sobre secuencias de control ANSI en bruto.

Debido a que hay una gran cantidad de lenguajes de control de terminales diferentes, generalmente un sistema tiene una capa de comunicación intermedia. Los códigos reales se buscan en una base de datos para el tipo de terminal actualmente detectado y se dan solicitudes estandarizadas a una API o (desde el shell) a un comando.

Uno de estos comandos es tput . tput acepta un conjunto de acrónimos llamados nombres de capacidades y cualquier parámetro, si es necesario, luego busca las secuencias de escape correctas para el terminal detectado en la base de datos terminfo e imprime los códigos correctos (el terminal comprende con suerte).

de http://wiki.bash-hackers.org/scripting/terminalcodes

Dicho esto, escribí una pequeña biblioteca auxiliar llamada bash-tint , que agrega otra capa encima de la entrada, lo que hace que sea aún más fácil de usar (imho):

Ejemplo: tint "white(Cyan(T)Magenta(I)Yellow(N)Black(T)) is bold(really) easy to use."

Daría el siguiente resultado: enter image description here

Aquí hay un pequeño script simple, que reuní recientemente, que coloreará cualquier entrada canalizada en lugar de usar “Toilet”.

File: color.bsh

 #!/usr/bin/env bash ## AMDanischewski 2015+(c) Free - for (all (uses and ## modifications)) - except you must keep this notice intact. declare INPUT_TXT="" declare ADD_LF="\n" declare -i DONE=0 declare -r COLOR_NUMBER="${1:-247}" declare -r ASCII_FG="\\033[38;05;" declare -r COLOR_OUT="${ASCII_FG}${COLOR_NUMBER}m" function show_colors() { ## perhaps will add bg 48 to first loop eventually for fgbg in 38; do for color in {0..256} ; do echo -en "\\033[${fgbg};5;${color}m ${color}\t\\033[0m"; (($((${color}+1))%10==0)) && echo; done; echo; done } if [[ ! $# -eq 1 || ${1} =~ ^-. ]]; then show_colors echo " Usage: ${0##*/} " echo " Eg echo \"Hello world!\" | figlet | ${0##*/} 54" else while IFS= read -r PIPED_INPUT || { DONE=1; ADD_LF=""; }; do PIPED_INPUT=$(sed 's#\\#\\\\#g' < << "${PIPED_INPUT}") INPUT_TXT="${INPUT_TXT}${PIPED_INPUT}${ADD_LF}" ((${DONE})) && break; done echo -en "${COLOR_OUT}${INPUT_TXT}\\033[00m" fi 

Luego llámalo con color rojo (196):
$> echo "text you want colored red" | color.bsh 196

Here is the simplest and readable solution. With bashj ( https://sourceforge.net/projects/bashj/ ), you would simply choose one of these lines:

 #!/usr/bin/bash W="Hello world!" echo $W R=130 G=60 B=190 echo u.colored($R,$G,$B,$W) echo u.colored(255,127,0,$W) echo u.red($W) echo u.bold($W) echo u.italic($W) Y=u.yellow($W) echo $Y echo u.bold($Y) 

256x256x256 colors are available if you have the color support in your terminal application.

Just as something a little out there, passing it through grep will highlight it as red (but only red). You can also use named pipes so your string is nearer to the end of the line:

  grep '.*' --color=always < (echo "foobar") 
 red='\e[0;31m' NC='\e[0m' # No Color echo -e "${red}Hello Stackoverflow${NC}" 

This answer correct, except that the call to colors should not be inside the quotes.

 echo -e ${red}"Hello Stackoverflow"${NC} 

Debería hacer el truco.