Как изменить цвет вывода эха в Linux

avatar
satheesh.droid
10 мая 2011 в 09:07
1361472
33
2206

Я пытаюсь напечатать текст в терминале с помощью команды echo.

Я хочу напечатать текст красным цветом. Как я могу это сделать?

Источник
Pithikos
22 октября 2014 в 10:32
46

Эта ссылка очень полезна: misc.flogisoft.com/bash/tip_colors_and_formatting

Ответы (33)

avatar
Oli Girling
8 ноября 2021 в 15:24
2

Вот что у меня получилось с использованием sed

echo " [timestamp] production.FATAL Some Message\n" \
"[timestamp] production.ERROR Some Message\n" \
"[timestamp] production.WARNING Some Message\n" \
"[timestamp] production.INFO Some Message\n" \
"[timestamp] production.DEBUG Some Message\n"  | sed \
-e "s/FATAL/"$'\e[31m'"&"$'\e[m'"/" \
-e "s/ERROR/"$'\e[31m'"&"$'\e[m'"/" \
-e "s/WARNING/"$'\e[33m'"&"$'\e[m'"/" \
-e "s/INFO/"$'\e[32m'"&"$'\e[m'"/" \
-e "s/DEBUG/"$'\e[34m'"&"$'\e[m'"/"

Выводит так: Mac sed output to colour

avatar
coldfix
20 октября 2021 в 15:23
9

Другие ответы уже дают отличные объяснения того, как это сделать. Чего мне все еще не хватало, так это хорошо организованного обзора цветовых кодов. Статья в Википедии "Код побега ANSI" очень полезна в этом. Однако, поскольку цвета часто можно настроить и они выглядят по-разному в каждом терминале, я предпочитаю иметь функцию, которую можно вызывать в терминале. Для этой цели я создал следующие функции, чтобы показать таблицу цветов и напомнить мне, как их установить (с расположением, вдохновленным статьей вики). Вы могли бы, например. загрузите их в свой .bashrc/.zshrc или поместите куда-нибудь в виде скрипта.

256 цветов

enter image description here

enter image description here

Сгенерировано этим скриптом bash/zsh:

function showcolors256() {
    local row col blockrow blockcol red green blue
    local showcolor=_showcolor256_${1:-bg}
    local white="\033[1;37m"
    local reset="\033[0m"

    echo -e "Set foreground color: \\\\033[38;5;${white}NNN${reset}m"
    echo -e "Set background color: \\\\033[48;5;${white}NNN${reset}m"
    echo -e "Reset color & style:  \\\\033[0m"
    echo

    echo 16 standard color codes:
    for row in {0..1}; do
        for col in {0..7}; do
            $showcolor $(( row*8 + col )) $row
        done
        echo
    done
    echo

    echo 6·6·6 RGB color codes:
    for blockrow in {0..2}; do
        for red in {0..5}; do
            for blockcol in {0..1}; do
                green=$(( blockrow*2 + blockcol ))
                for blue in {0..5}; do
                    $showcolor $(( red*36 + green*6 + blue + 16 )) $green
                done
                echo -n "  "
            done
            echo
        done
        echo
    done

    echo 24 grayscale color codes:
    for row in {0..1}; do
        for col in {0..11}; do
            $showcolor $(( row*12 + col + 232 )) $row
        done
        echo
    done
    echo
}

function _showcolor256_fg() {
    local code=$( printf %03d $1 )
    echo -ne "\033[38;5;${code}m"
    echo -nE " $code "
    echo -ne "\033[0m"
}

function _showcolor256_bg() {
    if (( $2 % 2 == 0 )); then
        echo -ne "\033[1;37m"
    else
        echo -ne "\033[0;30m"
    fi
    local code=$( printf %03d $1 )
    echo -ne "\033[48;5;${code}m"
    echo -nE " $code "
    echo -ne "\033[0m"
}

16 цветов

enter image description here

Сгенерировано этим скриптом bash/zsh:

function showcolors16() {
    _showcolor "\033[0;30m" "\033[1;30m" "\033[40m" "\033[100m"
    _showcolor "\033[0;31m" "\033[1;31m" "\033[41m" "\033[101m"
    _showcolor "\033[0;32m" "\033[1;32m" "\033[42m" "\033[102m"
    _showcolor "\033[0;33m" "\033[1;33m" "\033[43m" "\033[103m"
    _showcolor "\033[0;34m" "\033[1;34m" "\033[44m" "\033[104m"
    _showcolor "\033[0;35m" "\033[1;35m" "\033[45m" "\033[105m"
    _showcolor "\033[0;36m" "\033[1;36m" "\033[46m" "\033[106m"
    _showcolor "\033[0;37m" "\033[1;37m" "\033[47m" "\033[107m"
}

