Ответ 1

Вы можете использовать эти коды выхода 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, если вы не хотите добавлять дополнительную пустую строку)

Ответ 2

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

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

Конкретные подкоманды 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

Существуют также версии функций настройки цвета (не t214 > вместо setab и setf вместо setaf), но не ANSI), которые не указаны здесь.

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

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 default
tput bel     # Play a bell

С помощью compiz wobbly windows команда 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.)

Ответ 3

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

# 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, hex и восьмеричном соответственно:

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

В таблице ниже приведена сводная информация о 8-битной версии цвета ANSI

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

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

В таблице ниже приведена сводная информация о 24-битной версии цвета ANSI

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

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

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

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

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

blinking на KDE-терминале

простой C код, который показывает вам больше

более продвинутый инструмент, который я разработал для работы с этими цветами:

цветная съемка

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

объединение в порядке

больше выстрелов

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

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

Да, ты можешь. Я испытал в 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) и затем поместите файл a в допустимый PATH затем используйте его где угодно.

ls | pcc
df | pcc

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

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

Она не обрабатывает Unicode.

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

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

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

или же:

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
Имеет ли это смысл? какой цвет вы хотите объединить с этими тремя 8-битными значениями.

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

Ответ 4

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

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

Ответ 5

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

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

• 30 - 37 устанавливает цвет переднего плана.
• 40 - 47 устанавливает цвет фона

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

Хорошая практика для reset цвета текста вернуться к \033[0m в конце строки.

Ответ 6

Это переключатель цветов \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!"

Ответ 7

Чистым способом изменения цвета только для одного 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

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

coloredEcho "This text is green" 2

Ответ 8

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

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"

Ответ 9

Используйте 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"

Ответ 10

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

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

Здесь быстрая функция bash:

 say() {
     echo "[email protected]" | sed \
             -e "s/\(\(@\(red\|green\|yellow\|blue\|magenta\|cyan\|white\|reset\|b\|u\)\)\+\)[[]\{2\}\(.*\)[]]\{2\}/\1\[email protected]/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 @[email protected][[Success]] 

получить:

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

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

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

Итак, он (довольно) вездесущий.

Ответ 11

Благодаря @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

Ответ 12

Эти коды работают в моем поле 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

Ответ 13

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

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

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

Ответ 14

Мой любимый ответ пока цветенEcho.

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

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

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

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

Ответ 15

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

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

Генератор:

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

Ответ 16

Развернуть на этот ответ, для ленивых нас:

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"

Ответ 17

Вам определенно следует использовать 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."

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

Ответ 18

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

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

-Black 0; 30 темно-серый 1; 30

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

-Green 0; 32 светло-зеленый 1; 32

-Brown/оранжевый 0; 33 желтый 1; 33

-Blue 0; 34 Голубой 1; 34

-Purple 0; 35 светло-фиолетовый 1; 35

-Cyan 0; 36 Светло-голубой 1; 36

-Light серый 0; 37 белый 1; 37

Ответ 19

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

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

Ответ 20

Я написал 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!

Ответ 21

Если вы используете 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'

Попробуйте онлайн

Ответ 22

Вот небольшой маленький script, который я недавно собрал, чтобы раскрасить любой входной канал, вместо использования "Туалет".

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 

Затем назовите его красным цветом (196):
$> echo "text you want colored red" | color.bsh 196

Ответ 23

Ссылаться на:

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

Ответ 24

Вот реализация, которая работает на терминале MacOS для установки PS1 с окраской, а что нет.

Существует две реализации, одна из которых полагается на echo, а другая - на printf для динамического вызова методов, не нарушая ад.

Это только начало, но надежное и не будет мерцать терминал. Поддерживает git branch прямо сейчас, но может быть расширен в конечном итоге.

Можно найти здесь:

https://github.com/momomo/opensource/blob/master/momomo.com.shell.style.sh

Должен работать просто скопировать и вставить. Нет зависимостей.

Ответ 25

после того, как я смешал другие решения из потока, вот как мне удалось получить цвета внутри npm scripts через символы Юникода (CLI 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"
}

Ответ 26

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

Ответ 27

Так же, как что-то немного, прохождение через grep будет выделять его как красный (но только красный). Вы также можете использовать именованные каналы, чтобы ваша строка ближе к концу строки:

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

Ответ 28

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

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

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

Должен сделать трюк.