Cómo cambiar el color de salida de echo en Linux


Respuestas:


2297

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 úsalos así en tu 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 loveen rojo.

Según el comentario de @ james-lim, si está utilizando el echocomando, 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)


11
No funciona para mí - salida:\e[0;31mHello Stackoverflow\e[0m
Ben Harold

172
¿Lo probaste con "-e"? Le indica echoque habilite los escapes de barra invertida.
James Lim

142
En MacOSX, usando en \x1Blugar de \e. \033estaría bien para todas las plataformas.
Xiao

44
En un archivo de propiedades de hormiga, use unicode para esacpe, por ejemplo, rojo = \ u001b [0; 31m
usuario de shonky linux el

20
Como msanford hecho para tput, aquí está el "ANSI-Rainbow"for (( i = 30; i < 38; i++ )); do echo -e "\033[0;"$i"m Normal: (0;$i); \033[1;"$i"m Light: (1;$i)"; done
todos los

971

Puede usar el increíble tputcomando (sugerido en la respuesta de Ignacio ) para producir códigos de control de terminal para todo tipo de cosas.


Uso

Los tputsubcomandos específicos se analizan más adelante.

Directo

Llamar tputcomo parte de una secuencia de comandos:

tput setaf 1; echo "this is red text"

Use en ;lugar de &&hacerlo si hay tputerrores que el texto aún 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}"

tputproduce secuencias de caracteres que el terminal interpreta como que tienen un significado especial. No se mostrarán ellos mismos. Tenga en cuenta que aún pueden guardarse en archivos o procesarse como entrada por programas que no sean el terminal.

Sustitución de comandos

Puede ser más conveniente insertar tputla salida directamente en sus echocadenas 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 en 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         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 (en setblugar de setab, y en setflugar de setaf) que usan números diferentes, no dados 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 belcomando hace que el terminal tambalee por un segundo para llamar la atención del usuario.


Guiones

tputacepta scripts que contienen un comando por línea, que se ejecutan en orden antes de tputsalir.

Evite 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 terminfola lista completa de comandos y más detalles sobre estas opciones. (El tputcomando correspondiente aparece en la Cap-namecolumna de la tabla enorme que comienza en la línea 81).

13
Gran respuesta. Este es el que más me ayudó. Para cualquiera que se preguntara qué me preguntaba, $()es una sustitución de comando . Todo lo que tput af 1hace es generar la cadena de código de color, pero los códigos no son caracteres imprimibles, por lo que escribir tput af 1solo producirá una línea de salida en blanco.
Chris Middleton

55
Nota: si está utilizando CygWin y no tiene la instalación de tputncurses
Enrico

3
tput también funciona dentro de sed para analizar cruft en legible, colorido cruft: gist.github.com/nickboldt/fab71da10bd5169ffdfa
nickboldt

1
Para obtener una lista completa de los tputcolores, consulte esta respuesta en Unix StackExchange
Andrew

Creo que reset=`tput sgr0`debería ser reset=`tput sgr 0`, con un espacio.
monkeypants

836

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

excepción bash:

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 puede interpretarlos correctamente. Sin que esto agregue caracteres de escape adicionales, funciona, pero enfrentará problemas cuando utilice la Ctrl + rbúsqueda en su historial.

regla de excepción para bash

Debe agregar \[antes de cualquier código ANSI inicial y agregar \]después de cualquier código final.
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 no imprimibles caracteres
\]es para final de una secuencia de no imprimibles caracteres

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 bit

Antes de sumergirse en estos colores, debe conocer 4 modos con estos códigos:

1. modo de color

Modifica el estilo de color, NO el texto. Por ejemplo, haga el color brillante u oscuro.

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

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

2. modo 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; contrarrestar
  • 8; esconder
  • 9; tachado

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

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 de ANSI-color

|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
| 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[33m |         |       | yellow           | echo -e "\033[33m####\033[m" |                                      |
|         34 | \033[34m |         |       | blue             | echo -e "\033[34m####\033[m" |                                      |
|         35 | \033[35m |         |       | purple           | echo -e "\033[35m####\033[m" | real name: magenta = reddish-purple  |
|         36 | \033[36m |         |       | cyan             | echo -e "\033[36m####\033[m" |                                      |
|         37 | \033[37m |         |       | 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 ANSI-color

|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
| 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 ANSI-color

|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
| 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 una .gif

foreground.gif

resumen de fondo de 8 bits en una .gif

background.gif

resumen de color con sus valores

ingrese la descripción de la imagen aquí ingrese la descripción de la imagen aquí ingrese la descripción de la imagen aquí ingrese la descripción de la imagen aquí

blinking en KDE-Terminal

Parpadeo de KDE

un Ccódigo simple que te muestra más

cecho_screenshot

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

bline


disparo en modo de color

desvanecimiento-normal-brillante

disparo en modo texto

modo de solo texto

combinar está bien

combinar

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. Yo experimenté en, , , ,

¿Disminuyen la velocidad de un programa?

Creo que no.

¿Podemos usar estos en Windows?

3/4 bits Sí, si compila 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 ttyintérprete
xterm, gnome-terminal, kde-terminal, mysql-client-CLIy así sucesivamente.
Por ejemplo, si desea colorear su salida con mysql, puede usarPerl

#!/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;

guarde este código en un nombre de archivo: pcc(= Perl Colorize Character) y luego coloque el archivo a válido y PATHluego úselo en cualquier lugar que desee.

ls | pcc
df | pcc

adentro mysqlprimero regístralo pagery luego prueba:

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

pcc

No NO manejar 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 system( "clear" )para que pueda usar esto en lugar de system(3)llamar

¿Están disponibles en Unicode?

Si. \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 24-bit.
Si no tienes experiencia conasí que aquí hay un tutorial rápido:
24 bits significa: 00000000y 00000000y 00000000. Cada 8 bits es para un color específico.
1..8es por y 9..16para y 17..24por
lo tanto, en #FF0000significa y aquí está: 255;0;0
en #00FF00 ¿Qué significa aquí? 0;255;0
¿Tiene sentido? de qué color quieres combinarlo con estos tres valores de 8 bits.


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


70
¿Nadie más está realmente sorprendido por esta respuesta?
Benj

14
Esta es definitivamente la respuesta del salón de la fama, gracias.
ForeverZer0

2
@NeilGuyLindberg no hay literales octales este error es parte de Node.js no eslist en sí mismo. puedes usar x1B[para eliminarlo.
Shakiba Moshiri

55
¡Volví bastante lejos para votar esta respuesta!
ARN

1
Parece que @ShakibaMoshiri escribió una tesis sobre este tema xD Bromas aparte, ¡aplaude por una respuesta tan detallada!
SH '

189

Usar tputcon la setafcapacidad y un parámetro de 1.

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

8
Esta debería ser la mejor opción. lo que hace tput es leer la información del terminal y generar el código ANSI correctamente escapado para usted. código como \033[31mromperá la biblioteca readline en algunos de los terminales.
Tian Chen

44
Explore los colores con un bucle simple (aumente iel límite superior para obtener más sombras):for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done
msanford

2
Aquí hay un CÓMO sobre los códigos tput
maxywb

tput: command not found(en alpino)
dgallant

127
echo -e "\033[31m Hello World"

El [31mcontrola el color del texto:

  • 30- 37establece el color de primer plano
  • 40- 47establece el color de fondo

Puede encontrar una lista más completa de códigos de colores aquí .

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


2
echo -e "\ 033 [31m Hello World", el [31m es el color
neocanable

36

Acabo de amalgamar las buenas capturas en todas las soluciones y terminé con:

cecho(){
    RED="\033[0;31m"
    GREEN="\033[0;32m"
    YELLOW="\033[1;33m"
    # ... ADD MORE COLORS
    NC="\033[0m" # No Color

    printf "${!1}${2} ${NC}\n"
}

Y puedes llamarlo así:

cecho "RED" "Helloworld"

1
Muy práctico, solo tuve que reemplazar las comillas simples con comillas dobles para VERDE, AMARILLO, NC para que funcione en mi script.
ionescu77

1
¡Gran solución!
David Kariuki

31

Este es el cambio de color \033[ . Ver 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 0mel 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}"

echoSolución de función de 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!"

1
Cambiaría la última textvariable de text="$color${@: 2}${code}0m"esta manera, se coloreará toda la línea excepto el parámetro de color.
Shairon Toledo

@tomazahlin solo agrega -e al eco, como varias veces se mencionó anteriormente
Artem Medvedev

28

Una forma ordenada de cambiar el color solo para uno echoes 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

Si agrega -nal eco, puede usarlo como colorante en líneaecho "Red `coloredEcho "fox" red` jumps over the lazy dog"
sobi3ch

23

Use tputpara calcular códigos de colores. Evite usar el código de escape ANSI (por ejemplo, \E[31;1mpara 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"

18

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

El primer uso tputes más portátil en entornos modernos que la inyección manual de códigos ASCII a través deecho -E

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

 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 verde audaz

Notas sobre la portabilidad de tput

El primer tput(1)código fuente se cargó en septiembre de 1986.

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

Entonces, es ( bastante ) ubicuo.


¡Esto está muy bien! No sabia esto. ¿Puedes decir algo sobre la disponibilidad de tput? ¿Está disponible en la mayoría de los servidores donde uno no tiene derechos de administrador para instalarlo? ¿Tiene un enlace a donde esta técnica fue 'inventada' por primera vez?
Redsandro

3
tput es la forma de hacer esto que cumple con los estándares, donde es completamente independiente de que usted conozca las capacidades del terminal. Si el terminal no admite una capacidad dada, se degradará con gracia a lo que sea que pueda hacer sin eliminar los códigos de escape atornillados.
Ahmed Masud

1
He dejado de usar este método, ya que se mete con la posición del cursor en las líneas bash. Se ajustará aleatoriamente antes del final de la línea, y no volverá al principio de la línea cuando se use el inicio o las teclas de flecha. Volver a los torpes códigos de escape manuales soluciona este problema.
Redsandro

2
@Resandro: ¿es porque lo estás usando $PS1sin \[...\]las partes que no están separadas ? Continúe usando los marcadores Bash PS1 con las cadenas tput.
Toby Speight

Tenga en cuenta que esta función no funciona completamente en MacOsX debido a las diferencias en la utilidad sed: unix.stackexchange.com/questions/13711/…
Jeff

14

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

ingrese la descripción de la imagen aquí

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


Cabe señalar que esto requiere bash v4.
Synox

14

Si está usando zshobash

black() {
    echo -e "\e[30m${1}\e[0m"
}

red() {
    echo -e "\e[31m${1}\e[0m"
}

green() {
    echo -e "\e[32m${1}\e[0m"
}

yellow() {
    echo -e "\e[33m${1}\e[0m"
}

blue() {
    echo -e "\e[34m${1}\e[0m"
}

magenta() {
    echo -e "\e[35m${1}\e[0m"
}

cyan() {
    echo -e "\e[36m${1}\e[0m"
}

gray() {
    echo -e "\e[90m${1}\e[0m"
}

black 'BLACK'
red 'RED'
green 'GREEN'
yellow 'YELLOW'
blue 'BLUE'
magenta 'MAGENTA'
cyan 'CYAN'
gray 'GRAY'

Probar en línea


14

¡Podemos usar colores verdaderos de 24 Bits RGB para texto y fondo!

 ESC[38;2;⟨r⟩;⟨g⟩;⟨bm  /*Foreground color*/
 ESC[48;2;⟨r⟩;⟨g⟩;⟨bm  /*Background color*/

Ejemplo de texto rojo y etiqueta de cierre:

 echo -e "\e[38;2;255;0;0mHello world\e[0m"

Generador:

24 bits: a medida que las tarjetas gráficas de "color verdadero" con 16 a 24 bits de color se hicieron comunes, Xterm, Konsole de KDE, así como todos los terminales basados ​​en libvte (incluido el Terminal GNOME) admiten la configuración de color de primer plano y fondo de 24 bits https: / /en.wikipedia.org/wiki/ANSI_escape_code#24-bit

¿Es seguro usarlo en mis scripts?

¡Si! Los terminales de 8 y 16 bits solo mostrarán un color alternativo en el rango de la paleta disponible, manteniendo el mejor contraste, ¡sin roturas!


Además, nadie notó la utilidad del video invertido del código 7 de ANSI .

Sigue siendo legible en cualquier combinación de colores de terminales, 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 al cambiar los esquemas integrados del terminal:

ingrese la descripción de la imagen aquí

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


11

Estos códigos funcionan en mi caja de Ubuntu:

ingrese la descripción de la imagen aquí

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

ingrese la descripción de la imagen aquí


2
Por cierto: ¡Esto no depende mucho de haber instalado una versión específica de ubuntu, sino de usar PuTTY!
urzeit

11

Encontré la increíble respuesta de Shakiba Moshiri mientras buscaba información sobre ese tema ... luego tuve una idea ... y terminó en una función bastante agradable extremadamente fácil de usar 😁
Así que tengo que compartirla 😉

https://github.com/ppo/bash-colors

Uso: $(c <flags>) dentro de un echo -eoprintf

 ┌───────┬─────────────────┬──────────┐   ┌───────┬─────────────────┬──────────┐
  Code   Style            Octal        Code   Style            Octal    
 ├───────┼─────────────────┼──────────┤   ├───────┼─────────────────┼──────────┤
    -    Foreground       \033[3..       B    Bold             \033[1m  
    _    Background       \033[4..       U    Underline        \033[4m  
 ├───────┼─────────────────┼──────────┤      F    Flash/blink      \033[5m  
    k    Black            ......0m       N    Negative         \033[7m  
    r    Red              ......1m    ├───────┼─────────────────┼──────────┤
    g    Green            ......2m       L    Normal (unbold)  \033[22m 
    y    Yellow           ......3m       0    Reset            \033[0m  
    b    Blue             ......4m    └───────┴─────────────────┴──────────┘
    m    Magenta          ......5m 
    c    Cyan             ......6m 
    w    White            ......7m 
 └───────┴─────────────────┴──────────┘

Ejemplos:

echo -e "$(c 0wB)Bold white$(c) and normal"
echo -e "Normal text… $(c r_yB)BOLD red text on yellow background… $(c _w)now on
  white background… $(c 0U) reset and underline… $(c) and back to normal."

10

Por legibilidad

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

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

1
¡Realmente me gusta esta respuesta! ¿Puede explicar por favor el $ en el comando sed?
Patrick

2
El $ '<something>' es para bash, no sed. Le dice a bash que procese el \ e como una secuencia de escape, y ponga un carácter de "escape". Por lo general, verá las formas más simples como $ '\ t' o $ '\ n' para obtener una pestaña o un carácter de nueva línea pasado a un mando.
dsz

8

Mi respuesta favorita hasta ahora es coloredEcho.

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

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

lo usa 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

ejemplo de xcol

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

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

Yo uso estas variables en mis scripts así

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

6

Para ampliar esta respuesta , para los flojos 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"

2
No codifique los escapes de terminales. Uso tput; para eso es!
Toby Speight

@TobySpeight Aunque eso puede ser cierto para el soporte multiplataforma (en teoría), si el póster encuentra que funciona en su propio mundo, ¿por qué no estar de acuerdo y disuadir a otros en un mundo similar de usar la técnica? Caso en cuestión estoy intentando similar en Ubuntu 16.04 bash y funciona. Como el único usuario en esta plataforma, encuentro aceptable esta respuesta. También usaré tputpara scy rcaunque (guardar cursor, restaurar cursor). Aunque esta respuesta me llama "vago", podría reformularse como "práctico" o "directo al grano".
WinEunuuchs2Unix

Mi propia solución fue similar a esta, confinada exclusivamente a los componentes integrados de shell, porque bifurcar dos procesos externos, subcapas, etc. para cada mensaje en un script simplemente tenía un olor desagradable.
Amit Naidu

6

para mostrar la salida del mensaje con un color diferente que puede hacer:

echo -e "\033[31;1mYour Message\033[0m"

-Negro 0; 30 Gris oscuro 1; 30

-Rojo 0; 31 rojo claro 1; 31

-Verde 0; 32 Verde claro 1; 32

-Marrón / Naranja 0; 33 Amarillo 1; 33

-Azul 0; 34 Azul claro 1; 34

-Púrpura 0; 35 Púrpura claro 1; 35

-Cyan 0; 36 Cian claro 1; 36

-Gris claro 0; 37 Blanco 1; 37


5

Definitivamente debe usar tput sobre secuencias de control ANSI sin procesar.

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. tputacepta un conjunto de acrónimos llamados 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 terminfo e imprime los códigos correctos (es de esperar que el terminal comprenda).

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 tput, lo que hace que sea aún más fácil de usar (en mi humilde opinión):

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

Daría el siguiente resultado: ingrese la descripción de la imagen aquí


5

En lugar de codificar códigos de escape específicos de su terminal actual, debería usar tput .

Este es mi script de demostración favorito:

#!/bin/bash

tput init

end=$(( $(tput colors)-1 ))
w=8
for c in $(seq 0 $end); do
    eval "$(printf "tput setaf %3s   " "$c")"; echo -n "$_"
    [[ $c -ge $(( w*2 )) ]] && offset=2 || offset=0
    [[ $(((c+offset) % (w-offset))) -eq $(((w-offset)-1)) ]] && echo
done

tput init

256 colores de salida por tput


4

Estoy usando esto para imprimir en color

#!/bin/bash
#--------------------------------------------------------------------+
#Color picker, usage: printf $BLD$CUR$RED$BBLU'Hello World!'$DEF     |
#-------------------------+--------------------------------+---------+
#       Text color        |       Background color         |         |
#-----------+-------------+--------------+-----------------+         |
# Base color|Lighter shade| Base color   | Lighter shade   |         |
#-----------+-------------+--------------+-----------------+         |
BLK='\e[30m'; blk='\e[90m'; BBLK='\e[40m'; bblk='\e[100m' #| Black   |
RED='\e[31m'; red='\e[91m'; BRED='\e[41m'; bred='\e[101m' #| Red     |
GRN='\e[32m'; grn='\e[92m'; BGRN='\e[42m'; bgrn='\e[102m' #| Green   |
YLW='\e[33m'; ylw='\e[93m'; BYLW='\e[43m'; bylw='\e[103m' #| Yellow  |
BLU='\e[34m'; blu='\e[94m'; BBLU='\e[44m'; bblu='\e[104m' #| Blue    |
MGN='\e[35m'; mgn='\e[95m'; BMGN='\e[45m'; bmgn='\e[105m' #| Magenta |
CYN='\e[36m'; cyn='\e[96m'; BCYN='\e[46m'; bcyn='\e[106m' #| Cyan    |
WHT='\e[37m'; wht='\e[97m'; BWHT='\e[47m'; bwht='\e[107m' #| White   |
#-------------------------{ Effects }----------------------+---------+
DEF='\e[0m'   #Default color and effects                             |
BLD='\e[1m'   #Bold\brighter                                         |
DIM='\e[2m'   #Dim\darker                                            |
CUR='\e[3m'   #Italic font                                           |
UND='\e[4m'   #Underline                                             |
INV='\e[7m'   #Inverted                                              |
COF='\e[?25l' #Cursor Off                                            |
CON='\e[?25h' #Cursor On                                             |
#------------------------{ Functions }-------------------------------+
# Text positioning, usage: XY 10 10 'Hello World!'                   |
XY () { printf "\e[$2;${1}H$3"; }                                   #|
# Print line, usage: line - 10 | line -= 20 | line 'Hello World!' 20 |
line () { printf -v _L %$2s; printf -- "${_L// /$1}"; }             #|
# Create sequence like {0..(X-1)}                                    |
que () { printf -v _N %$1s; _N=(${_N// / 1}); printf "${!_N[*]}"; } #|
#--------------------------------------------------------------------+

Todos los colores básicos se configuran como variables y también hay algunas funciones útiles: XY, línea y que. Obtenga este script en uno de los suyos y use todos los colores y funciones.


3

Y esto es lo que solía ver toda combinación y decidir qué lecturas son geniales:

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

2

He escrito botín para lograr 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 me parece más interesante:

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

¡ Míralo en asciinema !


0

Aquí hay una pequeña secuencia de comandos simple, que reuní recientemente, que coloreará cualquier entrada canalizada en lugar de usar "Toilet".

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 

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


La lógica del bucle de color se encontró en este decente tutorial de colores Ascii: misc.flogisoft.com/bash/tip_colors_and_formatting

-1

Referirse a:

echo_red(){
    echo -e "\e[1;31m$1\e[0m"
}
echo_green(){
    echo -e "\e[1;32m$1\e[0m"
}
echo_yellow(){
    echo -e "\e[1;33m$1\e[0m"
}
echo_blue(){
    echo -e "\e[1;34m$1\e[0m"
}

Tenga en cuenta que la función echo_green debe tener el código 32 en lugar de 33. No se puede editar el flujo de sobrecarga de b / c requiere al menos 6 caracteres de edición.
Daniel

-2

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.


-3

después de mezclar otras soluciones de hilo, así es como logré obtener colores en la npm scriptssalida (CLI de gitbash):

{
    "deploy": "echo \u001b[1;32m && ng build && echo \u001b[1;0mdeploy {\u001b[1;33mcopy\u001b[1;0m: \u001b[1;32m0% && cp -r -f dist/packaged/* \\\\SERVER-01\\dist\\ && echo \u001b[1;0mdeploy {\u001b[1;33mcopy\u001b[1;0m} \u001b[1;34m\u001b[1;1m100% DEPLOYED"
}

ingrese la descripción de la imagen aquí


-4

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

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

te estás perdiendo el punto de poder seleccionar el color de tu elección. También grep como utilidad para colorear es realmente cuestionable: P
Ahmed Masud

En realidad no, OP mencionó específicamente que querían rojo. Estoy de acuerdo en que hay mejores opciones que usar grep, pero logra lo que pidieron y ahorra tener que aprender algo más complejo.
FinalDuty

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

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

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

Debería hacer el truco.


3
Funciona bien dentro de las comillas. el modificador -e evalúa también lo que hay entre comillas. La ejecución de ambas (comillas internas y externas) con bash -x genera el mismo comando ejecutado echo -e '\e[0;31mHello Stackoverflow\e[0m'. Entonces es lo mismo para bash.
naab
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.