wake-up-neo.com

So ändern Sie die Ausgabefarbe von Echo unter Linux

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

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

1493
satheesh.droid

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 dann benutze sie so in deinem 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"

dadurch wird love in Rot gedruckt.

Verwenden Sie in @ james-lims Kommentar , wenn Sie den Befehl echo verwenden, unbedingt das Flag -e, um umgekehrte Schrägstriche zuzulassen .

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

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

2007
Tobias

Sie können den fantastischen Befehl tput (vorgeschlagen in Ignacios Antwort ) verwenden, um Terminal-Steuercodes für alle möglichen Dinge zu erstellen.


Verwendungszweck

Spezifische tput Unterbefehle werden später erläutert.

Direkte

Rufen Sie tput als Teil einer Folge von Befehlen auf:

_tput setaf 1; echo "this is red text"
_

Verwenden Sie _;_ anstelle von _&&_. Wenn also tput Fehler auftreten, wird der Text weiterhin angezeigt.

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

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

Befehlsersetzung

Es ist möglicherweise praktischer, die Ausgabe von tput direkt in Ihre echo -Zeichenfolgen einzufügen, indem Sie Befehlsersetzung verwenden:

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

Beispiel

Der obige Befehl erzeugt dies unter Ubuntu:

Screenshot of colour terminal text


Befehle für Vordergrund- und Hintergrundfarbe

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

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 (setb anstelle von setab und setf anstelle von setaf), bei denen andere Zahlen verwendet werden, die hier nicht angegeben sind.

Befehle im Textmodus

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

Befehle zum Bewegen des Cursors

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

Mit Wackelfenster zusammenfassen bewirkt der Befehl bel, dass das Terminal eine Sekunde lang wackelt, um die Aufmerksamkeit des Benutzers auf sich zu ziehen.


Skripte

tput akzeptiert Skripte mit einem Befehl pro Zeile, die in der Reihenfolge ausgeführt werden, bevor tput beendet wird.

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

  • Siehe man 1 tput
  • Siehe man 5 terminfo für die vollständige Liste der Befehle und weitere Details zu diesen Optionen. (Der entsprechende Befehl tput ist in der Spalte _Cap-name_ der großen Tabelle aufgeführt, die in Zeile 81 beginnt.)
852
Drew Noakes

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 Escapezeichen in Bash , Hex und oktal jeweils:

|       | 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 ist eine Eingabeaufforderung)
  • PS4

sie sollten zusätzliche Escape-Zeichen hinzufügen, damit bash sie richtig interpretieren kann. Ohne das Hinzufügen zusätzlicher Escape-Zeichen funktioniert dies, es treten jedoch Probleme auf, wenn Sie Ctrl + r für die Suche in Ihrem Verlauf verwenden.

ausnahmeregel für Bash

Sie sollten \[ vor jedem Start von ANSI-Code und \] nach allen Endcodes 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\]

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

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

art der Farbfolge:

  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

Hiermit wird der Stil der Farbe NICHT des Texts geändert. Zum Beispiel die Farbe hell oder dunkler machen.

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

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

2. Textmodus

Dieser Modus dient zum Ändern des Stils von Text, NICHT von Farbe.

  • 3; kursiv
  • 4; unterstreichen
  • 5; blinkt (langsam)
  • 6; blinkt (schnell)
  • 7; rückwärts
  • 8; verstecken
  • 9; streichen

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

3. Vordergrundmodus

Dieser Modus dient zum Einfärben des Vordergrunds.

4. Hintergrundmodus