function _showcolor() {
    for code in $@; do
        echo -ne "$code"
        echo -nE "   $code"
        echo -ne "   \033[0m  "
    done
    echo
}
avatar
Mojtaba Hosseini
8 мая 2021 в 08:14
6

Emoji

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

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 demo Изображение файла сценария внутри VSCode

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

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

Обратите внимание на заглавную U для символов Unicode> = 10000


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

echo <0001f972>

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

joanis
18 июня 2021 в 16:24
2

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

joanis
18 июня 2021 в 16:26
0

Кроме того, echo <0001f972> у меня не работает. В каком контексте работает этот синтаксис? Для символов Юникода <= ffff, echo $'\u1234' работает, но не для> = 10000.

joanis
18 июня 2021 в 16:32
0

Только что нашел ответ для> = 10000: echo $'\U0001f972' с большой буквы U. (выяснил это из unix.stackexchange.com/a/280481/327696, предполагая, что bash и vim могут имитировать друг друга)

Rob
19 июня 2021 в 10:36
0

Это не дает ответа на вопрос. Чтобы критиковать или запрашивать разъяснения у автора, оставьте комментарий под его сообщением. - Из обзора

Jeremy Caney
19 июня 2021 в 19:02
1

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

NVRM
11 сентября 2021 в 19:31
1

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

avatar
wytten
20 января 2021 в 17:56
42

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

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

$ echo $(red apple) $(yellow banana) $(green kiwi)
apple banana kiwi

avatar
Flash Ang
13 ноября 2020 в 16:12
7

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

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

enter image description here

avatar
joharr
29 сентября 2020 в 16:44
2

Вдохновленный ответом @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.

avatar
Mauro
26 июня 2020 в 08:46
1

Вот простой сценарий для простого управления стилем текста в командной строке оболочки 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}

enter image description here

avatar
Pascal Polleunus
4 апреля 2020 в 10:02
24

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

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."
avatar
Ivan
14 февраля 2020 в 07:27
7

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

#!/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. Загрузите этот сценарий в один из ваших и используйте все цветовые переменные и функции.

avatar
Bruno Bronosky
7 февраля 2020 в 06:27
15

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

256 colors output by tput

avatar
Vishal
28 сентября 2019 в 18:27
17

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

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

avatar
Amirouche Zeggagh
19 августа 2019 в 15:43
10

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

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

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

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

avatar
Andrew Naguib
24 ноября 2018 в 23:09
46

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

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"
ionescu77
21 марта 2019 в 12:42
1

Очень практично, мне просто пришлось заменить одинарные кавычки на двойные кавычки для ЗЕЛЕНЫХ, ЖЕЛТЫХ, NC, чтобы они работали в моем скрипте.

David Kariuki
30 апреля 2020 в 20:46
1

Отличное решение !!

avatar
Fil
13 июня 2018 в 07:34
-2

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

avatar
ArtBIT
23 апреля 2018 в 10:14
6

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

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

avatar
NVRM
21 января 2018 в 10:51
17

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

Генератор:

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's 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";

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

enter image description here

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

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

admin
11 сентября 2021 в 03:32
0

подходит для zsh for i in {30..49};do echo -e "\033[$i;7mReversed color code $i\e[0m Hello world\!";done

avatar
Ahmed Masud
20 сентября 2017 в 21:02
21

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

Первое использование 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]] 

, чтобы получить:

Bold-Green Success

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

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

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

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

Redsandro
5 октября 2017 в 08:15
0

Это круто! Не знал этого. Можете что-нибудь сказать о наличии tput? Доступен ли он на большинстве серверов, где нет прав администратора для его установки? У вас есть ссылка на то, где впервые «изобрели» эту технику?

Ahmed Masud
5 октября 2017 в 18:44
3

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

Redsandro
22 октября 2017 в 12:47
1

Я прекратил использовать этот метод, так как он мешает положению курсора в строках bash. Он будет случайным образом переноситься до конца строки и не будет возвращаться полностью к началу строки при использовании кнопки Home или клавиш со стрелками. Возврат к неуклюжим ручным escape-кодам решает эту проблему.

Toby Speight
7 марта 2018 в 16:40
2

@Resandro - это потому, что вы используете его в $PS1 без \[...\] вокруг частей без интервала? Продолжайте использовать маркеры Bash PS1 со строками tput.

Jeff
15 октября 2018 в 13:41
0

Обратите внимание, что эта функция не полностью работает на MacO из-за различий в утилите sed: unix.stackexchange.com/questions/13711/…

