Jak zmienić wyjściowy kolor echa w systemie Linux

Odpowiedzi:

2292

Możesz użyć tych kodów specjalnych 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

A następnie użyj ich w ten sposób w swoim skrypcie:

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

który drukuje lovena czerwono.

Z komentarza @ james-lim, jeśli używasz echopolecenia, pamiętaj, aby użyć flagi -e, aby umożliwić ucieczki odwrotnym ukośnikiem .

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

(nie dodawaj, "\n"gdy używasz echa, chyba że chcesz dodać dodatkową pustą linię)

Tobiasz
źródło
11
Nie działa dla mnie - wynik:\e[0;31mHello Stackoverflow\e[0m
Ben Harold,
171
Czy próbowałeś tego z „-e”? Mówi, echoaby włączyć ucieczki z odwrotnym ukośnikiem.
James Lim
141
W MacOSX używanie \x1Bzamiast \e. \033byłoby dobrze na wszystkich platformach.
Xiao
4
W pliku właściwości ant użyj kodu Unicode dla esacpe, np. Red = \ u001b [0; 31m
shonky użytkownik linux
20
Podobnie jak msanford stworzony dla tput, tutaj jest „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
everyman
970

Możesz użyć niesamowitego tputpolecenia (zasugerowanego w odpowiedzi Ignacio ), aby wygenerować kody kontrolne terminali dla wszystkich rzeczy.


Stosowanie

Konkretne tputpolecenia podrzędne zostały omówione później.

Bezpośredni

Wywołaj tputjako część sekwencji poleceń:

tput setaf 1; echo "this is red text"

Użyj ;zamiast, &&więc jeśli tputbłędy nadal pokazują tekst.

Zmienne powłoki

Inną opcją jest użycie zmiennych powłoki:

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

tputtworzy sekwencje znaków, które są interpretowane przez terminal jako mające specjalne znaczenie. Nie będą się pokazywać. Pamiętaj, że nadal mogą być zapisywane w plikach lub przetwarzane jako dane wejściowe przez programy inne niż terminal.

Zastępowanie poleceń

Wygodniejsze może być wstawianie tputdanych wyjściowych bezpośrednio do echołańcuchów za pomocą podstawiania poleceń :

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

Przykład

Powyższe polecenie tworzy to na Ubuntu:

Zrzut ekranu z kolorowym tekstem terminala


Polecenia dotyczące koloru pierwszego planu i tła

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

Kolory są następujące:

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

Istnieją również wersje funkcji ustawiania kolorów inne niż ANSI ( setbzamiast setabi setfzamiast setaf), które używają różnych liczb, których tu nie podano.

Polecenia w trybie tekstowym

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

Polecenia ruchów kursora

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

Wyczyść i wstaw polecenia

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

Inne polecenia

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

Z Compiz chwiejnych okien The belkomenda sprawia terminala kołysanie na sekundę do zwrócenia uwagi użytkownika.


Skrypty

tputakceptuje skrypty zawierające jedno polecenie w wierszu, które są wykonywane w kolejności przed tputzakończeniem.

Unikaj plików tymczasowych, wyświetlając echo ciągu wielowierszowego i przesyłając go strumieniowo:

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

Zobacz też

  • Widzieć man 1 tput
  • Zobacz man 5 terminfopełną listę poleceń i więcej szczegółów na temat tych opcji. (Odpowiednie tputpolecenie znajduje się w Cap-namekolumnie ogromnej tabeli rozpoczynającej się od wiersza 81.)
Drew Noakes
źródło
13
Świetna odpowiedź. To ten najbardziej mi pomógł. Dla każdego, kto zastanawia się, co ja zastanawiam, $()jest to podstawienie polecenia . Wszystko, co tput af 1robi, to generuje ciąg kodu koloru, ale kody nie są znakami do wydrukowania, więc tput af 1samo wpisanie spowoduje utworzenie pustej linii wyniku.
Chris Middleton
5
Uwaga: jeśli używasz CygWin i nie masz instalacji tputncurses
Enrico
3
tput działa również wewnątrz sed do parsowania cruft w czytelny, kolorowy cruft
nickboldt
1
Pełna lista tputkolorów znajduje się w odpowiedzi na Unix StackExchange
Andrew
Myślę, że reset=`tput sgr0`powinno być reset=`tput sgr 0`, ze spacją.
małpy
832

niektóre zmienne, których możesz użyć:

# 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

znak zmiany znaczenia , odpowiednio , bash , hex i ósemkowy :

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

krótki przykład:

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

wyjątek bash:

Jeśli zamierzasz użyć tych kodów w swoich specjalnych zmiennych bash

  • PS0
  • PS1
  • PS2 (= służy do monitowania)
  • PS4

powinieneś dodać dodatkowe znaki ucieczki, aby potrafię je poprawnie interpretować. Bez dodawania dodatkowych znaków ucieczki działa, ale napotkasz problemy podczas Ctrl + rwyszukiwania w historii.

reguła wyjątków dla bash

Należy dodać \[przed każdym początkowym kodem ANSI i dodać \]po zakończeniu każdego z nich.
Przykład:
w regularnym użyciu: \033[32mThis is in green\033[0m
dla PS0 / 1/2/4: \[\033[32m\]This is in green\[\033[m\]

\[służy do rozpoczęcia sekwencji znaków niedrukowalnych
\] jest do końca sekwencji znaków niedrukowalnych

Wskazówka: aby zapamiętać, możesz najpierw dodać, \[\]a następnie umieścić między nimi swój kod ANSI:
- \[start-ANSI-code\]
-\[end-ANSI-code\]

rodzaj sekwencji kolorów:

  1. 3/4 bit
  2. 8 bitowy
  3. 24 bity

Przed nurkowaniem w tych kolorach powinieneś wiedzieć o 4 trybach z tymi kodami:

1. tryb kolorów

Zmienia styl koloru NIE tekstu. Na przykład rozjaśnij lub przyciemnij kolor.

  • 0 Resetowanie
  • 1; lżejszy niż zwykle
  • 2; ciemniejszy niż zwykle

Ten tryb nie jest szeroko obsługiwany. Jest w pełni obsługiwany na Gnome-Terminal.

2. tryb tekstowy

Ten tryb służy do modyfikowania stylu tekstu NIE w kolorze.

  • 3; italski
  • 4; podkreślać
  • 5; miga (powoli)
  • 6; miga (szybko)
  • 7; odwrócić
  • 8; ukryć
  • 9; przekreślenie

i są prawie obsługiwane.
Na przykład KDE-Konsole obsługuje, 5;ale Gnome-Terminal nie obsługuje i Gnome obsługuje, 8;ale KDE nie.

3. tryb pierwszego planu

Ten tryb służy do kolorowania pierwszego planu.

4. tryb tła

Ten tryb służy do kolorowania tła.

Poniższa tabela pokazuje podsumowanie 3 / 4-bitowej wersji koloru 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[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                                            |                                                                                       |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|

Poniższa tabela pokazuje podsumowanie 8-bitowej wersji koloru 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-bitowy szybki test:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

Poniższa tabela pokazuje podsumowanie 24-bitowej wersji koloru 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 |
|------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|

kilka zrzutów ekranu

8-bitowe streszczenie na pierwszym planie w .gif

foreground.gif

8-bitowe streszczenie w tle .gif

background.gif

podsumowanie kolorów z ich wartościami

wprowadź opis zdjęcia tutaj wprowadź opis zdjęcia tutaj wprowadź opis zdjęcia tutaj wprowadź opis zdjęcia tutaj

blinking na terminalu KDE

KDE miga

prosty Ckod, który pokazuje więcej

cecho_screenshot

bardziej zaawansowane narzędzie, które opracowałem, aby radzić sobie z tymi kolorami:

bliny


zdjęcie w trybie kolorowym

wyblakłe-normalne-jasne

strzał w trybie tekstowym

tryb tylko tekstowy

łączenie jest OK

połączyć

więcej zdjęć


Wskazówki i porady dla zaawansowanych użytkowników i programistów:

Czy możemy używać tych kodów w języku programowania?

Tak, możesz. Doświadczyłem w, , , ,

Czy spowalniają szybkość programu?

Myśle że nie.

Czy możemy ich używać w systemie Windows?

3/4-bit Tak, jeśli skompilujesz kod z gcc
kilkoma zrzutami ekranu na Win-7

Jak obliczyć długość kodu?

\033[ = 2, pozostałe części 1

Gdzie możemy użyć tych kodów?

Wszędzie tam, gdzie ma ttytłumacza
xterm, gnome-terminal, kde-terminal, mysql-client-CLIi tak dalej.
Na przykład, jeśli chcesz pokolorować wydruk za pomocą mysql, możesz użyć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;

zapisz ten kod w nazwie pliku: pcc(= Perl Colorize Character), a następnie umieść plik w poprawnym, PATHa następnie użyj go w dowolnym miejscu.

ls | pcc
df | pcc

wewnątrz mysqlnajpierw zarejestruj go, pagera następnie spróbuj:

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

szt

Robi NIE obsługuje Unicode.

Czy te kody tylko kolorują?

Nie, potrafią robić wiele interesujących rzeczy. Próbować:

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

lub:

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

Jest wielu początkujących, którzy chcą wyczyścić ekran system( "clear" ), abyś mógł użyć tego zamiast system(3)połączenia

Czy są dostępne w standardzie Unicode?

Tak. \u001b

Która wersja tych kolorów jest lepsza?

Jest łatwy w użyciu 3/4-bit, ale jest bardzo dokładny i piękny w użyciu 24-bit.
Jeśli nie masz doświadczenia zwięc o to szybkie wiczenia:
24 bity oznaczają: 00000000i 00000000i 00000000. Każdy 8 bitów dotyczy określonego koloru.
1..8jest dla i 9..16dla i 17..24dla
So in #FF0000oznacza i oto on: 255;0;0
w #00FF00oznacza, że tutaj jest: 0;255;0
Czy to ma sens? jaki kolor chcesz połączyć z tymi trzema 8-bitowymi wartościami.


odniesienie: sekwencje specjalne ANSI
Wikipedii tldp.org tldp.org misc.flogisoft.com niektóre blogi / strony internetowe, których nie pamiętam




Shakiba Moshiri
źródło
69
Czy nikt inny nie jest naprawdę zaskoczony tą odpowiedzią?
Benj
14
To zdecydowanie odpowiedź na sławę, dziękuję.
ForeverZer0
2
@ NeilGuyLindberg brak literałów ósemkowych ten błąd jest częścią Node.js, a nie samej listy. możesz użyć x1B[do jego wyeliminowania.
Shakiba Moshiri
5
Przewróciłem dość daleko, aby głosować na tę odpowiedź!
RNA,
1
Wydaje się, że @ShakibaMoshiri napisał rozprawę na ten temat xD Żarty osobno, kibicuje tak szczegółowej odpowiedzi!
SH '
189

Użyj tputz setafmożliwością i parametrem 1.

echo "$(tput setaf 1)Hello, world$(tput sgr0)"
Ignacio Vazquez-Abrams
źródło
8
To powinna być najlepsza opcja. to, co robi tput , to odczytuje informacje o terminalu i wyświetla poprawny kod ANSI dla ciebie. kod jak\033[31m spowoduje uszkodzenie biblioteki readline w niektórych terminalach.
Tian Chen,
44
Eksploruj kolory za pomocą prostej pętli (zwiększ igórną granicę, aby uzyskać więcej odcieni):for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done
msanford
2
Oto HOWTO na temat kodów tput: tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
maxywb
tput: command not found (na alpejskim)
dgallant
127
echo -e "\033[31m Hello World"

[31mKontroluje kolor tekstu:

  • 30- 37ustawia kolor pierwszego planu
  • 40- 47ustawia kolor tła

Pełniejszą listę kodów kolorów można znaleźć tutaj .

Dobrą praktyką jest resetowanie koloru tekstu z powrotem do \033[0mkońca łańcucha.

neocanable
źródło
2
echo -e "\ 033 [31m Hello World", [31m jest kolorem
neocanable
36

Właśnie połączyłem dobre połowy we wszystkich rozwiązaniach i otrzymałem:

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

Możesz to po prostu nazwać:

cecho "RED" "Helloworld"
Andrew Naguib
źródło
1
Bardzo praktyczne, po prostu musiałem zastąpić pojedyncze cudzysłowy podwójnymi cudzysłowami dla GREEN, YELLOW, NC, aby działało w moim skrypcie.
ionescu77
1
Świetne rozwiązanie !!
David Kariuki
31

To jest przełącznik kolorów \033[ . Zobacz historię .

Kody kolorów są takie jak 1;32(jasnozielony), 0;34(niebieski), 1;34(jasnoniebieski) itp.

Wypowiedzieć sekwencje kolorów z przełącznikiem kolorów \033[i 0m, w żaden kod -Color. Podobnie jak otwieranie i zamykanie kart w języku znaczników.

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

Proste echorozwiązanie funkcji koloru :

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!"
Jorge Bucaran
źródło
1
Zmienię ostatnią textzmienną w text="$color${@: 2}${code}0m"ten sposób, że cała linia oprócz parametru koloru zostanie pokolorowana.
Shairon Toledo,
@tomazahlin po prostu dodaj -e do echa, jak kilka razy wspomniano powyżej
Artem Miedwiediew
28

Dobrym sposobem na zmianę koloru tylko dla jednego echojest zdefiniowanie takiej funkcji:

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

Stosowanie:

coloredEcho "This text is green" green

Lub możesz bezpośrednio użyć kodów kolorów wymienionych w odpowiedzi Drew :

coloredEcho "This text is green" 2
Alireza Mirian
źródło
Jeśli dodasz -ndo echa, możesz użyć go jako kolorowania w echo "Red `coloredEcho "fox" red` jumps over the lazy dog"
wierszu
23

Służy tputdo obliczania kodów kolorów. Unikaj używania kodu ucieczkowego ANSI (np. \E[31;1mCzerwonego), ponieważ jest on mniej przenośny. Na przykład Bash w OS X nie obsługuje tego.

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"
Wilfred Hughes
źródło
18

Odpowiedź na to pytanie była wciąż powtarzana :-), ale dlaczego nie.

Pierwsze użycie tputjest bardziej przenośne w nowoczesnych środowiskach niż ręczne wstrzykiwanie kodów ASCIIecho -E

Oto funkcja szybkiego bashu:

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

Teraz możesz użyć:

 say @b@green[[Success]] 

uzyskać:

Odważny zielony sukces

Uwagi na temat przenośności tput

Pierwszy raz tput(1)Kod źródłowy po został przesłany we wrześniu 1986 roku

tput(1) był dostępny w semantyce X / Open curses w latach 90. (standard 1997 ma semantykę wymienioną poniżej).

Jest więc ( dość ) wszechobecny.

Ahmed Masud
źródło
To jest całkiem niezłe! Nie wiedziałem tego. Czy możesz powiedzieć coś o dostępności tput? Czy jest dostępny na większości serwerów, na których nie ma uprawnień administratora, aby go zainstalować? Czy masz link do miejsca, w którym ta technika została po raz pierwszy „wymyślona”?
Redsandro,
3
tput jest zgodnym ze standardami sposobem, aby to zrobić, w którym jest całkowicie niezależny od ciebie, znając możliwości terminala. Jeśli terminal nie obsługuje danej możliwości, z wdziękiem obniży poziom do wszystkiego, co może zrobić, bez wypychania nieprzyjemnych kodów ucieczki.
Ahmed Masud
1
Przestałem używać tej metody, ponieważ miesza się ona z pozycją kursora w liniach bash. Będzie losowo zawijał się przed końcem linii i nie wróci do samego końca linii, gdy używasz klawiszy home lub klawiszy strzałek. Powrót do niezdarnych ręcznych kodów ucieczki rozwiązuje ten problem.
Redsandro
2
@Resandro - czy to dlatego, że używasz go $PS1bez elementów nierozstawnych \[...\]? Nadal używaj znaczników Bash PS1 z ciągami tput.
Toby Speight
Zauważ, że ta funkcja nie działa w pełni w MacOsX z powodu różnic w narzędziu sed: unix.stackexchange.com/questions/13711/…
Jeff
14

Dzięki @ k-five za tę odpowiedź

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

Wynik

wprowadź opis zdjęcia tutaj

Mam nadzieję, że ten obraz pomoże Ci wybrać kolor dla twojego bash: D

cyber8200
źródło
14

Jeśli używasz zshlubbash

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'

Wypróbuj online

Vishal
źródło
14

Możemy użyć 24-bitowych kolorów RGB zarówno dla tekstu, jak i tła!

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

Przykładowy czerwony tekst i tag zamykający:

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

Generator:

24-bitowe: Ponieważ karty graficzne „true color” z 16 do 24 bitami koloru stały się powszechne, Xterm, Konsole KDE, a także wszystkie terminale oparte na libvte (w tym terminal GNOME) obsługują 24-bitowe ustawienie koloru pierwszego planu i tła https: / /en.wikipedia.org/wiki/ANSI_escape_code#24-bit

Czy korzystanie z moich skryptów jest bezpieczne?

Tak! Terminale 8 i 16 bitów wyświetlą po prostu kolor zastępczy w zakresie dostępnej palety, zachowując najlepszy kontrast, bez uszkodzeń!


Ponadto nikt nie zauważył przydatności odwróconego wideo ANSI code 7 .

Pozostaje czytelny na wszystkich schematach terminali, na czarnym lub białym tle lub na innych paletach fantazyjnych, poprzez zamianę kolorów pierwszego planu i tła.

Przykład: czerwone tło, które działa wszędzie:

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

Oto jak wygląda zmiana schematów wbudowanych w terminal:

wprowadź opis zdjęcia tutaj

To jest skrypt pętli używany dla gif.

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

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

NVRM
źródło
11

Te kody działają na moim pudełku Ubuntu:

wprowadź opis zdjęcia tutaj

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"

Spowoduje to wydrukowanie liter abcd w różnych kolorach:

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

Dla pętli:

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

wprowadź opis zdjęcia tutaj

Eric Leschinski
źródło
2
Nawiasem mówiąc: nie zależy to w dużej mierze od zainstalowania konkretnej wersji ubuntu, ale od używania PuTTY!
urzeit
11

Znalazłem niesamowitą odpowiedź Shakiby Moshiri , gdy szukałem informacji na ten temat… wtedy wpadłem na pomysł… i uzyskałem całkiem niezłą funkcję, niezwykle łatwą w użyciu 😁
Więc muszę się z tym podzielić 😉

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

Zastosowanie: $(c <flags>) wewnątrz echo -elubprintf

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

Przykłady:

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."
Pascal Polleunus
źródło
10

Dla czytelności

Jeśli chcesz poprawić czytelność kodu, możesz echonajpierw napis, a następnie dodaj kolor, używając sed:

echo 'Hello World!' | sed $'s/World/\e[1m&\e[0m/' 
Ooker
źródło
1
Naprawdę podoba mi się ta odpowiedź! Czy możesz jednak wyjaśnić $ w poleceniu sed?
Patrick
2
$ „<something>” jest dla bash, a nie sed. Mówi bashowi, aby przetworzył \ e jako sekwencję zmiany znaczenia i wstawił znak „escape”. Zazwyczaj widzisz prostsze formularze, takie jak $ '\ t' lub $ '\ n', aby znak tabulacji lub znaku nowej linii był przekazywany do znaku Komenda.
dsz
8

Jak dotąd moją ulubioną odpowiedzią jest kolorowy Echo.

Aby opublikować inną opcję, możesz sprawdzić to małe narzędzie xcol

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

używasz go tak samo jak grep, i na przykład pokoloruje on stdin innym kolorem dla każdego argumentu

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

przykład xcol

Zauważ, że akceptuje każde wyrażenie regularne, które sed zaakceptuje.

To narzędzie wykorzystuje następujące definicje

#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

Używam tych zmiennych w moich skryptach w taki sposób

echo "${red}hello ${yellow}this is ${green}coloured${normal}"
nachoparker
źródło
6

Aby rozwinąć tę odpowiedź , dla leniwych z nas:

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"
Mahn
źródło
2
Nie koduj ucieczki terminala. Użyj tput; po to jest!
Toby Speight
@TobySpeight Chociaż może tak być w przypadku obsługi wieloplatformowej (teoretycznie), jeśli plakat odkryje, że działa we własnym świecie, dlaczego nie zgadza się i zniechęca innych w podobnym świecie do korzystania z tej techniki? W tym przypadku próbuję podobnie w bash Ubuntu 16.04 i działa. Jako jedyny użytkownik na tej platformie uważam tę odpowiedź za akceptowalną. Będę również używał tputdo sci rcchociaż (zapisz kursor, przywróć kursor). Chociaż ta odpowiedź nazywa mnie „leniwą”, można ją przeredagować jako „praktyczną” lub „od razu do rzeczy”.
WinEunuuchs2Unix
Moje własne rozwiązanie było podobne do tego, ograniczone wyłącznie do wbudowanych powłok, ponieważ rozwidlenie dwóch procesów zewnętrznych, podpowłoki itp. Dla każdej wiadomości w skrypcie miało po prostu ... nieprzyjemny zapach.
Amit Naidu
6

aby wyświetlić wyjście komunikatu w innym kolorze, możesz:

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

-Czarny 0; 30 ciemnoszary 1; 30

-Red 0; 31 Jasnoczerwony 1; 31

-Zielony 0; 32 Jasnozielony 1; 32

-Brązowy / pomarańczowy 0; 33 żółty 1; 33

-Niebieski 0; 34 Jasnoniebieski 1; 34

-Urpurowy 0; 35 jasnofioletowy 1; 35

-Cyjan 0; 36 Jasny cyjan 1; 36

-Jasnoszary 0; 37 Biały 1; 37

Amirouche Zeggagh
źródło
5

Zdecydowanie powinieneś użyć tput zamiast surowych sekwencji kontrolnych ANSI.

Ponieważ istnieje wiele różnych języków sterowania terminalami, zwykle system ma pośrednią warstwę komunikacyjną. Rzeczywiste kody są wyszukiwane w bazie danych dla aktualnie wykrytego typu terminala, a użytkownik wysyła znormalizowane żądania do interfejsu API lub (z powłoki) do polecenia.

Jednym z tych poleceń jest tput. tputakceptuje zestaw akronimów zwanych nazwami zdolności i dowolnymi parametrami, jeśli to właściwe, a następnie wyszukuje prawidłowe sekwencje specjalne dla wykrytego terminala w bazie danych terminfo i drukuje prawidłowe kody (mam nadzieję, że terminal to rozumie).

od http://wiki.bash-hackers.org/scripting/terminalcodes

To powiedziawszy, napisałem małą bibliotekę pomocników o nazwie bash-tint , która dodaje kolejną warstwę nad tput, dzięki czemu korzystanie z niej jest jeszcze prostsze (imho):

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

Dałby następujący wynik: wprowadź opis zdjęcia tutaj

ArtBIT
źródło
5

I zamiast kodowania kodów ucieczkowych, które są specyficzne dla twojego obecnego terminala, powinieneś użyć tput.

To jest mój ulubiony skrypt demo:

#!/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 kolorów wyjściowych według tput

Bruno Bronosky
źródło
4

Używam tego do drukowania w kolorze

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

Wszystkie podstawowe kolory ustawione jako zmienne, a także kilka przydatnych funkcji: XY, linia i que. Źródło tego skryptu w jednym ze swoich i użyj wszystkich zmiennych kolorów i funkcji.

Ivan
źródło
3

I to, co kiedyś widziałem wszystkie kombinacje i zdecydowałem, które brzmi fajnie:

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
isntn
źródło
2

Napisałem swag, aby to osiągnąć.

Możesz po prostu zrobić

pip install swag

Teraz możesz zainstalować wszystkie polecenia ucieczki jako pliki TXT do danego miejsca docelowego poprzez:

swag install -d <colorsdir>

Lub jeszcze łatwiej poprzez:

swag install

Które zainstalują kolory ~/.colors.

Albo użyjesz ich w ten sposób:

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

Lub w ten sposób, który wydaje mi się bardziej interesujący:

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

Sprawdź to na asciinema !

throws_exceptions_at_you
źródło
0

Oto prosty, mały skrypt, który ostatnio przygotowałem, który pokoloruje wszelkie dane wejściowe w potoku zamiast używania „Toalety”.

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 

Następnie nazwij to kolorem czerwonym (196):
$> echo "text you want colored red" | color.bsh 196


źródło
Logika pętli kolorów została znaleziona w tym przyzwoitym samouczku kolorów Ascii: misc.flogisoft.com/bash/tip_colors_and_formatting
-1

Odnosić się do:

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"
}
Mikrofon
źródło
Zauważ, że funkcja echo_green powinna mieć kod 32 zamiast 33. Nie można edytować b / c stackoverflow wymaga co najmniej 6 znaków edycji.
Daniel
-2

Oto najprostsze i czytelne rozwiązanie. W przypadku bashj ( https://sourceforge.net/projects/bashj/ ) wystarczy wybrać jedną z tych linii:

#!/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 kolory są dostępne, jeśli masz obsługę kolorów w aplikacji terminalowej.

Fil
źródło
-3

po zmieszaniu innych rozwiązań z wątku oto, jak udało mi się uzyskać kolory na npm scriptswydruku (gitbash CLI):

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

wprowadź opis zdjęcia tutaj

godblessstrawberry
źródło
-4

Podobnie jak coś trochę tam, przejście przez grep podświetli go na czerwono (ale tylko na czerwono). Możesz także użyć nazwanych potoków, aby łańcuch był bliżej końca linii:

 grep '.*' --color=always <(echo "foobar")
FinalDuty
źródło
brakuje Ci możliwości wyboru koloru. również grep jako narzędzie do barwienia jest naprawdę wątpliwe: P
Ahmed Masud
Nie bardzo, OP specjalnie wspomniało, że chcą czerwonego. Zgadzam się, że istnieją lepsze opcje niż używanie grep, ale osiąga to, o co prosili i oszczędza konieczności uczenia się czegoś bardziej złożonego.
FinalDuty
-5
red='\e[0;31m'
NC='\e[0m' # No Color
echo -e "${red}Hello Stackoverflow${NC}"

Ta odpowiedź jest poprawna, z tym wyjątkiem, że wezwanie do kolorów nie powinno znajdować się w cudzysłowie.

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

Powinien załatwić sprawę.

Dale Corns
źródło
3
Działa dobrze wewnątrz cytatów. Przełącznik -e również ocenia to, co jest w cudzysłowach. Uruchomienie obu (wewnątrz i na zewnątrz cudzysłowów) za pomocą bash -x wyświetla to samo wykonane polecenie echo -e '\e[0;31mHello Stackoverflow\e[0m'. Tak samo jest z bash.
naab