Tôi đang cố gắng in một văn bản trong thiết bị đầu cuối bằng lệnh echo.

Tôi muốn in văn bản màu đỏ. Làm thế nào tôi có thể làm điều đó?

Bạn có thể sử dụng các mã thoát ANSI này :

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

Và sau đó sử dụng chúng như thế này trong kịch bản của bạn:

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

Mà in lovemàu đỏ.

Từ nhận xét của @ james-lim, nếu bạn đang sử dụng echolệnh, hãy chắc chắn sử dụng cờ -e để cho phép thoát dấu gạch chéo ngược .

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

(không thêm "\n"khi sử dụng echo trừ khi bạn muốn thêm dòng trống bổ sung)

Bạn có thể sử dụng tputlệnh tuyệt vời (được đề xuất trong câu trả lời của Ignacio ) để tạo mã kiểm soát đầu cuối cho tất cả các loại.

Sử dụng

Các tputlệnh phụ cụ thể sẽ được thảo luận sau.

Thẳng thắn

Gọi tputnhư một phần của chuỗi lệnh:

tput setaf 1; echo "this is red text"

Sử dụng ;thay vì &&như vậy nếu tputlỗi văn bản vẫn hiển thị.

Biến Shell

Một tùy chọn khác là sử dụng các biến shell:

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

tputtạo ra các chuỗi ký tự được hiểu bởi thiết bị đầu cuối có ý nghĩa đặc biệt. Họ sẽ không được hiển thị chính họ. Lưu ý rằng chúng vẫn có thể được lưu vào các tệp hoặc được xử lý như đầu vào bởi các chương trình khác ngoài thiết bị đầu cuối.

Thay thế lệnh

Có thể thuận tiện hơn khi chèn tputđầu ra trực tiếp vào echochuỗi của bạn bằng cách sử dụng thay thế lệnh :

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

Thí dụ

Lệnh trên tạo ra điều này trên Ubuntu:

Lệnh màu nền & màu nền

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

Màu sắc như sau:

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

Ngoài ra còn có các phiên bản không phải ANSI của các chức năng cài đặt màu ( setbthay vì setabvà setfthay vì setaf) sử dụng các số khác nhau, không được đưa ra ở đây.

Lệnh chế độ văn bản

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

Lệnh chuyển động con trỏ

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

Xóa và chèn lệnh

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

Các lệnh khác

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

Với các cửa sổbel lắc lư compiz , lệnh này làm cho thiết bị đầu cuối chao đảo trong một giây để thu hút sự chú ý của người dùng.

Chữ viết

tputchấp nhận các tập lệnh chứa một lệnh trên mỗi dòng, được thực hiện theo thứ tự trước khi tputthoát.

Tránh các tệp tạm thời bằng cách lặp lại một chuỗi nhiều dòng và đặt nó:

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

Xem thêm

• Xem man 1 tput
• Xem man 5 terminfođể biết danh sách đầy đủ các lệnh và biết thêm chi tiết về các tùy chọn này. (Lệnh tương ứng tputđược liệt kê trong Cap-namecột của bảng lớn bắt đầu từ dòng 81.)

Một số biến mà bạn có thể sử dụng:

# 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

ký tự thoát trong bash , hex và bát phân tương ứng:

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

ví dụ ngắn:

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

ngoại lệ bash:

Nếu bạn định sử dụng các mã này trong các biến bash đặc biệt của mình

• PS0
• PS1
• PS2 (= cái này là để nhắc)
• PS4

bạn nên thêm các ký tự thoát bổ sung để bashcó thể giải thích chúng một cách chính xác. Nếu không có thêm ký tự thoát này, nó sẽ hoạt động nhưng bạn sẽ gặp vấn đề khi bạn sử dụng Ctrl + rđể tìm kiếm trong lịch sử của mình.

quy tắc ngoại lệ cho bash

