Ich versuche, einen Text im Terminal mit dem Befehl echo zu drucken.

Ich möchte den Text in einer roten Farbe drucken. Wie kann ich das machen?

Sie können diese ANSI-Escape-Codes verwenden :

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

Und verwenden Sie sie dann wie folgt in Ihrem Skript:

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

welches lovein rot druckt .

Wenn Sie den echoBefehl aus dem Kommentar von @ james-lim verwenden, müssen Sie das Flag -e verwenden, um Backslash- Escapezeichen zuzulassen .

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

(Fügen Sie "\n"bei Verwendung von Echo nichts hinzu , es sei denn, Sie möchten zusätzliche Leerzeilen hinzufügen.)

Sie können den tputBefehl awesome (in Ignacios Antwort vorgeschlagen ) verwenden, um Terminalsteuerungscodes für alle möglichen Dinge zu erstellen.

Verwendungszweck

Bestimmte tputUnterbefehle werden später erläutert.

Direkte

Aufruf tputals Teil einer Befehlsfolge:

tput setaf 1; echo "this is red text"

Verwenden Sie ;stattdessen &&, wenn tputder Text weiterhin Fehler anzeigt.

Shell-Variablen

Eine andere Option ist die Verwendung von Shell-Variablen:

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

tputerzeugt Zeichenfolgen, die vom Terminal als besonders bedeutsam interpretiert werden. Sie werden nicht selbst gezeigt. Beachten Sie, dass sie weiterhin in Dateien gespeichert oder von anderen Programmen als dem Terminal als Eingabe verarbeitet werden können.

Befehlsersetzung

Es kann bequemer sein, tputdie Ausgabe echomithilfe der Befehlssubstitution direkt in Ihre Zeichenfolgen einzufügen :

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

Beispiel

Der obige Befehl erzeugt dies unter Ubuntu:

Befehle für Vordergrund- und Hintergrundfarben

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

Die Farben sind wie folgt:

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

Es gibt auch Nicht-ANSI-Versionen der Farbeinstellungsfunktionen ( setbanstelle von setabund setfanstelle von setaf), die unterschiedliche Zahlen verwenden, die hier nicht angegeben sind.

Textmodusbefehle

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

Cursorbewegungsbefehle

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

Befehle löschen und einfügen

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

Andere Befehle

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

Bei wackeligen Fenstern lässt der belBefehl das Terminal eine Sekunde lang wackeln, um die Aufmerksamkeit des Benutzers auf sich zu ziehen.

Skripte

tputAkzeptiert Skripte mit einem Befehl pro Zeile, die in der Reihenfolge vor dem tputBeenden ausgeführt werden.

Vermeiden Sie temporäre Dateien, indem Sie eine mehrzeilige Zeichenfolge wiederholen und weiterleiten:

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

Siehe auch

• Sehen man 1 tput
• Siehe man 5 terminfodie vollständige Liste der Befehle und weitere Informationen zu diesen Optionen. (Der entsprechende tputBefehl ist in der Cap-nameSpalte der großen Tabelle aufgeführt, die in Zeile 81 beginnt.)

Einige Variablen, die Sie verwenden können:

# 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

das Escape-Zeichen in Bash , Hex und Octal :

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

kurzes Beispiel:

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

Bash-Ausnahme:

Wenn Sie diese Codes in Ihren speziellen Bash-Variablen verwenden möchten

• PS0
• PS1
• PS2 (= dies dient zur Aufforderung)
• PS4

Sie sollten zusätzliche Escape-Zeichen hinzufügen, damit Bashkann sie richtig interpretieren. Ohne dieses Hinzufügen zusätzlicher Escape-Zeichen funktioniert es, aber Sie werden Probleme haben, wenn Sie Ctrl + rfür die Suche in Ihrem Verlauf verwenden.

Ausnahmeregel für Bash

