लिनक्स में इको के आउटपुट रंग को कैसे बदलें


1735

मैं इको कमांड का उपयोग करके टर्मिनल में एक टेक्स्ट प्रिंट करने की कोशिश कर रहा हूं।

मैं टेक्स्ट को लाल रंग में प्रिंट करना चाहता हूं। मैं उसे कैसे कर सकता हूँ?


30
यह लिंक बहुत मददगार है: misc.flogisoft.com/bash/tip_colors_and_formatting
Pithikos

इस पर एक नज़र डालें, जो मैंने आपके प्रश्न का उत्तर दिया: stackoverflow.com/a/48216286/3782119
शयन अमानी

जवाबों:


2292

आप इन एएनएसआई एस्केप कोड का उपयोग कर सकते हैं :

Black        0;30     Dark Gray     1;30
Red          0;31     Light Red     1;31
Green        0;32     Light Green   1;32
Brown/Orange 0;33     Yellow        1;33
Blue         0;34     Light Blue    1;34
Purple       0;35     Light Purple  1;35
Cyan         0;36     Light Cyan    1;36
Light Gray   0;37     White         1;37

और फिर उन्हें इस तरह अपनी स्क्रिप्ट में उपयोग करें:

#    .---------- constant part!
#    vvvv vvvv-- the code from above
RED='\033[0;31m'
NC='\033[0m' # No Color
printf "I ${RED}love${NC} Stack Overflow\n"

जो loveलाल रंग में प्रिंट करता है।

@ James-lim की टिप्पणी से, यदि आप echoकमांड का उपयोग कर रहे हैं , तो बैकस्लैश से बचने की अनुमति देने के लिए -e ध्वज का उपयोग करना सुनिश्चित करें

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

( "\n"जब तक आप अतिरिक्त खाली पंक्ति नहीं जोड़ना चाहते, तब तक इको का उपयोग न करें)


