Вы можете использовать эти 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

А затем используйте их в своем скрипте следующим образом:

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

который печатает love красным.

Из комментария @ james-lim: если вы используете команду echo, обязательно используйте флаг -e, чтобы разрешить экранирование обратной косой черты.

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

(не добавляйте "\n" при использовании echo, если вы не хотите добавить дополнительную пустую строку)

Вы можете использовать замечательную команду tput (предложенную в ответе Игнасио) для создания управляющих кодов терминала для всех видов вещей.

использование

Конкретные tput подкоманды обсуждаются позже.

Прямой

Вызов tput как часть последовательности команд:

tput setaf 1; echo "this is red text"

Используйте ; вместо &&, чтобы при tput ошибках текст все равно отображался.

Переменные оболочки

Другой вариант - использовать переменные оболочки:

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

tput создает последовательности символов, которые интерпретируются терминалом как имеющие особое значение. Они не будут показываться. Обратите внимание, что они все еще могут быть сохранены в файлы или обработаны как ввод другими программами, кроме терминала.

Подстановка команд

Может быть удобнее вставлять вывод tput непосредственно в ваши echo строки, используя подстановку команд :

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

Пример

Приведенная выше команда производит это в Ubuntu:

Команды цвета переднего плана и фона

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

Цвета следующие:

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

Существуют также не-ANSI версии функций настройки цвета (setb вместо setab и setf вместо setaf), в которых используются другие числа, не указанные здесь.

Команды текстового режима

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

Команды перемещения курсора

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

Очистить и вставить команды

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

Прочие команды

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

При компилировать шаткие окна команда bel заставляет терминал на секунду покачиваться, чтобы привлечь внимание пользователя.

Скрипты

tput принимает сценарии, содержащие по одной команде в строке, которые выполняются по порядку до tput выхода.

Избегайте использования временных файлов, отображая многострочную строку и передавая ее по конвейеру:

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

Смотрите также

• См. man 1 tput.
• См. man 5 terminfo для получения полного списка команд и дополнительных сведений об этих параметрах. (Соответствующая команда tput указана в столбце Cap-name огромной таблицы, которая начинается со строки 81.)

некоторые переменные, которые вы можете использовать:

# 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

escape-символ в bash, шестнадцатеричном и восьмеричном соответственно:

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

краткий пример:

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

исключение bash:

Если вы собираетесь использовать эти коды в своих специальных переменных bash

• PS0
• PS1
• PS2 (= это для подсказки)
• PS4

вам следует добавить дополнительные escape-символы, чтобы bash мог интерпретировать их правильно. Без добавления дополнительных escape-символов он работает, но вы столкнетесь с проблемами при использовании Ctrl + r для поиска в своей истории.

правило исключения для bash