Sie sollten \[vor jedem beginnenden ANSI-Code und \]nach jedem endenden hinzufügen.
Beispiel:
im regulären Gebrauch: \033[32mThis is in green\033[0m
für PS0 / 1/2/4: \[\033[32m\]This is in green\[\033[m\]

\[ist für den Beginn einer Folge von nicht druckbaren Zeichen
\]ist für das Ende einer Folge von nicht druckbaren Zeichen

Tipp: Zum Auswendiglernen können Sie zuerst \[\]Ihren ANSI-Code hinzufügen und dann dazwischen setzen:
- \[start-ANSI-code\]
-\[end-ANSI-code\]

Art der Farbsequenz:

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

Bevor Sie in diese Farben eintauchen, sollten Sie 4 Modi mit diesen Codes kennen:

1. Farbmodus

Es ändert den Farbstil NICHT Text. Machen Sie zum Beispiel die Farbe hell oder dunkler.

• 0 zurücksetzen
• 1; leichter als normal
• 2; dunkler als normal

Dieser Modus wird nicht allgemein unterstützt. Es wird auf Gnome-Terminal voll unterstützt.

2. Textmodus

Dieser Modus dient zum Ändern des Textstils, NICHT der Farbe.

• 3; kursiv
• 4; unterstreichen
• 5; blinkend (langsam)
• 6; blinkend (schnell)
• 7; umkehren
• 8; ausblenden
• 9; durchgestrichen

und werden fast unterstützt.
Zum Beispiel unterstützt KDE-Konsole, 5;aber Gnome-Terminal nicht und Gnome unterstützt, 8;aber KDE nicht.

3. Vordergrundmodus

Dieser Modus dient zum Färben des Vordergrunds.

4. Hintergrundmodus

Dieser Modus dient zum Färben des Hintergrunds.

Die folgende Tabelle zeigt eine Zusammenfassung der 3/4 Bit- Version von ANSI-color

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

Die folgende Tabelle zeigt eine Zusammenfassung der 8-Bit- Version von ANSI-Farbe

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

Der 8-Bit-Schnelltest:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

Die folgende Tabelle zeigt eine Zusammenfassung der 24-Bit- Version von ANSI-Farbe

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

einige Screenshots

Vordergrund 8-Bit-Zusammenfassung in a .gif

Hintergrund 8-Bit-Zusammenfassung in a .gif

Farbübersicht mit ihren Werten

blinking am KDE-Terminal

Ein einfacher CCode, der Ihnen mehr zeigt

Ein fortgeschritteneres Werkzeug, das ich entwickelt habe, um mit diesen Farben umzugehen:

Farbmodusaufnahme

Textmodus aufgenommen

Kombinieren ist OK

mehr Aufnahmen

Tipps und Tricks für fortgeschrittene Benutzer und Programmierer:

Können wir diese Codes in einer Programmiersprache verwenden?

Ja, du kannst. Ich habe in erlebtBash, c, c ++, d perl, Python

Verlangsamen sie die Geschwindigkeit eines Programms?

Ich denke nicht.

Können wir diese unter Windows verwenden?

3/4-Bit Ja, wenn Sie den Code mit einigen Screenshots unter Win-7 kompilierengcc

Wie berechnet man die Länge des Codes?

\033[ = 2, andere Teile 1

Wo können wir diese Codes verwenden?

Überall hat , dass ein ttyDolmetscher
xterm, gnome-terminal, kde-terminal, mysql-client-CLIund so weiter.
Wenn Sie beispielsweise Ihre Ausgabe mit MySQL einfärben möchten, können Sie sie verwendenPerl

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

Speichern Sie diesen Code in einem Dateinamen: pcc(= Perl Colorize Character) und fügen Sie die Datei in eine gültige Datei ein. PATHVerwenden Sie sie dann an einer beliebigen Stelle.

ls | pcc
df | pcc

innen mysqlerst registrieren pagerund dann versuchen:

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

Unicode wird NICHT verarbeitet.

Färben diese Codes nur?

Nein, sie können viele interessante Dinge tun. Versuchen:

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

oder:

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

Es gibt viele Anfänger, die den Bildschirm löschen möchten, system( "clear" )damit Sie dies anstelle eines system(3)Anrufs verwenden können

Sind sie in Unicode verfügbar?

Ja. \u001b

Welche Version dieser Farben ist vorzuziehen?

Es ist einfach zu bedienen 3/4-bit, aber es ist sehr genau und schön zu bedienen 24-bit.
Wenn Sie keine Erfahrung mit habenhtmlHier ist ein kurzes Tutorial:
24 Bit bedeutet: 00000000und 00000000und 00000000. Jedes 8-Bit ist für eine bestimmte Farbe.
1..8ist für und 9..16für und 17..24für
So inhtml #FF0000bedeutet und hier ist es:255;0;0
inhtml #00FF00bedeutet was hier ist: 0;255;0
Ist das sinnvoll? Welche Farbe Sie möchten, kombinieren Sie sie mit diesen drei 8-Bit-Werten.

Referenz:
Wikipedia
ANSI-Escape-Sequenzen
tldp.org
tldp.org
misc.flogisoft.com
einige Blogs / Webseiten, an die ich mich nicht erinnere

Verwenden Sie tputmit der setafFähigkeit und einem Parameter von 1.

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

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

Das [31msteuert die Textfarbe:

• 30- 37Sätze Vordergrund Farbe
• 40- 47Sätze Hintergrund Farbe

Eine vollständigere Liste der Farbcodes finden Sie hier .

Es wird empfohlen, die Textfarbe \033[0mauf das Ende der Zeichenfolge zurückzusetzen.

Ich habe gerade die guten Fänge in allen Lösungen zusammengeführt und am Ende Folgendes erhalten:

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

Und Sie können es einfach so nennen:

cecho "RED" "Helloworld"

Dies ist der Farbschalter \033[ . Siehe Geschichte .

Farbcodes sind wie 1;32(hellgrün), 0;34(blau), 1;34(hellblau), usw.

Wir beenden Farbsequenzen mit einem Farbschalter \033[und 0mdem No- Colour-Code. Genau wie das Öffnen und Schließen von Registerkarten in einer Auszeichnungssprache.

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

Einfache echoFarbfunktionslösung:

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

Eine gute Möglichkeit, die Farbe nur für eine Person zu ändern, echobesteht darin, eine solche Funktion zu definieren:

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

Verwendungszweck:

coloredEcho "This text is green" green

Oder Sie können direkt die in Drews Antwort genannten Farbcodes verwenden :

coloredEcho "This text is green" 2

Verwenden Sie tputdiese Option , um Farbcodes zu berechnen. Vermeiden Sie die Verwendung des ANSI-Escape-Codes (z. B. \E[31;1mfür Rot), da dieser weniger portabel ist. Bash unter OS X unterstützt dies beispielsweise nicht.

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"

Diese Frage wurde immer wieder beantwortet :-) aber warum nicht.

Die erste Verwendung tputist in modernen Umgebungen portabler als das manuelle Einfügen von ASCII-Codesecho -E

Hier ist eine schnelle Bash-Funktion:

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

Jetzt können Sie verwenden:

 say @b@green[[Success]] 

bekommen:

Hinweise zur Portabilität von tput

Erstes Mal tput(1) Quellcode wurde im September 1986 hochgeladen

tput(1) wurde in den 1990er Jahren in der X / Open-Curses-Semantik verfügbar (Standard von 1997 hat die unten erwähnte Semantik).

Es ist also ( ziemlich ) allgegenwärtig.

Vielen Dank an @ k-five für diese Antwort

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

Ergebnis

Hoffe, dieses Bild hilft Ihnen bei der Auswahl Ihrer Farbe für Ihre Bash: D.

Wenn Sie zshoder verwendenbash

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'

Versuchen Sie es online

Wir können 24-Bit-RGB-Echtfarben sowohl für Text als auch für Hintergrund verwenden!

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

Beispiel roter Text und schließendes Tag:

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

Generator:

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: Als "True Color" -Grafikkarten mit 16 bis 24 Bit Farbe üblich wurden, unterstützen Xterm, die Konsole von KDE sowie alle libvte-basierten Terminals (einschließlich GNOME-Terminal) die 24-Bit-Einstellung für die Vordergrund- und Hintergrundfarbe https: / /de.wikipedia.org/wiki/ANSI_escape_code#24-bit

Ist die Verwendung in meinen Skripten sicher?

Ja! 8- und 16-Bit-Terminals zeigen nur als Fallback eine Farbe im Bereich der verfügbaren Palette an, wobei der beste Kontrast erhalten bleibt, keine Brüche!

Außerdem bemerkte niemand die Nützlichkeit des umgekehrten ANSI-Code 7- Videos .

Durch Vertauschen der Vordergrund- und Hintergrundfarben bleibt es auf allen Terminalschemafarben, schwarzen oder weißen Hintergründen oder anderen Phantasiepaletten lesbar.

Beispiel für einen roten Hintergrund, der überall funktioniert:

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

So sieht es aus, wenn Sie die integrierten Terminalschemata ändern:

Dies ist das für das GIF verwendete Schleifenskript.

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

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

Diese Codes funktionieren auf meiner Ubuntu-Box:

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"

Dadurch werden die Buchstaben abcd alle in verschiedenen Farben gedruckt:

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

For-Schleife:

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

Ich fand Shakiba Moshiris großartige Antwort, als ich Informationen zu diesem Thema suchte… dann hatte ich eine Idee… und es endete mit einer sehr schönen Funktion, die extrem einfach zu bedienen war (
also muss ich sie teilen)

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

Verwendung: $(c <flags>) innerhalb eines echo -eoderprintf

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

Beispiele:

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

Zur besseren Lesbarkeit

Wenn Sie die Lesbarkeit des Codes verbessern möchten , können Sie zuerst echodie Zeichenfolge und später die Farbe hinzufügen, indem Sie Folgendes verwenden sed:

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

Meine bisherige Lieblingsantwort ist colouredEcho.

Um eine weitere Option zu veröffentlichen, können Sie sich dieses kleine Tool xcol ansehen

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

Sie verwenden es wie grep und es färbt sein stdin zum Beispiel für jedes Argument mit einer anderen Farbe

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

Beachten Sie, dass alle regulären Ausdrücke akzeptiert werden, die sed akzeptiert.

Dieses Tool verwendet die folgenden Definitionen

#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

Ich benutze diese Variablen in meinen Skripten wie folgt

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

Um diese Antwort für die Faulen von uns zu erweitern:

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"

So zeigen Sie die Nachrichtenausgabe in verschiedenen Farben an:

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

-Schwarz 0; 30 Dunkelgrau 1; 30

-Rot 0; 31 Hellrot 1; 31

-Grün 0; 32 Hellgrün 1; 32

-Braun / Orange 0; 33 Gelb 1; 33

-Blau 0; 34 Hellblau 1; 34

-Purple 0; 35 Light Purple 1; 35

-Cyan 0; 36 Light Cyan 1; 36

-Lichtgrau 0; 37 Weiß 1; 37

Sie sollten auf jeden Fall tput über rohe ANSI-Kontrollsequenzen verwenden.

Da es eine große Anzahl verschiedener Terminalsteuerungssprachen gibt, verfügt ein System normalerweise über eine Zwischenkommunikationsschicht. Die realen Codes werden in einer Datenbank nach dem aktuell erkannten Terminaltyp gesucht, und Sie geben standardisierte Anforderungen an eine API oder (von der Shell) an einen Befehl.

Einer dieser Befehle ist tput . tputAkzeptiert eine Reihe von Akronymen, die als Fähigkeitsnamen bezeichnet werden, und gegebenenfalls Parameter, sucht dann in der Terminfo-Datenbank nach den richtigen Escape-Sequenzen für das erkannte Terminal und druckt die richtigen Codes aus (das Terminal versteht dies hoffentlich).

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

Trotzdem habe ich eine kleine Hilfsbibliothek namens geschrieben bash-tint geschrieben Hilfsbibliothek , die zusätzlich zu tput eine weitere Ebene hinzufügt, was die Verwendung noch einfacher macht (imho):

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

Würde folgendes Ergebnis geben:

Ich sollte anstelle der harten Codierung von Escape-Codes, die für Ihr aktuelles Terminal spezifisch sind, verwenden tput .

Dies ist mein Lieblings-Demo-Skript:

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

Ich benutze dies für den Farbdruck

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

Alle Grundfarben sind als vars festgelegt und es gibt einige nützliche Funktionen: XY, line und que. Verwenden Sie dieses Skript in einem Ihrer Skripte und verwenden Sie alle Farbvarianten und -funktionen.

Und das, was ich verwendet habe, um alle Kombinationen zu sehen und zu entscheiden, was cool liest:

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

Ich habe Beute geschrieben , um genau das zu erreichen.

Du kannst es einfach tun

pip install swag

Jetzt können Sie alle Escape-Befehle als txt-Dateien an einem bestimmten Ziel installieren über:

swag install -d <colorsdir>

Oder noch einfacher über:

swag install

Welches wird die Farben installieren ~/.colors.

Entweder du benutzt sie so:

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

Oder so, was ich eigentlich interessanter finde:

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

Schau es dir im Asciinema an !

Hier ist ein einfaches kleines Skript, das ich kürzlich zusammengestellt habe und das alle leitungsgebundenen Eingaben einfärbt, anstatt "Toilette" zu verwenden.

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 

Dann nenne es mit der Farbe Rot (196):
$> echo "text you want colored red" | color.bsh 196

Beziehen auf:

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

Hier ist die einfachste und lesbarste Lösung. Mit bashj ( https://sourceforge.net/projects/bashj/ ) würden Sie einfach eine der folgenden Zeilen auswählen:

#!/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 Farben sind verfügbar, wenn Sie die Farbunterstützung in Ihrer Terminalanwendung haben.

Nachdem ich andere Lösungen aus dem Thread gemischt habe, habe ich npm scriptsFolgendes erreicht: Farben in der Ausgabe (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"
}

Genau wie etwas da draußen, wenn Sie es durch grep führen, wird es als rot (aber nur rot) hervorgehoben. Sie können auch Named Pipes verwenden, damit sich Ihre Zeichenfolge näher am Zeilenende befindet:

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

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

Diese Antwort ist korrekt, außer dass der Aufruf zu Farben nicht in Anführungszeichen stehen sollte.

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

Sollte den Trick machen.