Bạn nên thêm \[trước bất kỳ mã ANSI bắt đầu nào và thêm \]sau bất kỳ mã kết thúc nào.
Ví dụ:
trong sử dụng thường xuyên: \033[32mThis is in green\033[0m
cho PS0 / 1/2/4: \[\033[32m\]This is in green\[\033[m\]

\[là dành cho sự khởi đầu của một chuỗi các không in ký tự
\]là kết thúc của một chuỗi các không in ký tự

Mẹo: để ghi nhớ nó, trước tiên bạn có thể thêm \[\]và sau đó đặt mã ANSI giữa chúng:
- \[start-ANSI-code\]
-\[end-ANSI-code\]

loại chuỗi màu:

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

Trước khi đi sâu vào các màu này, bạn nên biết về 4 chế độ với các mã sau:

1. chế độ màu

Nó sửa đổi phong cách của màu KHÔNG văn bản. Ví dụ làm cho màu sáng hoặc tối hơn.

• 0 cài lại
• 1; nhẹ hơn bình thường
• 2; tối hơn bình thường

Chế độ này không được hỗ trợ rộng rãi. Nó hoàn toàn hỗ trợ trên Gnome-Terminal.

2. chế độ văn bản

Chế độ này là để sửa đổi kiểu văn bản KHÔNG màu.

• 3; in nghiêng
• 4; gạch chân
• 5; chớp mắt (chậm)
• 6; chớp mắt (nhanh)
• 7; đảo ngược
• 8; ẩn giấu
• 9; Gạch bỏ

và gần như được hỗ trợ.
Ví dụ: KDE-Konsole hỗ trợ 5;nhưng Gnome-Terminal thì không và Gnome hỗ trợ 8;nhưng KDE thì không.

3. chế độ tiền cảnh

Chế độ này là để tô màu nền trước.

4. chế độ nền

Chế độ này là để tô màu nền.

Bảng bên dưới hiển thị tóm tắt phiên bản 3/4 bit của màu 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                                            |                                                                                       |
|------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|

Bảng bên dưới hiển thị tóm tắt phiên bản 8 bit của màu 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     |
|------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|

Bài kiểm tra nhanh 8 bit:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

Bảng dưới đây cho thấy một bản tóm tắt về phiên bản màu ANSI 24 bit

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

một số ảnh chụp màn hình

tóm tắt tiền cảnh 8 bit trong một .gif

tóm tắt nền 8 bit trong một .gif

tóm tắt màu sắc với các giá trị của họ

blinking trên thiết bị đầu cuối KDE

một Cmã đơn giản cho bạn thấy nhiều hơn

một công cụ tiên tiến hơn mà tôi đã phát triển để xử lý các màu này:

chế độ màu

chế độ văn bản bắn

kết hợp là OK

nhiều bức ảnh

Mẹo và thủ thuật cho người dùng và lập trình viên nâng cao:

Chúng ta có thể sử dụng các mã này trong một ngôn ngữ lập trình không?

Vâng, bạn có thể. Tôi có kinh nghiệm trongbash, c, c ++, d perl, trăn

Có phải họ làm chậm tốc độ của một chương trình?

Tôi nghĩ rằng không.

Chúng ta có thể sử dụng những thứ này trên Windows không?

3/4-bit Có, nếu bạn biên dịch mã với gcc
một số ảnh chụp màn hình trên Win-7

Làm thế nào để tính chiều dài của mã?

\033[ = 2, các phần khác 1

Chúng ta có thể sử dụng các mã này ở đâu?

Bất cứ nơi nào mà có một ttythông dịch viên
xterm, gnome-terminal, kde-terminal, mysql-client-CLIvà vân vân.
Ví dụ: nếu bạn muốn tô màu đầu ra của mình bằng mysql, bạn có thể sử dụngPerl

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

lưu trữ mã này trong một tên tệp: pcc(= Perl Colorize Character) và sau đó đặt tệp a hợp lệ PATHsau đó sử dụng nó ở bất cứ đâu bạn muốn.

ls | pcc
df | pcc

bên trong mysqlđầu tiên đăng ký nó pagervà sau đó thử:

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

Nó KHÔNG xử lý Unicode.

Làm các mã này chỉ làm màu?

Không, họ có thể làm rất nhiều điều thú vị. Thử:

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

hoặc là:

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

Có rất nhiều người mới bắt đầu muốn xóa màn hình system( "clear" )để bạn có thể sử dụng điều này thay vì system(3)gọi

Chúng có sẵn bằng Unicode không?

Đúng. \u001b

Phiên bản nào của những màu này là thích hợp hơn?

Nó rất dễ sử dụng 3/4-bit, nhưng nó chính xác và đẹp khi sử dụng 24-bit.
Nếu bạn không có kinh nghiệm vớihtmlvì vậy đây là một hướng dẫn nhanh chóng:
24 bit có nghĩa là: 00000000và 00000000và 00000000. Mỗi 8 bit là cho một màu cụ thể.
1..8là cho và 9..16cho và 17..24vì
vậy tronghtml #FF0000có nghĩa là và đây là: 255;0;0
tronghtml #00FF00có nghĩa là ở đây: 0;255;0
Điều đó có ý nghĩa? bạn muốn kết hợp màu gì với ba giá trị 8 bit này.

tham khảo:
Wikipedia
Trình tự thoát ANSI
tldp.org
tldp.org
misc.flogisoft.com
một số blog / trang web mà tôi không nhớ

Sử dụng tputvới setafkhả năng và một tham số của 1.

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

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

Các [31mđiều khiển màu văn bản:

• 30- 37bộ foreground màu
• 40- 47đặt màu nền

Một danh sách đầy đủ hơn về mã màu có thể được tìm thấy ở đây .

Đó là một thực hành tốt để thiết lập lại màu văn bản trở lại \033[0mở cuối chuỗi.

Tôi vừa hợp nhất các sản phẩm khai thác tốt trong tất cả các giải pháp và kết thúc với:

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

Và bạn chỉ có thể gọi nó là:

cecho "RED" "Helloworld"

Đây là công tắc màu \033[ . Xem lịch sử .

Mã màu như 1;32(Xanh nhạt), 0;34(Xanh dương), 1;34(Xanh nhạt), v.v.

Chúng tôi chấm dứt các chuỗi màu bằng một công tắc màu \033[và 0m, mã không màu. Cũng giống như mở và đóng các tab trong một ngôn ngữ đánh dấu.

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

echoGiải pháp chức năng màu đơn giản :

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

Một cách gọn gàng để thay đổi màu sắc chỉ dành cho một người echolà xác định chức năng đó:

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

Sử dụng:

coloredEcho "This text is green" green

Hoặc bạn có thể trực tiếp sử dụng mã màu được đề cập trong câu trả lời của Drew :

coloredEcho "This text is green" 2

Sử dụng tputđể tính mã màu. Tránh sử dụng mã thoát ANSI (ví dụ: \E[31;1mmàu đỏ) vì nó ít di động hơn. Bash trên OS X, ví dụ, không hỗ trợ nó.

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"

Câu hỏi này đã được trả lời nhiều lần :-) nhưng tại sao không.

Lần đầu tiên sử dụng tputcó tính di động cao hơn trong môi trường hiện đại hơn là tiêm mã ASCII thủ công thông quaecho -E

Đây là một chức năng bash nhanh:

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

Bây giờ bạn có thể sử dụng:

 say @b@green[[Success]] 

để có được:

Ghi chú về tính di động của tput

tput(1)Mã nguồn lần đầu tiên được tải lên vào tháng 9 năm 1986

tput(1) đã có sẵn trong ngữ nghĩa X / Open nguyền rủa vào những năm 1990 (tiêu chuẩn năm 1997 có ngữ nghĩa được đề cập dưới đây).

Vì vậy, nó ( khá ) có mặt khắp nơi.

Cảm ơn @ k-five vì câu trả lời này

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

Kết quả

Hy vọng hình ảnh này sẽ giúp bạn chọn màu cho bash của bạn: D

Nếu bạn đang sử dụng zshhoặcbash

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'

Thử trực tuyến

Chúng tôi có thể sử dụng 24 bit RGB màu sắc trung thực cho cả văn bản và nền!

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

Ví dụ văn bản màu đỏ và thẻ đóng:

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

Máy phát điện:

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-bit: Khi các card đồ họa "màu thật" với 16 đến 24 bit màu trở nên phổ biến, Xterm, KDE's Konsole, cũng như tất cả các thiết bị đầu cuối dựa trên libvte (bao gồm cả Gnome Terminal) hỗ trợ cài đặt màu nền trước và nền 24 bit https: / /en.wikipedia.org/wiki/ANSI_escape_code#24-bit

Có an toàn để sử dụng trong các kịch bản của tôi?

Đúng! Thiết bị đầu cuối 8 và 16 bit sẽ chỉ hiển thị dưới dạng màu dự phòng trên phạm vi của bảng màu có sẵn, giữ độ tương phản tốt nhất, không bị vỡ!

Ngoài ra, không ai nhận thấy tính hữu ích của video đảo ngược mã ANSI 7 .

Nó có thể đọc được trên bất kỳ sơ đồ màu thiết bị đầu cuối, nền đen hoặc trắng hoặc các bảng màu huyền ảo khác, bằng cách hoán đổi màu nền trước và màu nền.

Ví dụ, đối với nền đỏ hoạt động ở mọi nơi:

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

Đây là giao diện của nó khi thay đổi các sơ đồ dựng sẵn của thiết bị đầu cuối:

Đây là kịch bản vòng lặp được sử dụng cho gif.

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

Xem https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Gpson_Rendition)_parameter

Các mã này hoạt động trên hộp Ubuntu của tôi:

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"

Điều này in các chữ abcd tất cả các màu khác nhau:

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

Đối với vòng lặp:

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

Tôi đã tìm thấy câu trả lời tuyệt vời của Shakiba Moshiri trong khi tôi đang tìm kiếm thông tin về chủ đề đó, sau đó tôi có một ý tưởng và nó kết thúc với một chức năng khá hay, cực kỳ dễ sử dụng 😁
Vì vậy, tôi đã chia sẻ nó

https://github.com/ppo/bash- màu

Cách sử dụng: $(c <flags>) bên trong một echo -ehoặcprintf

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

Ví dụ:

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

Để dễ đọc

Nếu bạn muốn cải thiện khả năng đọc mã, bạn có thể echochuỗi trước sau đó thêm màu sau bằng cách sử dụng sed:

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

Câu trả lời yêu thích của tôi cho đến nay là colorEcho.

Chỉ cần đăng một tùy chọn khác, bạn có thể kiểm tra xcol công cụ nhỏ này

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

bạn sử dụng nó giống như grep và ví dụ, nó sẽ tô màu stdin của nó bằng một màu khác nhau cho mỗi đối số

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

Lưu ý rằng nó chấp nhận bất kỳ biểu thức chính quy nào mà sed sẽ chấp nhận.

Công cụ này sử dụng các định nghĩa sau

#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

Tôi sử dụng các biến này trong các kịch bản của tôi như vậy

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

Để mở rộng câu trả lời này , cho sự lười biếng của chúng tôi:

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"

để hiển thị đầu ra thông báo với màu khác nhau, bạn có thể thực hiện:

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

-Màu đen 0; 30 Xám đậm 1; 30

-Red 0; 31 Đỏ nhạt 1; 31

-Màu xanh 0; 32 Xanh nhạt 1; 32

-Brown / Orange 0; 33 Vàng 1; 33

-Màu xanh 0; 34 Ánh sáng xanh 1; 34

-Purple 0; 35 Màu tím nhạt 1; 35

-Cyan 0; 36 Ánh sáng Cyan 1; 36

-Light Gray 0; 37 Trắng 1; 37

Bạn chắc chắn nên sử dụng thông số trên các chuỗi điều khiển ANSI thô.

Bởi vì có một số lượng lớn các ngôn ngữ điều khiển thiết bị đầu cuối khác nhau, thông thường một hệ thống có lớp giao tiếp trung gian. Các mã thực được tra cứu trong cơ sở dữ liệu cho loại thiết bị đầu cuối hiện được phát hiện và bạn đưa ra các yêu cầu được tiêu chuẩn hóa cho một API hoặc (từ trình bao) cho một lệnh.

Một trong những lệnh này là tput. tputchấp nhận một tập hợp các từ viết tắt được gọi là tên khả năng và bất kỳ tham số nào, nếu phù hợp, sau đó tìm kiếm các chuỗi thoát chính xác cho thiết bị đầu cuối được phát hiện trong cơ sở dữ liệu terminfo và in mã chính xác (thiết bị đầu cuối hy vọng hiểu được).

từ http://wiki.bash-hackers.org/scripting/terminalcodes

Điều đó nói rằng, tôi đã viết một thư viện trợ giúp nhỏ gọi là bash-tint , thêm một lớp khác trên đầu trang, làm cho nó thậm chí còn đơn giản hơn để sử dụng (imho):

Thí dụ: tint "white(Cyan(T)Magenta(I)Yellow(N)Black(T)) is bold(really) easy to use."

Sẽ cho kết quả như sau:

Tôi thay vì mã thoát mã hóa cứng dành riêng cho thiết bị đầu cuối hiện tại của bạn, bạn nên sử dụng tput.

Đây là kịch bản demo yêu thích của tôi:

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

Tôi đang sử dụng điều này để in màu

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

Tất cả các màu cơ bản được đặt là vars và cũng có một số hàm hữu ích: XY, line và que. Nguồn kịch bản này trong một của bạn và sử dụng tất cả các lọ màu và chức năng.

Và đây là những gì tôi đã sử dụng để xem tất cả sự kết hợp và quyết định đọc tuyệt vời:

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

Tôi đã viết swag để đạt được điều đó.

Bạn chỉ có thể làm

pip install swag

Bây giờ bạn có thể cài đặt tất cả các lệnh thoát dưới dạng tệp txt đến đích đã cho thông qua:

swag install -d <colorsdir>

Hoặc thậm chí dễ dàng hơn thông qua:

swag install

Mà sẽ cài đặt màu sắc để ~/.colors .

Hoặc bạn sử dụng chúng như thế này:

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

Hoặc theo cách này, mà tôi thấy thực sự thú vị hơn:

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

Kiểm tra nó trên asciinema !

Đây là một kịch bản nhỏ đơn giản, tôi đã kết hợp gần đây, nó sẽ tô màu bất kỳ đầu vào đường ống nào thay vì sử dụng "Nhà vệ sinh".

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 

Sau đó gọi nó với màu đỏ (196):
$> echo "text you want colored red" | color.bsh 196

Hãy tham khảo

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

Đây là giải pháp đơn giản và dễ đọc nhất. Với bashj ( https://sourceforge.net/projects/bashj/ ), bạn chỉ cần chọn một trong những dòng sau:

#!/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 màu sắc có sẵn nếu bạn có hỗ trợ màu trong ứng dụng đầu cuối của bạn.

sau khi trộn các giải pháp khác từ luồng ở đây, làm thế nào tôi quản lý để có được màu sắc ở npm scriptsđầu ra (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"
}

Cũng giống như một cái gì đó ngoài kia, đi qua grep sẽ làm nổi bật nó thành màu đỏ (nhưng chỉ màu đỏ). Bạn cũng có thể sử dụng các đường ống được đặt tên để chuỗi của bạn ở gần cuối dòng:

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

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

Câu trả lời này đúng, ngoại trừ việc gọi các màu không được nằm trong dấu ngoặc kép.

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

Nên làm thủ thuật.