In diesem Modus wird der Hintergrund eingefärbt.

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[32m |         |       | yellow           | echo -e "\033[33m####\033[m" |                                      |
|         34 | \033[32m |         |       | blue             | echo -e "\033[34m####\033[m" |                                      |
|         35 | \033[32m |         |       | purple           | echo -e "\033[35m####\033[m" | real name: Magenta = reddish-purple  |
|         36 | \033[32m |         |       | cyan             | echo -e "\033[36m####\033[m" |                                      |
|         37 | \033[32m |         |       | 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-Color

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

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

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

einige Screenshots

vordergrund 8-Bit-Zusammenfassung in einem .gif

foreground.gif

hintergrund 8-Bit-Zusammenfassung in einem .gif

background.gif

farbzusammenfassung mit ihren Werten

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

blinking auf dem KDE-Terminal

KDE-blinking

Ein einfacher C Code, der Ihnen mehr zeigt

cecho_screenshot

ein erweitertes Tool, das ich entwickelt habe, um mit diesen Farben umzugehen:

bline


farbmodus-Aufnahme

fade-normal-bright

textmodus erschossen

only-text-mode

kombinieren ist in Ordnung

combine

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 erlebt in bash , c , c ++ , dPerl , 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 gcc kompilieren
einige Screenshots unter Win-7

Wie berechnet man die Länge des Codes?

\033[ = 2, andere Teile 1

Wo können wir diese Codes verwenden?

Überall dort, wo es einen tty Interpreter gibt
xterm, gnome-terminal, kde-terminal, mysql-client-CLI und so weiter.
Wenn Sie beispielsweise Ihre Ausgabe mit mysql einfärben möchten, können Sie Perl verwenden.

#!/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 setzen Sie die Datei in ein gültiges PATH und verwenden Sie sie dann an einer beliebigen Stelle.

ls | pcc
df | pcc

inside mysql erst registrieren für pager und dann versuchen:

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

pcc

Es behandelt NICHT Unicode.

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 mit system( "clear" ) löschen möchten, sodass Sie diesen Aufruf anstelle von system(3) verwenden können

Sind sie in Unicode verfügbar?

Ja. \u001b

Welche Version dieser Farben ist vorzuziehen?

Es ist einfach, 3/4-bit zu verwenden, aber es ist sehr genau und schön, 24-bit zu verwenden.
Wenn Sie keine Erfahrung mit html haben, finden Sie hier ein kurzes Tutorial:
24 Bits bedeuten: 00000000 und 00000000 und 00000000. Jedes 8-Bit ist für eine bestimmte Farbe.
1..8 ist für  und 9..16 für  und 17..24 für 
Also in html#FF0000 bedeutet  und hier ist es: 255;0;0
in html#00FF00 bedeutet  was hier ist: 0;255;0
Ist das sinnvoll? Welche Farbe Sie möchten, kombinieren 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

666
Shakiba Moshiri

Verwenden Sie tput mit der Funktion setaf und einem Parameter von 1.

echo "$(tput setaf 1)Hello, world$(tput sgr0)"
177
echo -e "\033[31m Hello World"

Der [31m steuert die Textfarbe:

  • 30-37 setzt Vordergrundfarbe
  • 40-47 legt die Hintergrundfarbe fest

Eine vollständigere Liste der Farbcodes hier zu finden .

Es wird empfohlen, die Textfarbe am Ende der Zeichenfolge auf \033[0m zurückzusetzen.

113
Neo

Dies ist der Farbschalter \033[. Siehe Geschichte .

Farbe Codes sind wie 1;32 (Hellgrün), 0;34 (Blau), 1;34 (Hellblau) usw.

Wir beenden Farbsequenzen mit einem Farbschalter \033[ und 0m, dem no - Farbcode. 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 farbe echo funktion lö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!"
31
Jorge Bucaran

Eine gute Möglichkeit, die Farbe nur für ein echo zu ändern, besteht darin, die folgende 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
29
Alireza Mirian

Ich habe gerade die guten Fänge in allen Lösungen zusammengefasst und endete mit:

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"
24
Andrew Naguib

Verwenden Sie tput, um Farbcodes zu berechnen. Vermeiden Sie die Verwendung des ANSI-Escape-Codes (z. B. \E[31;1m fü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"
22
Wilfred Hughes

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

Die erstmalige Verwendung von tput ist in modernen Umgebungen portabler als das manuelle Einfügen von ASCII Codes über echo -E

Hier ist eine schnelle Bash-Funktion:

 say() {
     echo "[email protected]" | sed \
             -e "s/\(\(@\(red\|green\|yellow\|blue\|Magenta\|cyan\|white\|reset\|b\|u\)\)\+\)[[]\{2\}\(.*\)[]]\{2\}/\1\[email protected]/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 @[email protected][[Success]] 

bekommen:

Bold-Green Success

Hinweise zur Portabilität von tput

Der Quellcode von tput(1) wurde zum ersten Mal im September 1986 hochgeladen

tput(1) war in den 1990er Jahren in der Semantik von X/Open curses verfügbar (1997 Standard hat die unten genannte Semantik).

Es ist also ( ziemlich ) allgegenwärtig.

19
Ahmed Masud

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

enter image description here

Hoffe, dass dies Bild dir hilft, deine Farbe für deine Bash auszuwählen: D

14
kyo

Diese Codes funktionieren auf meiner Ubuntu-Box:

enter image description here

echo -e "\x1B[31m foobar \x1B[0m"
echo -e "\x1B[32m foobar \x1B[0m"
echo -e "\x1B[96m foobar \x1B[0m"
echo -e "\x1B[01;96m foobar \x1B[0m"
echo -e "\x1B[01;95m foobar \x1B[0m"
echo -e "\x1B[01;94m foobar \x1B[0m"
echo -e "\x1B[01;93m foobar \x1B[0m"
echo -e "\x1B[01;91m foobar \x1B[0m"
echo -e "\x1B[01;90m foobar \x1B[0m"
echo -e "\x1B[01;89m foobar \x1B[0m"
echo -e "\x1B[01;36m foobar \x1B[0m"

Dies druckt die Buchstaben a b c d in verschiedenen Farben:

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

enter image description here

12
Eric Leschinski

Zur besseren Lesbarkeit

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

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

Meine bisherige Lieblingsantwort ist colouredEcho.

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

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

sie verwenden es genau wie grep, und es färbt sein Standardelement beispielsweise für jedes Argument mit einer anderen Farbe ein

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

xcol example

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 so

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

Niemand bemerkte die Nützlichkeit des ANSI-Code 7 invertierten Videos .

Es bleibt auf allen Terminal-Schemafarben, schwarzen oder weißen Hintergründen oder anderen ausgefallenen Paletten lesbar, indem Vordergrund- und Hintergrundfarben ausgetauscht werden.

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

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

So sieht es beim Ändern der integrierten Terminalschemata aus:

enter image description here

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

6
NVRM

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

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"
6
Mahn

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

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

Einer dieser Befehle ist tput. tput akzeptiert eine Reihe von Akronymen, die als Funktionsnamen bezeichnet werden, und gegebenenfalls Parameter, sucht dann in der terminfo-Datenbank nach den korrekten Escape-Sequenzen für das erkannte Terminal und druckt die korrekten Codes aus (das Terminal versteht hoffentlich).

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

Trotzdem habe ich eine kleine Hilfsbibliothek namens bash-tint geschrieben, die eine weitere Ebene über tput hinzufügt, wodurch die Verwendung noch einfacher wird (imho):

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

Würde folgendes Ergebnis ergeben: enter image description here

4
ArtBIT

Ich habe geschrieben Swag um genau das zu erreichen.

Sie können es einfach tun

pip install Swag

Jetzt können Sie alle Escape-Befehle als TXT-Dateien an ein bestimmtes Ziel installieren:

Swag install -d <colorsdir>

Oder noch einfacher über:

Swag install

Welches installiert die Farben zu ~/.colors.

Entweder benutzt du 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 an asciinema !

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

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

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

-Lila 0; 35 Hellviolett 1; 35

-Cyan 0; 36 Light Cyan 1; 36

-Hellgrau 0; 37 Weiß 1; 37

1

Hier ist eine Implementierung, die auf dem MacOS-Terminal funktioniert, um PS1 mit Farbe einzustellen und was nicht.

Es gibt zwei Implementierungen, von denen sich eine auf Echo und eine auf printf stützt, um Methoden dynamisch aufzurufen, ohne dass die Hölle losbricht.

Es ist nur ein Anfang, aber robust und lässt das Terminal nicht flackern. Unterstützt jetzt git branch, kann aber erweitert werden, um irgendwann eine Reihe von Dingen zu erledigen.

Hier finden Sie:

https://github.com/momomo/opensource/blob/master/momomo.com.Shell.style.sh

Sollte funktionieren, indem Sie einfach kopieren und einfügen. Keine Abhängigkeiten.

0
momomo

Hier ist ein einfaches, kleines Skript, das ich kürzlich zusammengestellt habe und das alle Pipeline-Eingaben koloriert, 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 

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

0
user4401178

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