Ahmed Masud
15 октября 2018 в 17:06
0

@Jeff Я как бы надеялся, что OP будет извлекать уроки из этого подхода, а не слепо вырезать и вставлять его. Единственная причина, по которой я использовал tput как переносимый подход, заключается в том, что это действительно - это правильный способ запроса терминала.

NVRM
4 сентября 2020 в 21:33
1

Мы можем установить позицию курсора, строку и столбец, используя аналогичную escape-последовательность ANSI.

avatar
code8888
28 апреля 2017 в 00:50
18

Спасибо @ 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

Результат

enter image description here

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

Synox
4 июня 2020 в 11:24
0

Следует отметить, что для этого требуется bash v4.

avatar
Wilfred Hughes
4 апреля 2017 в 10:37
30

Используйте 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"
avatar
throws_exceptions_at_you
18 февраля 2017 в 21:30
2

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

avatar
isntn
4 февраля 2017 в 14:03
4

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

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
avatar
nachoparker
24 января 2017 в 08:23
9

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

xcol example

Обратите внимание, что он принимает любое регулярное выражение, которое примет 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}"

avatar
Mahn
23 сентября 2015 в 16:21
6

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

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"
Toby Speight
23 сентября 2015 в 16:25
2

Не допускайте жесткого кодирования выхода из терминала. Используйте tput; вот для чего это нужно!

WinEunuuchs2Unix
2 ноября 2019 в 21:18
0

@TobySpeight Хотя это может быть правдой для многоплатформенной поддержки (теоретически), если автор считает, что это работает в их собственном мире, почему не согласны и отговаривают других в аналогичном мире от использования этой техники? Показательный пример: я пытаюсь сделать то же самое в Ubuntu 16.04 bash, и это работает. Как единственный пользователь этой платформы, я считаю этот ответ приемлемым. Я также буду использовать tput для sc и rc (сохранить курсор, восстановить курсор). Хотя этот ответ называет меня «ленивым», его можно переформулировать как «практичный» или «прямо к делу».

Amit Naidu
23 мая 2020 в 04:47
0

Мое собственное решение было похоже на это, ограничивалось только встроенными модулями оболочки, потому что разветвление двух внешних процессов, подоболочек и т. Д. Для каждого сообщения в сценарии просто имело ... неприятный запах.

avatar
Shakiba Moshiri
9 марта 2015 в 09:02
1155

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