Вы должны добавить \[ перед любым начальным кодом ANSI и добавить \] после любых завершающих.
Пример:
при обычном использовании: \033[32mThis is in green\033[0m
для PS0 / 1/2/4: \[\033[32m\]This is in green\[\033[m\]

\[ обозначает начало последовательности непечатаемых символов.
\] обозначает конец последовательности непечатаемых символов.

Совет: для запоминания вы можете сначала добавить \[\], а затем поместить между ними свой код ANSI:

• \[start-ANSI-code\]
• \[end-ANSI-code\]

тип цветовой последовательности:

1. 3/4 бит
2. 8 бит
3. 24 бит

Прежде чем погрузиться в эти цвета, вы должны знать о 4 режимах с этими кодами:

1. цветовой режим

Он изменяет стиль цвета НЕ текста. Например, сделайте цвет ярче или темнее.

• 0 сбросить
• 1; легче обычного
• 2; темнее обычного

Этот режим широко не поддерживается. Он полностью поддерживается Gnome-Terminal.

2. текстовый режим

Этот режим предназначен для изменения стиля текста, а НЕ цвета.

• 3; курсив
• 4; подчеркивание
• 5; мигает (медленно)
• 6; мигает (быстро)
• 7; реверс
• 8; скрыть
• 9; зачеркнутый

и почти поддерживаются.
Например, KDE-Konsole поддерживает 5;, а Gnome-Terminal - нет, а Gnome поддерживает 8;, а KDE - нет.

3. режим переднего плана

Этот режим предназначен для раскрашивания переднего плана.

4. фоновый режим

Этот режим предназначен для раскрашивания фона.

В приведенной ниже таблице представлена ​​сводка 3/4-битной версии 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                                            |                                                                                       |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|

В приведенной ниже таблице представлена ​​сводка 8-битной версии 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     |
|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|

8-битный быстрый тест:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

В приведенной ниже таблице представлена ​​сводка 24-битной версии 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 |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|

несколько скриншотов

8-битная сводка переднего плана в .gif

фоновое 8-битное резюме в .gif

цветная сводка с их значениями

blinking в KDE-Terminal

цветной снимок

текстовый режим выстрел

комбинирование в порядке

другие снимки

Советы и рекомендации для продвинутых пользователей и программистов:

Можем ли мы использовать эти коды на языке программирования?

Да, ты можешь. Я испытал bash, c, c ++, d perl, python

Они замедляют скорость работы программы?

Я думаю нет.

Можем ли мы использовать их в Windows?

3/4 бит. Да, если вы скомпилируете код с gcc
снимками экрана на Win- 7

Как рассчитать длину кода?

\033[ = 2, остальные части 1

Где мы можем использовать эти коды?

Везде, где есть tty интерпретатор
xterm, gnome-terminal, kde-terminal, mysql-client-CLI и так далее.
Например, если вы хотите раскрасить свой вывод с помощью mysql, вы можете использовать Perl

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

сохраните этот код в имени файла: pcc (= Perl Colorize Character), а затем поместите файл в допустимый PATH, затем используйте его где угодно.

ls | pcc
df | pcc

внутри mysql сначала зарегистрируйте его для pager, а затем попробуйте:

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

Он НЕ обрабатывает Юникод.

Эти коды только раскрашивают?

Нет, они умеют много интересного. Пытаться:

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

or:

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

Многие новички хотят очистить экран с помощью system( "clear" ), поэтому вы можете использовать это вместо вызова system(3).

Доступны ли они в Юникоде?

да. \u001b

Какой вариант этих цветов предпочтительнее?

Это легко использовать 3/4-bit, но очень точно и красиво использовать 24-bit.
Если у вас нет опыта работы с html, поэтому вот краткое руководство:
24 бита означают: 00000000 и 00000000 и 00000000. Каждые 8 ​​бит предназначены для определенного цвета.
1..8 для и 9..16 для и 17..24 для
Итак, в html #FF0000 означает и вот это это: 255;0;0
в html #00FF00 означает который здесь: 0;255;0 < br /> Это имеет смысл? какой цвет вы хотите объединить с этими тремя 8-битными значениями.

ссылка:
Википедия
escape-последовательности ANSI
tldp.org
tldp.org
misc.flogisoft.com
некоторые блоги / веб-страницы, которые я не помню

Используйте tput с возможностью setaf и параметром 1.

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

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

[31m управляет цветом текста:

• _3 _-_ 4_ устанавливает цвет переднего плана
• _5 _-_ 6_ устанавливает цвет фона

Более полный список цветовых кодов можно найти здесь.

Рекомендуется сбросить цвет текста обратно на \033[0m в конце строки.

Я только что объединил хорошие уловы во всех решениях и в итоге получил:

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

И вы можете просто назвать это так:

cecho "RED" "Helloworld"

Это переключатель цвета \033[. См. историю.

Цвет коды похож на 1;32 (светло-зеленый) , 0;34 (синий), 1;34 (голубой) и т. Д.

Мы завершаем цветовые последовательности переключателем цвета \033[ и 0m, нет -цветного кода. Точно так же, как открытие и закрытие вкладок на языке разметки.

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

Простое цветовое решение echo функции:

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

Изящный способ изменить цвет только для одного echo - определить такую ​​функцию:

function coloredEcho(){
    local exp=$1;
    local color=$2;
    if ! [[ $color =~ '^[0-9]$' ]] ; then
       case $(echo $color | tr '[:upper:]' '[:lower:]') in
        black) color=0 ;;
        red) color=1 ;;
        green) color=2 ;;
        yellow) color=3 ;;
        blue) color=4 ;;
        magenta) color=5 ;;
        cyan) color=6 ;;
        white|*) color=7 ;; # white or invalid color
       esac
    fi
    tput setaf $color;
    echo $exp;
    tput sgr0;
}

Использование:

coloredEcho "This text is green" green

Или вы можете напрямую использовать цветовые коды, упомянутые в ответе Дрю:

coloredEcho "This text is green" 2

Мой рифф на ответ Тобиаса:

# Color
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
NC='\033[0m' # No Color

function red {
    printf "${RED}$@${NC}\n"
}

function green {
    printf "${GREEN}$@${NC}\n"
}

function yellow {
    printf "${YELLOW}$@${NC}\n"
}

Используйте tput для расчета цветовых кодов. Избегайте использования escape-кода ANSI (например, \E[31;1m для красного), потому что он менее переносим. Например, Bash в OS X не поддерживает его.

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"

Я нашел потрясающий ответ Шакибы Мошири, пока искал информацию по этой теме ... потом у меня возникла идея ... и в итоге получилась довольно приятная функция, чрезвычайно простая в использовании ????
Итак, я должен поделиться ею ????

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

Использование: $(c <flags>) внутри echo -e или printf

 ┌───────┬─────────────────┬──────────┐   ┌───────┬─────────────────┬──────────┐
 │ 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 │
 └───────┴─────────────────┴──────────┘

Примеры:

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

На этот вопрос отвечали снова и снова :-), но почему бы и нет.

Первое использование tput более переносимо в современных средах, чем ввод кодов ASCII вручную через echo -E

Вот быстрая функция bash:

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

Теперь вы можете использовать:

 say @b@green[[Success]] 

получить:

Примечания по переносимости tput

Впервые tput(1) исходный код был загружен в сентябре 1986 г.

tput(1) был доступен в семантике X / Open curses в 1990-х годах (стандарт 1997 года имеет семантику, упомянутую ниже).

Так что это (довольно) повсеместно.

Если вы используете zsh или bash

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'

Попробуйте в Интернете

Спасибо @ k-five за этот ответ

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

Результат

Надеюсь, это изображение поможет вам выбрать цвет для вашего bash: D

Мы можем использовать 24-битные истинные цвета RGB как для текста, так и для фона!

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

Пример красного текста и закрывающего тега:

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

Generator:

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-битный: по мере того, как графические карты «истинного цвета» с 16–24 битами цвета стали обычным явлением, Xterm, KDE Konsole, а также все терминалы на основе libvte (включая терминал GNOME) поддерживают 24-битный передний план. и настройка цвета фона https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit

Насколько безопасно использовать в моих скриптах?

Да! 8- и 16-битные терминалы будут отображать только резервный цвет в диапазоне доступной палитры, сохраняя наилучший контраст, без поломок!

Кроме того, никто не заметил полезности кода ANSI 7 перевернутого видео.

Он остается читаемым на любых цветах схем терминала, черном или белом фоне или других палитрах фантазии, меняя местами цвета переднего плана и фона.

Пример для красного фона, который работает везде:

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

Вот так это выглядит при изменении встроенных схем терминала:

Это сценарий цикла, используемый для гифки.

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

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

I вместо управляющих кодов жесткого кодирования, специфичных для вашего текущего терминала, вы должны использовать tput.

Это мой любимый демонстрационный скрипт:

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

Эти коды работают на моем компьютере с 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"

Это напечатает буквы a b c d разными цветами:

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

Для цикла:

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

Для удобочитаемости

Если вы хотите улучшить читаемость кода, вы можете сначала echo строку, а затем добавить цвет, используя sed:

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

Пока что мой любимый ответ - colorEcho.

Чтобы опубликовать еще один вариант, вы можете проверить этот небольшой инструмент xcol

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

вы используете его так же, как grep, и он раскрасит свой стандартный ввод другим цветом для каждого аргумента, например

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

Обратите внимание, что он принимает любое регулярное выражение, которое примет sed.

Этот инструмент использует следующие определения

#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

Я использую эти переменные в своих скриптах вот так

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

чтобы показать вывод сообщения другим цветом, вы можете сделать:

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

-Черный 0; 30 Темно-серый 1; 30

-Красный 0; 31 Светло-красный 1; 31

-Зеленый 0; 32 Светло-зеленый 1; 32

-Коричневый / Оранжевый 0; 33 Желтый 1; 33

-Синий 0; 34 Голубой 1; 34

-Фиолетовый 0; 35 Светло-фиолетовый 1; 35

-Циан 0; 36 Светло-голубой 1; 36

-Светло-серый 0; 37 Белый 1; 37

Я использую это для цветной печати

#!/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[*]}"; } #|
#--------------------------------------------------------------------+

Все основные цвета установлены как переменные, а также есть несколько полезных функций: XY, line и que. Загрузите этот скрипт в один из ваших и используйте все цветовые переменные и функции.

Чтобы расширить этот ответ для ленивых из нас:

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"

Вам определенно следует использовать tput вместо необработанных управляющих последовательностей ANSI.

Поскольку существует большое количество различных языков управления терминалами, обычно в системе есть промежуточный уровень связи. Реальные коды ищутся в базе данных для текущего обнаруженного типа терминала, и вы даете стандартизированные запросы к API или (из оболочки) к команде.

Одна из этих команд - tput. tput принимает набор сокращений, называемых именами возможностей и любыми параметрами, если это необходимо, затем ищет правильные escape-последовательности для обнаруженного терминала в базе данных terminfo и печатает правильные коды (терминал, надеюсь, понимает).

из http://wiki.bash-hackers.org/scripting/terminalcodes

Тем не менее, я написал небольшую вспомогательную библиотеку под названием bash-tint, которая добавляет еще один слой поверх tput, что делает его еще проще в использовании (imho):

Пример: tint "white(Cyan(T)Magenta(I)Yellow(N)Black(T)) is bold(really) easy to use."

Дало бы следующий результат:

И это то, что я использовал, чтобы увидеть все комбинации и решить, что лучше всего:

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

Вы можете комбинировать цвета и текстовый режим.

#!/bin/bash

echo red text / black background \(Reverse\)
echo "\033[31;7mHello world\e[0m";
echo -e "\033[31;7mHello world\e[0m";
echo

echo yellow text / red background
echo "\033[32;41mHello world\e[0m";
echo -e "\033[32;41mHello world\e[0m";
echo "\033[0;32;41mHello world\e[0m";
echo -e "\033[0;32;41mHello world\e[0m";
echo

echo yellow BOLD text / red background
echo "\033[1;32;41mHello world\e[0m";
echo -e "\033[1;32;41mHello world\e[0m";
echo

echo yellow BOLD text underline / red background
echo "\033[1;4;32;41mHello world\e[0m";
echo -e "\033[1;4;32;41mHello world\e[0m";
echo "\033[1;32;4;41mHello world\e[0m";
echo -e "\033[1;32;4;41mHello world\e[0m";
echo "\033[4;32;41;1mHello world\e[0m";
echo -e "\033[4;32;41;1mHello world\e[0m";
echo

Для этого я написал swag.

Вы можете просто сделать

pip install swag

Теперь вы можете установить все escape-команды в виде файлов txt в указанное место назначения с помощью:

swag install -d <colorsdir>

Или еще проще:

swag install

При этом цвета будут установлены на ~/.colors.

Либо вы используете их так:

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

Или вот так, что мне кажется более интересным:

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

Проверьте это на asciinema!

Вдохновленный ответом @nachoparker, у меня в .bashrc есть следующее:

#### colours
source xcol.sh

### tput foreground
export tpfn=$'\e[0m' # normal
export tpfb=$(tput bold)

## normal colours
export tpf0=$(tput setaf 0) # black
export tpf1=$(tput setaf 1) # red
export tpf2=$(tput setaf 2) # green
export tpf3=$(tput setaf 3) # yellow
export tpf4=$(tput setaf 4) # blue
export tpf5=$(tput setaf 5) # magenta
export tpf6=$(tput setaf 6) # cyan
export tpf7=$(tput setaf 7) # white
# echo "${tpf0}black ${tpf1}red ${tpf2}green ${tpf3}yellow ${tpf4}blue ${tpf5}magenta ${tpf6}cyan ${tpf7}white${tpfn}"

## bold colours
export tpf0b="$tpfb$tpf0" # bold black
export tpf1b="$tpfb$tpf1" # bold red
export tpf2b="$tpfb$tpf2" # bold green
export tpf3b="$tpfb$tpf3" # bold yellow
export tpf4b="$tpfb$tpf4" # bold blue
export tpf5b="$tpfb$tpf5" # bold magenta
export tpf6b="$tpfb$tpf6" # bold cyan
export tpf7b="$tpfb$tpf7" # bold white
# echo "${tpf0b}black ${tpf1b}red ${tpf2b}green ${tpf3b}yellow ${tpf4b}blue ${tpf5b}magenta ${tpf6b}cyan ${tpf7b}white${tpfn}"

export позволяет мне использовать эти tpf.. в сценариях Bash.

Вот простой скрипт для простого управления стилем текста в командной строке оболочки bash:

https://github.com/ferromauro/bash-palette

Импортируйте код, используя:

source bash-palette.sh

Используйте импортированную переменную в команде echo (используйте параметр -e!):

echo -e ${PALETTE_GREEN}Color Green${PALETTE_RESET}

Возможно объединение большего количества элементов:

echo -e ${PALETTE_GREEN}${PALETTE_BLINK}${PALETTE_RED_U}Green Blinking Text over Red Background${PALETTE_RESET}

Смайлики

одна вещь, которую вы можете сделать, но не упомянутая в ответе, - это использовать смайлики для раскрашивания вывода!

echo ????: error message
echo ????: warning message
echo ????: ok status message
echo ????: action message
echo ????: Or anything you like and want to recognize immediately by color
echo ????: Or with a specific emoji

???? Бонусная добавленная стоимость

Этот метод очень полезен, особенно когда ваш редактор исходного кода для скрипта поддерживает отображение Unicode. Тогда вы также сможете увидеть красочный скрипт еще до его запуска и прямо в источнике! :

_{Изображение файла сценария внутри VSCode}

Примечание. Возможно, вам потребуется передать Unicode смайлика напрямую:

echo $'\U0001f972'  // this emoji: ????

_{Обратите внимание на заглавную U для символов Юникода ›= 10000}.

Также. Это очень редко, но вам может потребоваться передать такой код:

echo <0001f972>

Спасибо @joanis из комментариев за упоминание этого

Вот самое простое и понятное решение. С bashj (https://sourceforge.net/projects/bashj/) вы просто выберете одна из этих строк:

#!/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 цвета доступны, если у вас есть поддержка цвета в вашем терминальном приложении.

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

Это правильный ответ, за исключением того, что вызов цветов не должен быть внутри кавычек.

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

Должен сделать свое дело.