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

Quiero imprimir el texto en 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 ú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)

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:

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

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

resumen de fondo de 8 bits en una .gif

resumen de color con sus valores

blinking en KDE-Terminal

un Ccódigo simple que te muestra más

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

disparo en modo de color

disparo en modo texto

combinar 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. Yo experimenté engolpetazo, C, c ++, re perl, pitón

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

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 conhtmlasí 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, enhtml #FF0000significa y aquí está: 255;0;0
enhtml #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

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

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

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.

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"

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

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

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"

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:

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.

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 imagen te ayude a elegir tu color para tu fiesta: D

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

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

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

Ejemplo de texto rojo y etiqueta de cierre:

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

Generador:

text.addEventListener("input",update)
back.addEventListener("input",update)

function update(){
  let a = text.value.substr(1).match(/.{1,2}/g)
  let b = back.value.substr(1).match(/.{1,2}/g)
  out1.textContent = "echo -e \"\\" + `033[38;2;${parseInt(a[0],16)};${parseInt(a[1],16)};${parseInt(a[2],16)}mHello\"`
  out2.textContent = "echo -e \"\\" + `033[48;2;${parseInt(b[0],16)};${parseInt(b[1],16)};${parseInt(b[2],16)}mWorld!\"`
}

div {padding:1rem;font-size:larger}

TEXT COLOR: <input type="color" id="text" value="#23233">
<br><div id="out1"></div>
BACK COLOR: <input type="color" id="back" value="#FFFF00">
<br><div id="out2">

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:

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

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

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

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

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

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

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"

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

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:

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

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.

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

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 !

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

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

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.

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

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

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.