11
मेरे लिए काम नहीं करता है - आउटपुट:\e[0;31mHello Stackoverflow\e[0m
बेन हेरोल्ड

171
क्या आपने इसे "-ई" के साथ आज़माया? यह echoबैकस्लैश एस्के को सक्षम करने के लिए कहता है।
जेम्स लिम

141
MacOSX में, के \x1Bबजाय का उपयोग कर \e\033सभी प्लेटफार्मों के लिए ठीक होगा।
जिओ

4
एक चींटी की संपत्ति फ़ाइल में esacpe के लिए यूनिकोड का उपयोग करें, जैसे लाल = \ u001b [0; 31m
shonky linux उपयोगकर्ता

20
जैसे एमएसएनफोर्ड ने टुट के लिए बनाया है, यहाँ "ANSI- इंद्रधनुष" हैfor (( i = 30; i < 38; i++ )); do echo -e "\033[0;"$i"m Normal: (0;$i); \033[1;"$i"m Light: (1;$i)"; done
हर

970

आप सभी प्रकार की चीजों के लिए टर्मिनल कंट्रोल कोड बनाने के लिए कमाल के tputकमांड ( इग्नासियो के जवाब में सुझाए गए ) का उपयोग कर सकते हैं।


प्रयोग

विशिष्ट tputउप-आदेशों पर बाद में चर्चा की जाती है।

प्रत्यक्ष

tputआदेशों के अनुक्रम के भाग के रूप में कॉल करें :

tput setaf 1; echo "this is red text"

यदि पाठ अभी भी दिखाता है तो त्रुटियों के ;बजाय इसका उपयोग करें ।&&tput

शैल चर

एक अन्य विकल्प शेल चरों का उपयोग करना है:

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

tputएक विशेष अर्थ होने के रूप में टर्मिनल द्वारा व्याख्या किए गए चरित्र अनुक्रम पैदा करता है। उन्हें खुद नहीं दिखाया जाएगा। ध्यान दें कि उन्हें अभी भी फ़ाइलों में सहेजा जा सकता है या टर्मिनल के अलावा अन्य कार्यक्रमों द्वारा इनपुट के रूप में संसाधित किया जा सकता है।

कमान प्रतिस्थापन

कमांड प्रतिस्थापन का उपयोग करके tputसीधे अपने echoस्ट्रिंग्स में आउटपुट सम्मिलित करना अधिक सुविधाजनक हो सकता है :

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

उदाहरण

उपरोक्त कमांड उबंटू पर इसका निर्माण करता है:

रंग टर्मिनल पाठ का स्क्रीनशॉट


अग्रभूमि और पृष्ठभूमि रंग आदेश

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

रंग इस प्रकार हैं:

Num  Colour    #define         R G B

0    black     COLOR_BLACK     0,0,0
1    red       COLOR_RED       1,0,0
2    green     COLOR_GREEN     0,1,0
3    yellow    COLOR_YELLOW    1,1,0
4    blue      COLOR_BLUE      0,0,1
5    magenta   COLOR_MAGENTA   1,0,1
6    cyan      COLOR_CYAN      0,1,1
7    white     COLOR_WHITE     1,1,1

रंग सेटिंग फ़ंक्शन के गैर-एएनएसआई संस्करण भी हैं ( setbइसके बजाय setab, और setfइसके बजायsetaf ) के जो यहां दिए गए विभिन्न नंबरों का उपयोग करते हैं।

पाठ मोड आदेश

tput bold    # Select bold mode
tput dim     # Select dim (half-bright) mode
tput smul    # Enable underline mode
tput rmul    # Disable underline mode
tput rev     # Turn on reverse video mode
tput smso    # Enter standout (bold) mode
tput rmso    # Exit standout mode

कर्सर आंदोलन आदेश

tput cup Y X # Move cursor to screen postion X,Y (top left is 0,0)
tput cuf N   # Move N characters forward (right)
tput cub N   # Move N characters back (left)
tput cuu N   # Move N lines up
tput ll      # Move to last line, first column (if no cup)
tput sc      # Save the cursor position
tput rc      # Restore the cursor position
tput lines   # Output the number of lines of the terminal
tput cols    # Output the number of columns of the terminal

साफ़ करें और कमांड डालें

tput ech N   # Erase N characters
tput clear   # Clear screen and move the cursor to 0,0
tput el 1    # Clear to beginning of line
tput el      # Clear to end of line
tput ed      # Clear to end of screen
tput ich N   # Insert N characters (moves rest of line forward!)
tput il N    # Insert N lines

अन्य आदेश

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

साथ Compiz wobbly खिड़कियों , belआदेश एक दूसरे उपयोगकर्ता का ध्यान आकर्षित करने के लिए के लिए टर्मिनल लडखडाना बनाता है।


स्क्रिप्ट

tput प्रति पंक्ति एक आदेश वाली स्क्रिप्ट को स्वीकार करता है, जिसे पहले क्रम में निष्पादित किया जाता है tput बाहर निकलने जाता है।

एक बहु-तार स्ट्रिंग की गूंज और इसे पाइप करके अस्थायी फ़ाइलों से बचें:

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

यह सभी देखें

  • देख man 1 tput
  • देखें man 5 terminfoआदेश और इन विकल्पों पर अधिक विवरण की पूरी सूची के लिए। (संबंधित tputकमांड Cap-nameलाइन 81 पर शुरू होने वाली विशाल तालिका के कॉलम में सूचीबद्ध है ।)

13
बहुत बढ़िया जवाब। यह वह है जिसने मुझे सबसे अधिक मदद की है। किसी और के लिए जो सोच रहा था कि मैं क्या सोच रहा था, $()एक कमांड प्रतिस्थापन है । सभी tput af 1करता है रंग कोड स्ट्रिंग उत्पन्न करता है, लेकिन कोड मुद्रण योग्य वर्ण नहीं हैं, इसलिए tput af 1अकेले टाइप करने से आउटपुट की एक रिक्त रेखा उत्पन्न होगी।
क्रिस मिडलटन

5
नोट: यदि आप CygWin का उपयोग कर रहे हैं और tput स्थापित नहीं हैncurses
Enrico

3
tput भी sedible, रंगीन cruft में पार्सिंग के लिए sed के अंदर काम करता है: gist.github.com/nickboldt/fab71da10bd5169ffdfa
nickboldt 19

1
tputरंगों की पूरी सूची के लिए यूनिक्स स्टेक्सएक्सचेंज
एंड्रयू

मुझे लगता है कि एक स्थान के साथ reset=`tput sgr0`होना चाहिए reset=`tput sgr 0`
बंदरों का

831

कुछ चर जो आप उपयोग कर सकते हैं:

# 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

क्रमशः बैश , हेक्स और ऑक्टल में एस्केप कैरेक्टर :

|       | bash  | hex    | octal   | NOTE                         |
|-------+-------+--------+---------+------------------------------|
| start | \e    | \x1b   | \033    |                              |
| start | \E    | \x1B   | -       | x cannot be capital          |
| end   | \e[0m | \x1m0m | \033[0m |                              |
| end   | \e[m  | \x1b[m | \033[m  | 0 is appended if you omit it |
|       |       |        |         |                              |

संक्षिप्त उदाहरण:

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

बैश अपवाद:

यदि आप इन कोड का उपयोग अपने विशेष बैश चर में करने जा रहे हैं

  • PS0
  • PS1
  • PS2 (= यह संकेत देने के लिए है)
  • PS4

आपको अतिरिक्त भागने वर्ण जोड़ना चाहिए ताकि उनकी सही व्याख्या कर सकते हैं। इसके बिना अतिरिक्त भागने वाले पात्रों को जोड़ने के बिना यह काम करता है लेकिन जब आप Ctrl + rअपने इतिहास में खोज के लिए उपयोग करते हैं तो आपको समस्याओं का सामना करना पड़ेगा ।

बैश के लिए अपवाद नियम

आपको \[किसी भी एएनएसआई कोड को शुरू करने से पहले जोड़ना चाहिए और \]किसी भी समाप्त होने के बाद जोड़ना चाहिए ।
उदाहरण:
नियमित उपयोग में: \033[32mThis is in green\033[0m
PS0 / 1/2/4 के लिए: \[\033[32m\]This is in green\[\033[m\]

\[के एक दृश्य की शुरुआत के लिए है प्रिंट न हो सकने पात्रों
\]का एक अनुक्रम के अंत के लिए है प्रिंट न हो सकने वर्ण

सुझाव: के लिए याद यह आप पहली बार में जोड़ सकते हैं \[\]और फिर उन दोनों के बीच अपने एएनएसआई कोड डाल:
- \[start-ANSI-code\]
-\[end-ANSI-code\]

रंग अनुक्रम का प्रकार:

  1. 3/4 बिट
  2. 8 बिट
  3. 24 बिट

इन रंगों में गोता लगाने से पहले, आपको इन कोड के साथ 4 मोड के बारे में पता होना चाहिए:

1. रंग-विधा

यह रंग नहीं पाठ की शैली को संशोधित करता है। उदाहरण के लिए, रंग उज्ज्वल या गहरा बनाएं।

  • 0 रीसेट
  • 1; सामान्य से हल्का
  • 2; सामान्य से अधिक गहरा

यह मोड व्यापक रूप से समर्थित नहीं है। यह गनोम-टर्मिनल पर पूरी तरह से समर्थन है।

2. पाठ-विधा

यह विधा टेक्स्ट नॉट कलर की शैली को संशोधित करने के लिए है।

  • 3; तिरछा
  • 4; रेखांकन
  • 5; निमिष (धीमा)
  • 6; निमिष (तेज)
  • 7; उलटना
  • 8; छिपाना
  • 9; काट देना

और लगभग समर्थित हैं।
उदाहरण के लिए केडीई-कोनसोल समर्थन करता है 5;लेकिन गनोम-टर्मिनल नहीं करता है और ग्नोम समर्थन करता है 8;लेकिन केडीई नहीं करता है।

3. अग्रभूमि मोड

यह मोड अग्रभूमि को रंगीन करने के लिए है।

4. बैकग्राउंड मोड

यह मोड बैकग्राउंड को कलर करने के लिए है।

नीचे दी गई तालिका ANSI- रंग के 3/4 बिट संस्करण का सारांश दिखाती है

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

नीचे दी गई तालिका ANSI- रंग के 8 बिट संस्करण का सारांश दिखाती है

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

8-बिट फास्ट टेस्ट:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

नीचे दी गई तालिका ANSI- रंग के 24 बिट संस्करण का सारांश दिखाती है

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

कुछ स्क्रीन शॉट्स

अग्रभूमि 8-बिट सारांश a .gif

foreground.gif

पृष्ठभूमि 8-बिट सारांश में .gif

background.gif

उनके मूल्यों के साथ रंग सारांश

यहां छवि विवरण दर्ज करें यहां छवि विवरण दर्ज करें यहां छवि विवरण दर्ज करें यहां छवि विवरण दर्ज करें

blinking केडीई-टर्मिनल पर

केडीई-निमिष

एक सरल Cकोड जो आपको अधिक दिखाता है

cecho_screenshot

एक और अधिक उन्नत उपकरण जो मैंने इन रंगों से निपटने के लिए विकसित किया है:

bline


रंग-मोड शॉट

फेड-सामान्य उज्ज्वल

पाठ मोड शॉट

केवल-पाठ मोड

संयोजन ठीक है

जोड़ना

अधिक शॉट्स


उन्नत उपयोगकर्ताओं और प्रोग्रामर के लिए टिप्स और ट्रिक्स:

क्या हम प्रोग्रामिंग भाषा में इन कोड का उपयोग कर सकते हैं?

हाँ तुम कर सकते हो। में अनुभव किया, , , ,

क्या वे एक कार्यक्रम की गति को धीमा कर रहे हैं?

मेरे ख़्याल से नहीं।

क्या हम विंडोज पर इनका उपयोग कर सकते हैं?

3/4-बिट हां, यदि आप विन -7 पर कुछ स्क्रीन-शॉट्स के साथ कोड संकलित करते हैंgcc

कोड की लंबाई की गणना कैसे करें?

\033[ = 2, अन्य भाग 1

हम इन कोड का उपयोग कहां कर सकते हैं?

कहीं भी है कि एक है ttyदुभाषिया
xterm, gnome-terminal, kde-terminal, mysql-client-CLIऔर इतने पर।
उदाहरण के लिए यदि आप अपने उत्पादन को mysql के साथ रंगना चाहते हैं तो आप उपयोग कर सकते हैंPerl

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

इस कोड को एक फ़ाइल नाम में संग्रहीत करें: pcc(= पर्ल कलर करेक्टर) और फिर फ़ाइल को एक मान्य में डालें और PATHफिर उसे कहीं भी उपयोग करें।

ls | pcc
df | pcc

अंदर mysqlपहले के लिए यह रजिस्टर pagerऔर फिर प्रयास करें:

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

पीसीसी

यह यूनिकोड को नहीं संभालता है।

क्या ये कोड केवल रंग-रोगन करते हैं?

नहीं, वे बहुत सारी दिलचस्प चीजें कर सकते हैं। प्रयत्न:

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

या:

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

बहुत सारे शुरुआती हैं जो स्क्रीन को साफ करना चाहते हैं system( "clear" )ताकि आप system(3)कॉल के बजाय इसका उपयोग कर सकें

क्या वे यूनिकोड में उपलब्ध हैं?

हाँ। \u001b

इन रंगों में से कौन सा संस्करण बेहतर है?

इसका उपयोग करना आसान है 3/4-bit, लेकिन यह उपयोग करने के लिए बहुत सटीक और सुंदर है 24-bit
यदि आपके पास अनुभव नहीं है: तो यहाँ एक त्वरित ट्यूटोरियल है
24 बिट का मतलब है: 00000000और 00000000और 00000000। प्रत्येक 8-बिट एक विशिष्ट रंग के लिए है।
1..8के लिए और के 9..16लिए और 17..24है
तो #FF0000मतलब और यहाँ यह है:255;0;0
में #00FF00इसका मतलब है जो यहाँ है: 0;255;0
क्या इसका कोई मतलब है? आप इन तीन 8-बिट मूल्यों के साथ किस रंग को जोड़ना चाहते हैं।


संदर्भ:
विकिपीडिया
ANSI से बचने के क्रम
tldp.org
tldp.org
misc.flogisoft.com
कुछ ब्लॉग / वेब-पेज जिन्हें मुझे याद नहीं है


69
क्या इस उत्तर पर कोई और वास्तव में चकित नहीं है ??
बेंज

14
यह निश्चित रूप से प्रसिद्धि का हॉल है, धन्यवाद।
फॉरएवरजेर 0

2
@NeilGuyLindberg कोई ऑक्टिकल शाब्दिक नहीं है, यह त्रुटि Node.js का ही हिस्सा है, जो स्वयं को सूचीबद्ध नहीं करती है। आप x1B[इसे खत्म करने के लिए उपयोग कर सकते हैं ।
शाकिबा मोशिरी

5
मैंने इस उत्तर को आगे बढ़ाने के लिए काफी दूर तक स्क्रॉल किया!
आरएनए

1
ऐसा लगता है, @ShakibaMoshiri ने इस विषय पर एक थीसिस लिखी xD चुटकुले, इस तरह के एक विस्तृत जवाब के लिए चीयर्स!
SH '

189

tputकी setafक्षमता और एक पैरामीटर के साथ उपयोग करें 1

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

8
यह सबसे अच्छा विकल्प होना चाहिए। tput क्या करता है यह टर्मिनल जानकारी को पढ़ेगा और आपके लिए सही ढंग से बच गए ANSI कोड को प्रस्तुत करेगा। कोड कुछ टर्मिनलों में रीडलाइन लाइब्रेरी \033[31mको तोड़ देगा ।
तियान चेन

44
एक साधारण लूप के साथ रंगों का अन्वेषण करें ( iअधिक रंगों के लिए ऊपरी सीमा for (( i = 0; i < 17; i++ )); do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; done
बढ़ाएं

2
यहाँ tput कोड पर एक HOWTO है: tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
maxywb

tput: command not found(अल्पाइन पर)
dgallant

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

[31mनियंत्रित करता है लेख का रंग:

  • 30- अग्रभूमि रंग 37सेट
  • 40- पृष्ठभूमि रंग 47सेट

रंग कोड की एक पूरी पूरी सूची यहां पाई जा सकती है

\033[0mस्ट्रिंग के अंत में पाठ रंग को वापस रीसेट करना अच्छा अभ्यास है ।


2
इको-ई "\ _33 [31 मी हैलो वर्ल्ड", [31
मी

36

मैंने सभी समाधानों में अच्छे कैच को अभी-अभी समाप्‍त किया है और समाप्‍त किया है:

cecho(){
    RED="\033[0;31m"
    GREEN="\033[0;32m"
    YELLOW="\033[1;33m"
    # ... ADD MORE COLORS
    NC="\033[0m" # No Color

    printf "${!1}${2} ${NC}\n"
}

और आप इसे केवल इस रूप में कह सकते हैं:

cecho "RED" "Helloworld"

1
बहुत ही व्यावहारिक, मुझे सिर्फ अपनी स्क्रिप्ट में काम करने के लिए GREEN, YELLOW, NC के लिए दोहरे उद्धरण चिह्नों के साथ एकल उद्धरणों को बदलना पड़ा।
आयनसु ion

1
महान समाधान !!
डेविड करुकी

31

यह रंग स्विच है \033[इतिहास देखें ।

कलर कोड इस तरह हैं 1;32(लाइट ग्रीन), 0;34(ब्लू), 1;34(लाइट ब्लू), आदि।

हम एक रंग स्विच के साथ रंग अनुक्रम को समाप्त करते हैं \033[और 0m, नो- कलर कोड। जैसे मार्कअप भाषा में टैब खोलना और बंद करना।

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

सरल रंग echoसमारोह समाधान:

cecho() {
  local code="\033["
  case "$1" in
    black  | bk) color="${code}0;30m";;
    red    |  r) color="${code}1;31m";;
    green  |  g) color="${code}1;32m";;
    yellow |  y) color="${code}1;33m";;
    blue   |  b) color="${code}1;34m";;
    purple |  p) color="${code}1;35m";;
    cyan   |  c) color="${code}1;36m";;
    gray   | gr) color="${code}0;37m";;
    *) local text="$1"
  esac
  [ -z "$text" ] && local text="$color$2${code}0m"
  echo "$text"
}

cecho "Normal"
cecho y "Yellow!"

1
मैं अंतिम textचर को text="$color${@: 2}${code}0m"इस तरह से बदल दूंगा कि रंग पैरामीटर को छोड़कर पूरी लाइन रंगीन हो जाएगी।
शैरॉन टोलेडो 15

@tomazahlin सिर्फ -E को प्रतिध्वनित करता है, जैसा कि कई बार ऊपर कहा गया है
आर्टेम मेदवेदेव

28

echoइस तरह के फंक्शन को परिभाषित करने के लिए केवल एक रंग बदलने का एक साफ तरीका है :

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

उपयोग:

coloredEcho "This text is green" green

या आप सीधे ड्रू के उत्तर में उल्लिखित कलर कोड का उपयोग कर सकते हैं :

coloredEcho "This text is green" 2

यदि आप -nप्रतिध्वनि में जोड़ते हैं तो आप इनलाइन रंग के रूप में उपयोग कर सकते हैंecho "Red `coloredEcho "fox" red` jumps over the lazy dog"
sobi3ch

23

tputरंग कोडों की गणना करने के लिए उपयोग करें । ANSI एस्केप कोड (उदाहरण के \E[31;1mलिए लाल) का उपयोग करने से बचें क्योंकि यह कम पोर्टेबल है। उदाहरण के लिए, ओएस एक्स पर बैश, इसका समर्थन नहीं करता है।

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"

18

इस सवाल का जवाब बार-बार दिया गया है :-) लेकिन क्यों नहीं।

पहली बार tputआधुनिक परिवेश में ASCII कोड को मैन्युअल रूप से इंजेक्ट करने की तुलना में अधिक पोर्टेबल हैecho -E

यहां एक त्वरित बैश फ़ंक्शन है:

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

अब आप उपयोग कर सकते हैं:

 say @b@green[[Success]] 

लेना:

बोल्ड-ग्रीन सफलता

की पोर्टेबिलिटी पर नोट्स tput

पहली बार tput(1)सोर्स कोड सितंबर 1986 में अपलोड किया गया था

tput(1) 1990 के दशक में एक्स / ओपन शाप शब्दार्थ में उपलब्ध है (1997 मानक में नीचे उल्लिखित शब्दार्थ है)।

तो, यह ( काफी ) सर्वव्यापी है।


यह बहुत अच्छा है! यह नहीं पता था। क्या आप उपलब्धता के बारे में कुछ कह सकते हैं tput? क्या यह अधिकांश सर्वरों पर उपलब्ध है जहां किसी के पास इसे स्थापित करने के लिए व्यवस्थापक अधिकार नहीं हैं? क्या आपके पास कोई लिंक है जहां इस तकनीक को पहले 'आविष्कार' किया गया था?
रेडसंड्रो

3
tput यह करने के लिए मानकों का अनुपालन करने वाला तरीका है, जहां यह टर्मिनल क्षमताओं को जानने के लिए पूरी तरह से स्वतंत्र है। यदि टर्मिनल किसी दिए गए क्षमता का समर्थन नहीं करता है तो यह खराब तरीके से डाउनग्रेड कर सकता है जो इसे बिना किसी पेचीदा बच कोड से बाहर धकेल सकता है।
अहमद मसूद

1
मैंने इस पद्धति का उपयोग करना बंद कर दिया है क्योंकि यह बैश लाइनों में कर्सर की स्थिति के साथ गड़बड़ करता है। यह लाइन के अंत से पहले बेतरतीब ढंग से लपेट जाएगा, और घर या तीर कुंजियों का उपयोग करते समय लाइन की शुरुआत में सभी तरह से वापस नहीं जाएगा। अनाड़ी मैनुअल एस्केप कोड पर वापस जाना इस समस्या को ठीक करता है।
रेडसेंड्रो

2
@Resandro - ऐसा इसलिए है क्योंकि आप इसे गैर-रिक्ति भागों के $PS1बिना उपयोग कर रहे हैं \[...\]? Tash स्ट्रिंग्स के साथ बैश PS1 मार्कर का उपयोग करना जारी रखें।
टॉबी स्पाईट

ध्यान दें कि यह फ़ंक्शन Mac उपयोगिता पर पूर्ण
Jeff

14

इस उत्तर के लिए @ k-पाँच का धन्यवाद

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

परिणाम

यहां छवि विवरण दर्ज करें

आशा है कि यह छवि आपको अपने बैश के लिए अपना रंग चुनने में मदद करेगी: डी


14

यदि आप उपयोग कर रहे हैं zshयाbash

black() {
    echo -e "\e[30m${1}\e[0m"
}

red() {
    echo -e "\e[31m${1}\e[0m"
}

green() {
    echo -e "\e[32m${1}\e[0m"
}

yellow() {
    echo -e "\e[33m${1}\e[0m"
}

blue() {
    echo -e "\e[34m${1}\e[0m"
}

magenta() {
    echo -e "\e[35m${1}\e[0m"
}

cyan() {
    echo -e "\e[36m${1}\e[0m"
}

gray() {
    echo -e "\e[90m${1}\e[0m"
}

black 'BLACK'
red 'RED'
green 'GREEN'
yellow 'YELLOW'
blue 'BLUE'
magenta 'MAGENTA'
cyan 'CYAN'
gray 'GRAY'

ऑनलाइन कोशिश करें


14

हम टेक्स्ट और बैकग्राउंड दोनों के लिए 24 बिट्स RGB असली रंगों का उपयोग कर सकते हैं !

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

उदाहरण लाल पाठ और समापन टैग:

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

जनरेटर:

24-बिट: 16 से 24 बिट रंग वाले "असली रंग" ग्राफिक कार्ड आम हो गए, Xterm, KDE's Konsole, साथ ही सभी libvte आधारित टर्मिनल (GNOME टर्मिनल सहित) 24-बिट अग्रभूमि और पृष्ठभूमि रंग का समर्थन करते हैं https: / /en.wikipedia.org/wiki/ANSI_escape_code#24-bit

क्या मेरी लिपियों में इसका उपयोग करना सुरक्षित है?

हाँ! 8 और 16 बिट्स टर्मिनलों बस उपलब्ध पैलेट की सीमा पर एक रंग के रूप में प्रदर्शित करेंगे, सबसे अच्छा विपरीत, कोई टूट नहीं!


इसके अलावा, किसी ने ANSI कोड 7 के उलट वीडियो की उपयोगिता पर ध्यान नहीं दिया

यह किसी भी टर्मिनल योजनाओं के रंग, काले या सफेद पृष्ठभूमि, या अन्य फ़िक्सेस पैलेट पर अग्रभूमि और पृष्ठभूमि के रंगों की अदला-बदली करके पठनीय रहता है।

उदाहरण, एक लाल पृष्ठभूमि के लिए जो हर जगह काम करती है:

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

टर्मिनल निर्मित योजनाओं को बदलते समय ऐसा लगता है:

यहां छवि विवरण दर्ज करें

यह gif के लिए उपयोग की जाने वाली लूप स्क्रिप्ट है।

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

Https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters देखें


11

ये कोड मेरे उबंटू बॉक्स पर काम करते हैं:

यहां छवि विवरण दर्ज करें

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"

यह अक्षरों को अलग-अलग रंगों में एबकॉर्ड करता है:

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

पाश के लिए:

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

यहां छवि विवरण दर्ज करें


2
वैसे: यह ubuntu के एक विशिष्ट संस्करण को स्थापित करने पर ज्यादा निर्भर नहीं करता है, लेकिन PuTTY का उपयोग करते हुए!
५१५ को ५:५०

10

पठनीयता के लिए

यदि आप कोड की पठनीयता में सुधार करना चाहते हैं , तो आप echoपहले स्ट्रिंग कर सकते हैं , फिर बाद में रंग का उपयोग करके जोड़ सकते हैं sed:

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

1
मुझे वास्तव में यह उत्तर पसंद है! क्या आप कृपया sed कमांड में $ की व्याख्या कर सकते हैं?
पैट्रिक

2
$ '<कुछ>' बैश के लिए है, सेड के लिए नहीं। यह एक अनुक्रम के रूप में \ e को संसाधित करने के लिए बैश बताता है, और एक "एस्केप" वर्ण डाल देता है। आमतौर पर आप टैब या न्यूलाइन वर्ण प्राप्त करने के लिए $ '\ t' या $ '\ n' जैसे सरल रूप देखते हैं। आदेश।
dsz

10

जब मैं उस विषय पर जानकारी देख रहा था तो मुझे शकीबा मोशिरी का भयानक उत्तर मिला ... तो मुझे एक विचार आया ... और यह एक बहुत अच्छा कार्य में उपयोग करने के लिए बहुत आसान हो गया 😁
तो मैं इसे साझा करना चाहता हूं osh

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

उपयोग: $(c <flags>) एक echo -eया अंदरprintf

 ┌───────┬─────────────────┬──────────┐   ┌───────┬─────────────────┬──────────┐
  Code   Style            Octal        Code   Style            Octal    
 ├───────┼─────────────────┼──────────┤   ├───────┼─────────────────┼──────────┤
    -    Foreground       \033[3..       B    Bold             \033[1m  
    _    Background       \033[4..       U    Underline        \033[4m  
 ├───────┼─────────────────┼──────────┤      F    Flash/blink      \033[5m  
    k    Black            ......0m       N    Negative         \033[7m  
    r    Red              ......1m    ├───────┼─────────────────┼──────────┤
    g    Green            ......2m       L    Normal (unbold)  \033[22m 
    y    Yellow           ......3m       0    Reset            \033[0m  
    b    Blue             ......4m    └───────┴─────────────────┴──────────┘
    m    Magenta          ......5m 
    c    Cyan             ......6m 
    w    White            ......7m 
 └───────┴─────────────────┴──────────┘

उदाहरण:

echo -e "$(c 0wB)Bold white$(c) and normal"
echo -e "Normal text… $(c r_yB)BOLD red text on yellow background… $(c _w)now on
  white background… $(c 0U) reset and underline… $(c) and back to normal."

8

मेरा अब तक का पसंदीदा उत्तर है रंगीन।

बस एक और विकल्प पोस्ट करने के लिए, आप इस छोटे टूल xcol को देख सकते हैं

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

आप इसे grep की तरह ही उपयोग करते हैं, और यह प्रत्येक तर्क के लिए एक अलग रंग के साथ अपने स्टड को रंग देगा, उदाहरण के लिए

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

xcol का उदाहरण

ध्यान दें कि यह किसी भी नियमित अभिव्यक्ति को स्वीकार करता है जो sed स्वीकार करेगा।

यह उपकरण निम्नलिखित परिभाषाओं का उपयोग करता है

#normal=$(tput sgr0)                      # normal text
normal=$'\e[0m'                           # (works better sometimes)
bold=$(tput bold)                         # make colors bold/bright
red="$bold$(tput setaf 1)"                # bright red text
green=$(tput setaf 2)                     # dim green text
fawn=$(tput setaf 3); beige="$fawn"       # dark yellow text
yellow="$bold$fawn"                       # bright yellow text
darkblue=$(tput setaf 4)                  # dim blue text
blue="$bold$darkblue"                     # bright blue text
purple=$(tput setaf 5); magenta="$purple" # magenta text
pink="$bold$purple"                       # bright magenta text
darkcyan=$(tput setaf 6)                  # dim cyan text
cyan="$bold$darkcyan"                     # bright cyan text
gray=$(tput setaf 7)                      # dim white text
darkgray="$bold"$(tput setaf 0)           # bold black = dark gray text
white="$bold$gray"                        # bright white text

मैं इन लिपियों का उपयोग अपनी लिपियों में करता हूँ

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

6

इस उत्तर पर विस्तार करने के लिए , हम में से आलसी के लिए:

function echocolor() { # $1 = string
    COLOR='\033[1;33m'
    NC='\033[0m'
    printf "${COLOR}$1${NC}\n"
}

echo "This won't be colored"
echocolor "This will be colorful"

2
हार्डकोड टर्मिनल से बच नहीं है। का उपयोग करें tput; इसके लिए क्या है!
टोबी स्पाइट

@TobySpeight हालांकि यह बहु-मंच समर्थन (सिद्धांत रूप में) के लिए सच हो सकता है, अगर पोस्टर पाता है कि यह अपनी दुनिया में काम करता है, तो तकनीक का उपयोग करने से समान दुनिया में दूसरों को असहमत और निराश क्यों करें? इस मामले में मैं Ubuntu 16.04 बैश में समान कोशिश कर रहा हूं और यह काम करता है। इस प्लेटफ़ॉर्म पर एकमात्र उपयोगकर्ता के रूप में मुझे यह उत्तर स्वीकार्य लगता है। मैं भी और के tputलिए उपयोग करेंगे (हालांकि, कर्सर को बचाएं, कर्सर को पुनर्स्थापित करें)। यद्यपि यह उत्तर मुझे "आलसी" कहता है, इसे "व्यावहारिक" या "सीधे बिंदु पर" के रूप में पुन: प्रस्तुत किया जा सकता है। scrc
विनयुनुच्स

मेरा स्वयं का समाधान इसी के समान था, शुद्ध रूप से निर्मित शेल तक ही सीमित था, क्योंकि स्क्रिप्ट में हर संदेश के लिए दो बाहरी प्रक्रियाओं, उपश्रेणियों इत्यादि के लिए सिर्फ एक अप्रिय गंध थी।
अमित नायडू

6

अलग-अलग रंग के साथ संदेश उत्पादन दिखाने के लिए आप कर सकते हैं:

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

-बैक ०; ३० डार्क ग्रे १; ३०

-रेड ०; ३१ लाइट रेड १; ३१

-ग्रीन ०; ३२ लाइट ग्रीन १; ३२

-ब्रोन / नारंगी ०; ३३ पीला १; ३३

-बलू ०; ३४ लाइट ब्लू १; ३४

-पुल ०, ३५ लाइट पर्पल १; ३५

—क्यान ०; ३६ प्रकाश सियान १; ३६

-लाइट ग्रे ०; ३ 1 श्वेत १; ३;


5

आपको कच्चे ANSI नियंत्रण अनुक्रमों पर निश्चित रूप से tput का उपयोग करना चाहिए।

क्योंकि विभिन्न टर्मिनल नियंत्रण भाषाओं की एक बड़ी संख्या है, आमतौर पर एक सिस्टम में एक मध्यवर्ती संचार परत होती है। वास्तविक कोड वर्तमान में खोजे गए टर्मिनल प्रकार के लिए एक डेटाबेस में देखे जाते हैं और आप एक कमांड के लिए एक एपीआई या शेल से मानकीकृत अनुरोध देते हैं।

इन आदेशों में से एक है tputtputक्षमता नाम और किसी भी पैरामीटर नामक योगों के एक सेट को स्वीकार करता है, यदि उपयुक्त हो, तो टर्मो डेटाबेस में पता लगाए गए टर्मिनल के लिए सही बच क्रमों को देखता है और सही कोड (टर्मिनल उम्मीद को समझता है) को प्रिंट करता है।

से http://wiki.bash-hackers.org/scripting/terminalcodes

उस ने कहा, मैंने बैश-टिंट नामक एक छोटी सहायक लाइब्रेरी लिखी है , जो कि tput के ऊपर एक और परत जोड़ती है, जिससे इसे उपयोग करना और भी सरल हो जाता है (imho):

उदाहरण: tint "white(Cyan(T)Magenta(I)Yellow(N)Black(T)) is bold(really) easy to use."

निम्नलिखित परिणाम देगा: यहां छवि विवरण दर्ज करें


5

मैं हार्ड कोडिंग एस्केप कोड के बजाय जो आपके वर्तमान टर्मिनल के लिए विशिष्ट हैं, आपको उपयोग करना चाहिए tput

यह मेरी पसंदीदा डेमो स्क्रिप्ट है:

#!/bin/bash

tput init

end=$(( $(tput colors)-1 ))
w=8
for c in $(seq 0 $end); do
    eval "$(printf "tput setaf %3s   " "$c")"; echo -n "$_"
    [[ $c -ge $(( w*2 )) ]] && offset=2 || offset=0
    [[ $(((c+offset) % (w-offset))) -eq $(((w-offset)-1)) ]] && echo
done

tput init

256 रंग आउटपुट द्वारा tput


4

मैं उपयोग कर रहा हूँ इस रंग मुद्रण के लिए

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

सभी मूल रंग var के रूप में सेट किए जाते हैं और कुछ उपयोगी कार्य भी होते हैं: XY, लाइन और कतार। इस स्क्रिप्ट को आप में से किसी एक में सोर्स करें और सभी कलर वैर और फंक्शन्स का उपयोग करें।


3

और यह मैं सभी संयोजन को देखता था और निर्णय लेता था कि कौन सा अच्छा है:

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

2

मैंने लिखा है कि बस हासिल करने के लिए स्वैग

आप बस कर सकते हैं

pip install swag

अब आप सभी बची हुई कमांडों को txt फ़ाइलों के माध्यम से किसी दिए गए गंतव्य पर स्थापित कर सकते हैं:

swag install -d <colorsdir>

या इससे भी आसान:

swag install

जो रंगों को स्थापित करेगा ~/.colors

या तो आप उन्हें इस तरह उपयोग करते हैं:

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

या इस तरह, जो मुझे वास्तव में अधिक दिलचस्प लगता है:

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

Asciinema पर इसे देखें !


0

यहाँ एक सरल छोटी स्क्रिप्ट है, मैंने हाल ही में एक साथ रखा, जो "टॉयलेट" का उपयोग करने के बजाय किसी भी पाइप किए गए इनपुट को रंग देगा।

File: color.bsh

#!/usr/bin/env bash 

## A.M.Danischewski 2015+(c) Free - for (all (uses and 
## modifications)) - except you must keep this notice intact. 

declare INPUT_TXT=""
declare    ADD_LF="\n" 
declare -i DONE=0
declare -r COLOR_NUMBER="${1:-247}"
declare -r ASCII_FG="\\033[38;05;"
declare -r COLOR_OUT="${ASCII_FG}${COLOR_NUMBER}m"

function show_colors() { 
   ## perhaps will add bg 48 to first loop eventually 
 for fgbg in 38; do for color in {0..256} ; do 
 echo -en "\\033[${fgbg};5;${color}m ${color}\t\\033[0m"; 
 (($((${color}+1))%10==0)) && echo; done; echo; done
} 

if [[ ! $# -eq 1 || ${1} =~ ^-. ]]; then 
  show_colors 
  echo " Usage: ${0##*/} <color fg>" 
  echo "  E.g. echo \"Hello world!\" | figlet | ${0##*/} 54" 
else  
 while IFS= read -r PIPED_INPUT || { DONE=1; ADD_LF=""; }; do 
  PIPED_INPUT=$(sed 's#\\#\\\\#g' <<< "${PIPED_INPUT}")
  INPUT_TXT="${INPUT_TXT}${PIPED_INPUT}${ADD_LF}"
  ((${DONE})) && break; 
 done
 echo -en "${COLOR_OUT}${INPUT_TXT}\\033[00m"
fi 

फिर इसे रंग लाल (196) के साथ कहें:
$> echo "text you want colored red" | color.bsh 196


कलर लूप लॉजिक इस सभ्य Ascii रंग ट्यूटोरियल में पाया गया: misc.flogisoft.com/bash/tip_colors_and_formatting

-1

को देखें:

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

ध्यान दें कि echo_green फ़ंक्शन में 33 के बजाय कोड 32 होना चाहिए। बी / सी स्टैकओवरफ़्लो को संपादित नहीं कर सकता है जिसमें कम से कम 6 वर्ण संपादित करने की आवश्यकता होती है।
डैनियल

-2

यहाँ सबसे सरल और पठनीय समाधान है। Bashj ( https://sourceforge.net/projects/bashj/ ) के साथ, आप बस इनमें से किसी एक लाइन को चुनेंगे:

#!/usr/bin/bash

W="Hello world!"
echo $W

R=130
G=60
B=190

echo u.colored($R,$G,$B,$W)

echo u.colored(255,127,0,$W)
echo u.red($W)
echo u.bold($W)
echo u.italic($W)

Y=u.yellow($W)
echo $Y
echo u.bold($Y)

256x256x256 रंग उपलब्ध हैं यदि आपके पास अपने टर्मिनल एप्लिकेशन में रंग का समर्थन है।


-3

धागे से अन्य समाधानों को मिलाने के बाद यहाँ बताया गया है कि मैं npm scriptsआउटपुट में रंग कैसे प्राप्त कर पाया (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"
}

यहां छवि विवरण दर्ज करें


-4

बस के रूप में कुछ वहाँ से बाहर, यह grep के माध्यम से गुजर रहा है यह लाल (लेकिन केवल लाल) के रूप में प्रकाश डाला जाएगा। आप नामित पाइपों का भी उपयोग कर सकते हैं ताकि आपकी स्ट्रिंग लाइन के अंत के करीब हो:

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

आपको अपनी पसंद के रंग का चयन करने में सक्षम होने की बात याद आ रही है। रंग उपयोगिता के रूप में भी वास्तव में संदिग्ध है: पी
अहमद मसूद

वास्तव में नहीं, ओपी ने विशेष रूप से उल्लेख किया कि वे लाल चाहते थे। मैं मानता हूं कि grep का उपयोग करने से बेहतर विकल्प हैं, लेकिन यह वही करता है जो उन्होंने पूछा था और कुछ और जटिल सीखने के लिए बचाता है।
फ़ाइनलडूट

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

यह उत्तर सही है, सिवाय इसके कि रंगों का कॉल उद्धरणों के अंदर नहीं होना चाहिए।

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

चाल चलनी चाहिए।


3
उद्धरण के अंदर ठीक काम करता है। -e स्विच का मूल्यांकन उद्धरणों में भी है। बैश -x का उपयोग करके दोनों (अंदर और बाहर के कोट्स) चलाना एक ही निष्पादित कमांड को आउटपुट करता है echo -e '\e[0;31mHello Stackoverflow\e[0m'। तो यह सिर्फ बैश के लिए एक ही है।
नाब
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.