tag fondo easytag color cambiar linux bash command-line echo terminal-color

linux - fondo - easytag



Cómo cambiar el color de salida de eco en Linux (22)

Por legibilidad

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

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

Estoy intentando imprimir un texto en el terminal usando el comando echo.

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

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 carácter 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 | | | | | | |

breve ejemplo:

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

bash excepción:

Si va a utilizar estos códigos en sus 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 tendrá problemas cuando use Ctrl + r para buscar en su historial.

regla de excepción para bash

Debe agregar /[ antes de cualquier código ANSI inicial y agregar /] después 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 colocar 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 sumergirse en estos colores, debe conocer 4 modos con estos códigos:

1. modo de color

Modifica el estilo de color NO del texto. Por ejemplo, hacer que el color sea más brillante o más oscuro.

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

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

2. modo texto

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

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

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

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 bit 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 de 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 de 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 primer plano de 8 bits en un .gif

Resumen de fondo de 8 bits en un .gif

Resumen de colores con sus valores.

blinking en KDE-Terminal

Un simple código C que te muestra más.

Una herramienta más avanzada que desarrollé para tratar con estos colores:

disparo en modo de color

modo de texto disparo

combinando está bien

más disparos


Consejos y trucos para usuarios avanzados y programadores:

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

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

¿Están ralentizando la velocidad de un programa?

Creo que no.

¿Podemos usar estos en Windows?

3/4-bit Sí, si compilas 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?

Cualquier lugar que tenga un intérprete de tty
xterm , gnome-terminal , kde-terminal , mysql-client-CLI y así sucesivamente.
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 en un PATH válido y luego utilícelo donde desee.

ls | pcc
df | pcc

dentro de mysql primero regístrelo para pager y luego intente:

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

NO maneja Unicode.

¿Estos códigos solo hacen colorear?

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 esto en lugar del system(3)

¿Están disponibles en Unicode?

Sí. /u001b

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

Es fácil de usar 3/4-bit , pero es mucho más preciso y hermoso de usar de 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
Así que en html #FF0000 significa y aquí está: 255;0;0
en html #00FF00 significa que aquí es: 0;255;0
¿Tiene sentido? qué color desea combinarlo con estos tres valores de 8 bits.


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

insignias

Aquí hay un pequeño guión simple, que puse juntos, que coloreará cualquier entrada canalizada en lugar de usar "Inodoro".

File: color.bsh

#!/usr/bin/env bash ## A.M.Danischewski 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##*/} <color fg>" echo " E.g. 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

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

Definitivamente, debe utilizar tput sobre secuencias de control ANSI sin formato.

Debido a que hay una gran cantidad de lenguajes de control de terminal 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 detectado actualmente y usted da 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 denominados nombres de capacidad y cualquier parámetro, si corresponde, luego busca las secuencias de escape correctas para el terminal detectado en la base de datos de terminfo e imprime los códigos correctos (se espera que el terminal entienda).

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

Dicho esto, escribí una pequeña biblioteca de ayuda llamada bash-tint , que agrega otra capa encima de tput, haciendo 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:

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

Primero, usar tput es más portátil en entornos modernos que inyectar manualmente códigos ASCII 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:

Notas sobre la portabilidad de tput

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

tput(1) ha estado disponible en X / Open curses semantics en la década de 1990 (el estándar de 1997 tiene la semántica que se menciona a continuación).

Entonces, es ( bastante ) ubicuo.

Este es el interruptor de color /033[ . Ver la history

Los codes color son como 1;32 (verde claro), 0;34 (azul), 1;34 (azul claro), etc.

Terminamos las secuencias de colores con un interruptor de color /033[ y 0m , el código sin color. Al igual que abrir y cerrar pestañas 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!"

Estos códigos funcionan en mi caja de Ubuntu:

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 todas 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

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

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

He escrito swag para lograr precisamente eso.

Solo puedes hacer

pip install swag

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

swag install -d <colorsdir>

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

swag install

Que instalará los colores a ~/.colors .

O los usas así:

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

O de esta manera, que en realidad me parece más interesante:

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

¡Échale un vistazo a asciinema !

Mi respuesta favorita hasta ahora es ColouredEcho.

Solo para publicar otra opción, puedes revisar esta pequeña herramienta xcol

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

lo usas como 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

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

Esta herramienta utiliza 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

Yo uso estas variables en mis scripts como tal

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

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

Permanece legible en cualquier color de esquemas de terminal, fondos blancos o negros u otras paletas de fantasía, intercambiando los colores de fondo y de primer plano.

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

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

Así es como se ve al cambiar los esquemas incorporados del terminal:

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

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"

Puede utilizar 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 úsalos así en tu guión:

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

que imprime el love en rojo.

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

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

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

Puedes 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

Los sub-comandos específicos de tput se discuten más adelante.

Directo

Llame a tput como parte de una secuencia de comandos:

tput setaf 1; echo "this is red text"

Utilizar En lugar de && si el error sigue tput , el texto sigue tput .

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 como que tienen un significado especial. No serán mostrados ellos mismos. Tenga en cuenta que aún pueden guardarse en archivos o procesarse como entrada por otros programas que no sean el terminal.

Sustitución de comandos

Puede ser más conveniente insertar la salida de tput directamente en sus cadenas de echo utilizando 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:

Comandos de color de fondo 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 R G B 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, no se dan 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 Y X # 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 wobbly windows , 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 canalizándola:

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 lista en la columna Cap-name de la enorme tabla que comienza en la línea 81).

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 puedes usar directamente los códigos de colores mencionados en la respuesta de Drew :

coloredEcho "This text is green" 2

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

echo "$(tput setaf 1)Hello, world$(tput sgr0)"

Utilice tput para calcular los códigos de color. Evite usar el código de escape ANSI (por ejemplo, /E[31;1m para 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"

Y esto es lo que solía ver todas las combinaciones y decidir cuál lee mejor:

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

Al igual que algo un poco por ahí, pasarlo a través de grep lo destacará como rojo (pero solo rojo). También puedes usar tuberías con nombre para que tu cadena esté más cerca del final de la línea:

grep ''.*'' --color=always <(echo "foobar")

Aquí está la solución más simple y legible. Con bashj ( https://sourceforge.net/projects/bashj/ ), simplemente elegiría una de estas líneas:

#!/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 Los colores están disponibles si tiene el soporte de color en su aplicación de terminal.

echo -e "/033[31m Hello World"

El [31m controla el color del texto:

  • 30 - 37 sets de color de primer plano
  • 40 - 47 sets de color de fondo

Una lista más completa de códigos de color se puede encontrar aquí .

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

red=''/e[0;31m'' NC=''/e[0m'' # No Color echo -e "${red}Hello ${NC}"

Esta respuesta es correcta, excepto que la llamada a los colores no debe estar dentro de las comillas.

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

Debería hacer el truco.