# 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 , шестнадцатеричный и восьмеричный 23797> соответственно: <43379>
|       | bash  | hex     | octal   | NOTE                         |
|-------+-------+---------+---------+------------------------------|
| start | \e    | \x1b    | \033    |                              |
| start | \E    | \x1B    | -       | x cannot be capital          |
| end   | \e[0m | \x1b[0m | \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

foreground.gif

фоновая 8-битная сводка в .gif

background.gif

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

enter image description here enter image description here enter image description here enter image description here

blinking на KDE-Terminal

KDE-blinking

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

cecho_screenshot

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

bline


снимок в цветном режиме

fade-normal-bright

снимок в текстовом режиме

only-text-mode

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

combine

больше снимков


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

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

Да, можно. Я испытал в bash, c, c ++, d, d <18435723> per18435723> per18435723> per18435723> per18435723> per18435723

>

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

Думаю, НЕТ.

Можно ли использовать их в 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;

pcc

Он НЕ обрабатывает 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 <121212723743189189127231843677121271272384367712122127231843677128 org
misc.flogisoft.com
некоторые блоги / веб-страницы, которые я не помню

Neil Guy Lindberg
2 октября 2019 в 20:17
0

Это помогло мне обойти .eslint strict, без восьмеричных литералов, и в то же время преодолеть строки шаблонов JS, которые не позволяют то же самое.

Shakiba Moshiri
3 октября 2019 в 06:45
2

@NeilGuyLindberg без восьмеричных литералов эта ошибка является частью Node.js, а не самим списком. вы можете использовать x1B[ для его устранения.

Pascal Polleunus
4 апреля 2020 в 09:54
1

Вау, круто! :-D Я только что сделал довольно приятную функцию, чрезвычайно простую в использовании, поэтому я должен ею поделиться ;-) github.com/ppo/bash-colors

victorq10
23 апреля 2020 в 12:39
1

@ShakibaMoshiri Из ответа неясно, как комбинировать цвета, пока вы внимательно не прочитаете escape-последовательности ANSI. Просто для примечания: echo -e "\033[97;44;1m text \033[m" выводит полужирный (; 1) текст белого цвета (; 97) на синем фоне (; 44), а \033[0m сбрасывает весь текстовый атрибут (0). Также это зависит от цветовой схемы терминала.

Peter Mortensen
11 июня 2021 в 22:57
1

pogchamp - «(Интернет-сленг, текстовые сообщения, Twitch-talk) Используется для обозначения волнения.»

nevermind
24 сентября 2021 в 18:53
1

опечатка: \x1m0m должно быть \x1b[0m

avatar
Jorge Bucaran
25 февраля 2015 в 01:38
36

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

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

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

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

Shairon Toledo
1 октября 2015 в 15:02
1

Я бы изменил последнюю переменную text на text="$color${@: 2}${code}0m", таким образом вся строка, кроме параметра цвета, будет окрашена.

Artem Medvedev
21 марта 2017 в 04:03
0

@tomazahlin просто добавьте -e к echo, как несколько раз упоминалось выше

Greg Dubicki
7 июня 2020 в 18:17
0

Как предложил Уилфред Хьюз, лучше использовать tput, поскольку он более переносимый - работает в Bash и на macOS. Поэтому я предлагаю использовать функцию Алиреза Мириан из этого ответа: coderhelper.com/a/23006365/2693875

avatar
Eric Leschinski
5 сентября 2014 в 18:40
13

Эти коды работают на моем компьютере с Ubuntu:

enter image description here

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

enter image description here

urzeit
16 января 2015 в 14:50
2

Кстати: это не сильно зависит от того, установлена ​​ли конкретная версия ubuntu, но от использования PuTTY!

avatar
Ooker
5 июля 2014 в 08:28
12

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

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

echo 'Hello World!' | sed $'s/World/\e[1m&\e[0m/' 
Patrick
3 марта 2016 в 23:35
1

Мне очень нравится этот ответ! Не могли бы вы объяснить $ в команде sed?

dsz
10 октября 2016 в 04:28
2

$ '<something>' предназначен для bash, а не для sed. Он сообщает bash обрабатывать \ e как escape-последовательность и помещать в нее «escape-символ». Обычно вы видите более простые формы, такие как $ '\ t' или $ '\ n', чтобы получить знак табуляции или новой строки, переданный в команда.

avatar
Dale Corns
25 июня 2014 в 17:54
-5
red='\e[0;31m'
NC='\e[0m' # No Color
echo -e "${red}Hello Stackoverflow${NC}"

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

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

Должен помочь.

naab
8 июля 2014 в 08:39
3

Прекрасно работает внутри кавычек. переключатель -e также оценивает, что находится в кавычках. Выполнение обоих (внутри и вне кавычек) с использованием bash -x выводит одну и ту же выполненную команду echo -e '\e[0;31mHello Stackoverflow\e[0m'. То же самое и с bash.

avatar
Alireza Mirian
11 апреля 2014 в 07:36
32

Изящный способ изменить цвет только для одного 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
sobi3ch
12 января 2017 в 17:23
0

Если вы добавите -n к эху, вы можете использовать его как встроенную раскраску echo "Red `coloredEcho "fox" red` jumps over the lazy dog"

avatar
Drew Noakes
7 января 2014 в 22:25
1185

Вы можете использовать замечательную команду 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:

Screenshot of colour terminal text


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

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

Chris Middleton
25 июля 2014 в 15:45
21

Отличный ответ. Это тот, который мне больше всего помог. Для всех, кому интересно, что меня интересует, $() - это подстановка команды. Все, что делает tput af 1, - это генерирует строку цветового кода, но коды не являются печатными символами, поэтому при вводе только tput af 1 будет получена пустая строка вывода.

Enrico
12 декабря 2014 в 18:56
5

Примечание: если вы используете CygWin и у вас нет tput install ncurses

nickboldt
5 февраля 2015 в 19:06
4

tput также работает внутри sed для разбора мусора на разборчивый красочный мусор: gist.github.com/nickboldt/fab71da10bd5169ffdfa

Andrew
21 января 2017 в 23:10
2

Для получения полного списка цветов tput ознакомьтесь с этим ответом на Unix StackExchange

monkeypants
24 сентября 2019 в 06:26
0

Я думаю, что reset=`tput sgr0` должно быть reset=`tput sgr 0` с пробелом.

csalmeida
10 апреля 2020 в 21:34
0

У меня этот вариант работал с оболочкой fish. Вот пример: tput setaf 5 tput bold echo "Hello, World" tput sgr0

x-yuri
23 декабря 2020 в 15:46
1

@monkeypants Из то, что я вижу, sgr0 специально предназначено для сброса (отключения) атрибутов. sgr 0, вероятно, тоже может выполнять эту роль, но sgr - это более общая команда, позволяющая изменять атрибуты.

avatar
Tobias
10 мая 2011 в 09:11
2901

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

Ben Harold
9 мая 2013 в 22:01
21

У меня не работает - вывод: \e[0;31mHello Stackoverflow\e[0m

James Lim
14 мая 2013 в 13:10
192

Вы пробовали это с "-e"? Он сообщает echo, чтобы разрешить экранирование обратной косой черты.

Xiao
19 июня 2013 в 06:04
157

В MacOSX используется \x1B вместо \e. \033 подойдет для всех платформ.

shonky linux user
1 октября 2013 в 00:55
5

В файле свойств ant для экранирования используйте Unicode, например красный = \ u001b [0; 31м

Thanatos
23 марта 2014 в 20:56
1

Вы можете заметить, что они действительно зависят от их понимания терминалом. Тем не менее, я никогда не встречал терминал, который не понимал бы этот набор. 0 означает «сброс»; это не является строго обязательным (только если вам нужен сброс) и будет так же актуально в ярких версиях. (0;1;30) (1 означает яркий.)

Benubird
24 июля 2014 в 08:57
3

В моей системе (bash на ubuntu) я обнаружил, что для первого числа 1 означает жирный, а не яркий, а 3 и 4 выделены курсивом и подчеркнуты, 5 вспышек и 7 также меняют фон. Интересно, есть ли где-нибудь какая-то спецификация для них?

everyman
28 января 2016 в 21:28
25

Как и msanford, созданный для tput, вот "ANSI-Rainbow" for (( i = 30; i < 38; i++ )); do echo -e "\033[0;"$i"m Normal: (0;$i); \033[1;"$i"m Light: (1;$i)"; done

tripleee
7 апреля 2017 в 05:55
2

echo -e не переносится, а printf -. Используйте printf.

localhostdotdev
13 мая 2019 в 01:02
0

вам может потребоваться сделать \x33 вместо \033 (такой же, но восьмеричный префикс не работает, например, в coffeescript)

Chiramisu
8 января 2020 в 17:01
1

Вы должны использовать двойные кавычки с echo, чтобы это работало.

biesior
24 августа 2020 в 23:30
0

@everyman, ты забыл избежать раскраски ANSI в конце цикла, Шерлок;)

adavea
8 декабря 2020 в 15:00
0

Предупреждаем всех, кто использует популярную серию IDE IDEA, черный / белый / серый цветовые коды будут выглядеть немного беспорядочно (например, светло-серый темнее темно-серого), если вы используете их в консоли вывода in-IDE, но они правильно выводят на фактический терминал

ingydotnet
1 февраля 2021 в 19:33
0

Вы можете предварительно развернуть escape-последовательности, например, (printf -v R '\e[0;31m'; printf -v Z '\e[0m'; echo "This is a ${R}red$Z word."). Затем вы можете использовать их в простом эхо без -e (и даже без двойных кавычек).

aswzen
14 апреля 2021 в 09:46
0

какой код мне нужно использовать для цвета по умолчанию?

carloswm85
14 августа 2021 в 23:42
0

@everyman, вы забыли упомянуть, что первое нормальное значение (в этой замечательной ANSI Rainbow) - черное, что делает его невидимым в консолях с черным фоном.

avatar
Ignacio Vazquez-Abrams
10 мая 2011 в 09:10
218

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

echo "$(tput setaf 1)Hello, world$(tput sgr0)"
Tian Chen
6 марта 2013 в 07:39
11

Это должен быть лучший вариант. Что делает tput , так это считывает информацию о терминале и отображает для вас правильно экранированный код ANSI. код типа \033[31m нарушит работу библиотеки readline в некоторых терминалах.

msanford
22 января 2014 в 15:41
50

Изучите цвета с помощью простого цикла (увеличьте верхнюю границу i, чтобы получить больше оттенков): for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done

maxywb
4 августа 2014 в 18:38
3

Вот HOWTO по кодам tput: tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html

el-teedee
5 октября 2020 в 10:42
0

Согласитесь с @TianChen, такой код, как \033[31m, также будет генерировать некоторые нерелевантные символы, если программа, используемая для вывода текста, несовместима с такими командами. С другой стороны, команды tput + setaf не работают, оставляя вывод полностью читаемым. См. Комментарий @BenHarold, в котором говорится: «У меня не работает - вывод: \e[0;31mHello Stackoverflow\e[0m»

avatar
neocanable
10 мая 2011 в 09:10
170
echo -e "\033[31m Hello World"

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

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

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

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

neocanable
10 мая 2011 в 09:13
4

echo -e "\ 033 [31m Hello World", [31m - цвет