Ik probeer een tekst in de terminal af te drukken met behulp van ECHO-opdracht.

Ik wil de tekst in een rode kleur afdrukken. Hoe kan ik dat doen?

Antwoord 1, Autoriteit 100%

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

Gebruik ze dan als dit in uw script:

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

die lovein rood afdrukken.

Van @ James-Lim’s commentaar, Als u de opdracht echogebruikt, moet u de vlag -e gebruiken om Backslash te laten ontsnappen .

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

(Voeg niet "\n"toe wanneer u echogebruikt, tenzij u een extra lege regel wilt toevoegen)

Antwoord 2, Autoriteit 41%

U kunt de Awesome tput-opdracht (gesuggereerd in ignacio’s antwoord ) om terminal te produceren Controlecodes voor allerlei dingen.

Gebruik

Specifieke tputSub-commando’s worden later besproken.

DIRECT

Bel tputaan als onderdeel van een reeks opdrachten:

tput setaf 1; echo "this is red text"

Gebruik ;in plaats van &&, dus als tputfouten bevat, wordt de tekst nog steeds weergegeven.

Shell-variabelen

Een andere optie is om shell-variabelen te gebruiken:

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

tputproduceert tekenreeksen die door de terminal worden geïnterpreteerd als een speciale betekenis. Ze worden zelf niet getoond. Merk op dat ze nog steeds kunnen worden opgeslagen in bestanden of verwerkt als invoer door andere programma’s dan de terminal.

Commandovervanging

Het kan handiger zijn om de uitvoer van tputrechtstreeks in uw echo-strings in te voegen met behulp van opdrachtvervanging:

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

Voorbeeld

Het bovenstaande commando produceert dit op Ubuntu:

Voorgrond & achtergrondkleuropdrachten

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

De kleuren zijn als volgt:

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

Er zijn ook niet-ANSI-versies van de kleurinstellingsfuncties (setbin plaats van setab, en setfin plaats van setaf) die verschillende nummers gebruiken, hier niet worden gegeven.

Tekstmodus-opdrachten

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

Cursor-bewegingsopdrachten

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

Wissen en invoegen opdrachten

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 opdrachten

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

Met Compiz Woobbly Windows , de belCommando maakt de terminal wobble voor een seconde om de aandacht van de gebruiker te tekenen.

Scripts

tputAccepteert scripts met één opdracht per regel, die in volgorde worden uitgevoerd vóór tputUITSITEITEN.

Vermijd tijdelijke bestanden door een multiline-string te echoeren en het te pijpen:

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

Zie ook

Zie man 1 tput
Zie man 5 terminfovoor de volledige lijst van commando’s en meer details over deze opties. (De bijbehorende tputOpdracht wordt vermeld in de Cap-nameKOLOM VAN DE ENORME TABEL DIE BEGINT OP LIJN 81.)

Antwoord 3, Autoriteit 40%

Enkele variabelen die u kunt gebruiken:

# 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

het escape-teken in respectievelijk bash, hexen 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 |
|       |       |        |         |                              |

KORTE VOORBEELD:

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

Als u deze codes in uw speciale bash-variabelen wilt gebruiken

ps0
PS1
PS2 (= dit is voor het aanrekenen)
ps4

U moet extra escape-tekens toevoegen, zodat bash kan ze correct interpreteren. Zonder dit extra escape-personages werkt het, maar u zult problemen ondervinden wanneer u Ctrl + rgebruikt voor het zoeken in uw geschiedenis.

Uitzonderingsregel voor bash

Je moet \[toevoegen vóór elke beginnende ANSI-code en \]toevoegen na elke eindigende.
Voorbeeld:
bij normaal gebruik: \033[32mThis is in green\033[0m
voor PS0/1/2/4: \[\033[32m\]This is in green\[\033[m\]

\[is voor het begin van een reeks van niet-afdrukbaretekens
\]is voor het einde van een reeks van niet-afdrukbaretekens

Tip: om het te onthouden kunt u eerst \[\]toevoegen en vervolgens uw ANSI-code ertussen plaatsen:

\[start-ANSI-code\]
\[end-ANSI-code\]

type kleurvolgorde:

3/4-bits
8-bits
24-bits

Voordat je in deze kleuren duikt, moet je 4 modi kennen met deze codes:

1. kleurmodus

Het past de kleurstijl aan, NIET de tekst. Maak de kleur bijvoorbeeld helderder of donkerder.

0reset
1;lichter dan normaal
2;donkerder dan normaal

Deze modus wordt niet breed ondersteund. Het wordt volledig ondersteund op Gnome-Terminal.

2. tekstmodus

Deze modus is voor het wijzigen van de tekststijl, NIET de kleur.

3;cursief
4;onderstrepen
5;knippert (langzaam)
6;knippert (snel)
7;omgekeerd
8;verbergen
9;doorhalen

en worden bijna ondersteund.
KDE-Konsole ondersteunt bijvoorbeeld 5;maar Gnome-Terminal niet en Gnome ondersteunt 8;maar KDE niet.

3. voorgrondmodus

Deze modus is voor het inkleuren van de voorgrond.

4. achtergrondmodus

Deze modus is voor het inkleuren van de achtergrond.

De onderstaande tabel toont een samenvatting van de 3/4 bitversie van ANSI-kleur

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

De onderstaande tabel toont een samenvatting van de 8-bits-versie van ANSI-kleur

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

De 8-bits snelle test:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done

De onderstaande tabel toont een samenvatting van de 24-bits-versie van ANSI-kleur

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

Sommige screen-shots

Voorgrond 8-bits samenvatting in een .gif

Achtergrond 8-bits samenvatting in een .gif

Kleuroverzicht met hun waarden

`blinking`op KDE-Terminal

een eenvoudige `C`-code die je meer laat zien

een meer geavanceerde tool die ik heb ontwikkeld om met deze kleuren om te gaan :

opname in kleurmodus

opname in tekstmodus

combineren is OK

meer foto’s

Tips en trucs voor gevorderde gebruikers en programmeurs:

Kunnen we deze codes in een programmeertaal gebruiken?

Ja, dat kan. Ik heb ervaren in bash, c, c++, d perl, python

Vertraagt ze de snelheid van een programma?

Ik denk, NEE.

Kunnen we deze op Windows gebruiken?

3/4-bit Ja, als u de code compileert met gcc
enkele screenshots op Win-7

Hoe bereken je de lengte van de code?

\033[= 2, andere delen 1

Waar kunnen we deze codes gebruiken?

Overal met een tty-interpreter
xterm, gnome-terminal, kde-terminal, mysql-client-CLIenzovoort.
Als u bijvoorbeeld uw uitvoer wilt inkleuren met mysql, kunt u Perl

gebruiken

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

bewaar deze code in een bestandsnaam: pcc(= Perl Colorize Character) en plaats het bestand a in geldig PATHen gebruik het dan waar je maar wilt.

ls | pcc
df | pcc

in mysqlregistreer het eerst voor pageren probeer dan:

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

Het behandelt NIETUnicode.

Gaan deze codes alleen inkleuren?

Nee, ze kunnen veel interessante dingen doen. Probeer:

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

of:

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

Er zijn veel beginners die het scherm willen wissen met system( "clear" )zodat je dit kunt gebruiken in plaats van system(3)call

Zijn ze beschikbaar in Unicode?

Ja. \u001b

Welke versie van deze kleuren heeft de voorkeur?

Het is gemakkelijk om 3/4-bitte gebruiken, maar het is veel nauwkeuriger en mooier om 24-bitte gebruiken.
Als je geen ervaring hebt met htmldus hier is een korte tutorial:
24 bits betekent: 00000000en 00000000en 00000000. Elke 8-bit is voor een specifieke kleur.
1..8is voor en 9..16voor en 17..24voor
Dus in html#FF0000betekent en hier is het : 255;0;0
in html#00FF00betekent wat hier is: 0;255;0
Slaat dat ergens op? welke kleur je wilt combineren met deze drie 8-bits waarden.

referentie:
Wikipedia
ANSI-escape-reeksen
tldp.org
tldp.org
misc.flogisoft.com
sommige blogs/webpagina’s die ik me niet herinner

Antwoord 4, autoriteit 8%

Gebruik tputmet de setaf-mogelijkheid en een parameter van 1.

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

Antwoord 5, autoriteit 6%

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

De [31mregelt de tekstkleur:

30–37zet voorgrondkleur
40–47stelt achtergrondkleur in

Een meer volledige lijst met kleurcodes vindt u hier.

Het is een goede gewoonte om de tekstkleur terug te zetten naar \033[0maan het einde van de tekenreeks.

Antwoord 6, autoriteit 2%

Ik heb zojuist de goede vangsten in alle oplossingen samengevoegd en eindigde met:

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

En je kunt het gewoon noemen als:

cecho "RED" "Helloworld"

Antwoord 7

Dit is de kleurschakelaar\033[. Zie geschiedenis.

Kleur codeszijn als 1;32(Lichtgroen), 0;34(Blauw), 1;34(Lichtblauw), enz.

We beëindigen kleurreeksen met een kleurwissel \033[en 0m, de no-kleurcode. Net als het openen en sluiten van tabbladen in een opmaaktaal.

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

Eenvoudige kleur echofunctie-oplossing:

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

Antwoord 8

Mijn riff op het antwoord van Tobias:

# Color
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
NC='\033[0m' # No Color
function red {
    printf "${RED}$@${NC}\n"
}
function green {
    printf "${GREEN}$@${NC}\n"
}
function yellow {
    printf "${YELLOW}$@${NC}\n"
}

Antwoord 9

Een handige manier om van kleur te veranderen voor slechts één echois om een dergelijke functie te definiëren:

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

Gebruik:

coloredEcho "This text is green" green

Of je kunt direct de kleurcodes gebruiken die worden genoemd in Drew’s antwoord:

coloredEcho "This text is green" 2

Antwoord 10

Gebruik tputom kleurcodes te berekenen. Vermijd het gebruik van de ANSI-escape-code (bijv. \E[31;1mvoor rood) omdat deze minder draagbaar is. Bash op OS X ondersteunt het bijvoorbeeld niet.

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"

Antwoord 11

Ik vond Shakiba Moshiri‘s geweldige antwoord terwijl ik informatie over dat onderwerp zocht… toen had ik een idee … en het eindigde in een heel mooie functie die extreem gemakkelijk te gebruiken is 😁
Dus ik moet het delen 😉

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

Gebruik:$(c <flags>)in een echo -eof 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 │
 └───────┴─────────────────┴──────────┘

voorbeelden:

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

Antwoord 12

Deze vraag is steeds opnieuw beantwoord 🙂 Maar waarom niet.

Veel gebruik van tputis meer draagbaar in moderne omgevingen dan handmatig injecteren van ASCII-codes via echo -E

Hier is een snelle bash-functie:

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

Nu kunt u het volgende gebruiken:

say @b@green[[Success]]

te verkrijgen:

Opmerkingen over de overdraagbaarheid van `tput`

De eerste keer dat de broncode van tput(1)werd geüpload in september 1986

tput(1)was in de jaren 90 beschikbaar in X/Open curses-semantiek (1997-standaard heeft de hieronder vermelde semantiek).

Dus, het is (vrij) alomtegenwoordig.

Antwoord 13

Als je zshof bash

gebruikt

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'

Online proberen

Antwoord 14

Met dank aan @k-fivevoor dit antwoord

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

Resultaat

Ik hoop dat dit beeld help je om je kleur te kiezen voor je bash: D

Antwoord 15

We kunnen 24 bits RGB True Colors gebruiken voor zowel tekst als achtergrond!

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

Voorbeeld Rode tekst en sluitingstag:

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

generator:

Antwoord 16

I in plaats van harde codering escape-codes die specifiek zijn voor uw huidige terminal, moet u tput.

Dit is mijn favoriete demo-script:

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

Antwoord 17

Deze codes werken op mijn Ubuntu-vak:

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"

Dit drukt de letters a b c d allemaal in verschillende kleuren:

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

voor lus:

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

Antwoord 18

voor leesbaarheid

Als je de leesbaarheidvan de code wilt verbeteren, kun je eerst de tekenreeks echogebruiken en later de kleur toevoegen met sed:

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

Antwoord 19

Mijn favoriete antwoord tot nu toe is colouredEcho.

Om nog een optie te posten, kun je deze kleine tool xcol bekijken

https://ownyourbits.com/2017/01 /23/kleur je-stdout-met-xcol/

je gebruikt het net als grep, en het kleurt zijn stdin bijvoorbeeld voor elk argument in met een andere kleur

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

Merk op dat het elke reguliere expressie accepteert die sed accepteert.

Deze tool gebruikt de volgende definities

#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

Ik gebruik deze variabelen in mijn scripts zoals de

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

Antwoord 20

Om het berichtuitvoer te tonen met verschillende kleur die u kunt maken:

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

-black 0; 30 donkergrijs 1; 30

-D 0; 31 lichtrood 1; 31

-Groen 0; 32 Lichtgroen 1; 32

-Brouw / oranje 0; 33 Geel 1; 33

-Blue 0; 34 lichtblauw 1; 34

-Purple 0; 35 Lichtpaars 1; 35

-cyan 0; 36 lichtcyaan 1; 36

-Light grijs 0; 37 wit 1; 37

Antwoord 21

Ik gebruik dit voor kleur afdrukken

#!/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 basiskleuren zijn ingesteld als vars en er zijn ook enkele handige functies: XY, line en que. Bron dit script in een van de jouwe en gebruik alle kleurenvariaties en -functies.

Antwoord 22

Om dit antwoorduit te breiden, voor de luie onder ons:

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"

Antwoord 23

Je moet zeker tput gebruiken in plaats van onbewerkte ANSI-controlesequenties.

Omdat er een groot aantal verschillende terminalbesturingen zijn
talen, heeft een systeem meestal een tussenliggende communicatielaag.
De echte codes worden opgezocht in een database voor de momenteel gedetecteerde
terminal type en je geeft gestandaardiseerde verzoeken aan een API of (van
de shell) naar een commando.

Een van deze commando’s is tput. tputaccepteert een set acroniemen genaamd
mogelijkheidsnamen en eventuele parameters, indien van toepassing, zoekt dan de
correcte ontsnappingsreeksen voor de gedetecteerde terminal in de terminfo
database en drukt de juiste codes af (hopelijk de terminal
begrijpt).

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

Dat gezegd hebbende, heb ik een kleine helperbibliotheek geschreven met de naam bash-tint, die een nieuwe laag toevoegt bovenop tput, waardoor het nog eenvoudiger te gebruiken is (imho):

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

Zou het volgende resultaat geven:

Antwoord 24

Je kunt kleuren en tekstmodus “gecombineerd”.

#!/bin/bash
echo red text / black background \(Reverse\)
echo "\033[31;7mHello world\e[0m";
echo -e "\033[31;7mHello world\e[0m";
echo
echo yellow text / red background
echo "\033[32;41mHello world\e[0m";
echo -e "\033[32;41mHello world\e[0m";
echo "\033[0;32;41mHello world\e[0m";
echo -e "\033[0;32;41mHello world\e[0m";
echo
echo yellow BOLD text / red background
echo "\033[1;32;41mHello world\e[0m";
echo -e "\033[1;32;41mHello world\e[0m";
echo
echo yellow BOLD text underline / red background
echo "\033[1;4;32;41mHello world\e[0m";
echo -e "\033[1;4;32;41mHello world\e[0m";
echo "\033[1;32;4;41mHello world\e[0m";
echo -e "\033[1;32;4;41mHello world\e[0m";
echo "\033[4;32;41;1mHello world\e[0m";
echo -e "\033[4;32;41;1mHello world\e[0m";
echo

Antwoord 25

En dit wat ik altijd zag, alle combinaties en besloot welke cool is:

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

Antwoord 26

Ik heb swaggeschreven om precies dat te bereiken.

Je kunt het gewoon doen

pip install swag

Je kunt nu alle escape-commando’s als txt-bestanden naar een bepaalde bestemming installeren via:

swag install -d <colorsdir>

Of nog makkelijker via:

swag install

Hiermee worden de kleuren geïnstalleerd in ~/.colors.

Ofwel gebruik je ze als volgt:

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

Of op deze manier, wat ik eigenlijk interessanter vind:

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

Bekijk het op asciinema!

Antwoord 27

Geïnspireerd door het antwoord van @nachoparker, heb ik dit in mijn .bashrc:

#### colours
source xcol.sh
### tput foreground
export tpfn=$'\e[0m' # normal
export tpfb=$(tput bold)
## normal colours
export tpf0=$(tput setaf 0) # black
export tpf1=$(tput setaf 1) # red
export tpf2=$(tput setaf 2) # green
export tpf3=$(tput setaf 3) # yellow
export tpf4=$(tput setaf 4) # blue
export tpf5=$(tput setaf 5) # magenta
export tpf6=$(tput setaf 6) # cyan
export tpf7=$(tput setaf 7) # white
# echo "${tpf0}black ${tpf1}red ${tpf2}green ${tpf3}yellow ${tpf4}blue ${tpf5}magenta ${tpf6}cyan ${tpf7}white${tpfn}"
## bold colours
export tpf0b="$tpfb$tpf0" # bold black
export tpf1b="$tpfb$tpf1" # bold red
export tpf2b="$tpfb$tpf2" # bold green
export tpf3b="$tpfb$tpf3" # bold yellow
export tpf4b="$tpfb$tpf4" # bold blue
export tpf5b="$tpfb$tpf5" # bold magenta
export tpf6b="$tpfb$tpf6" # bold cyan
export tpf7b="$tpfb$tpf7" # bold white
# echo "${tpf0b}black ${tpf1b}red ${tpf2b}green ${tpf3b}yellow ${tpf4b}blue ${tpf5b}magenta ${tpf6b}cyan ${tpf7b}white${tpfn}"

De exportstelt mij in staat om die tpf..in bash-scripts.

Antwoord 28

Hier is een eenvoudig script om de tekststijl in Bash Shell Promt eenvoudig te beheren:

https://github.com/ferromauro/bash-palette

Importeer de code met:

source bash-palette.sh

Gebruik de geïmporteerde variabele in ECHO-opdracht (gebruik de optie -e!):

echo -e ${PALETTE_GREEN}Color Green${PALETTE_RESET}

Het is mogelijk om meer elementen te combineren:

echo -e ${PALETTE_GREEN}${PALETTE_BLINK}${PALETTE_RED_U}Green Blinking Text over Red Background${PALETTE_RESET}

Antwoord 29

emoji

Eén ding dat u kunt doen die niet in het antwoord wordt vermeld, is om emoji’s te gebruiken om uw uitvoer te kleuren!

echo 📕: error message
echo 📙: warning message
echo 📗: ok status message
echo 📘: action message
echo 📔: Or anything you like and want to recognize immediately by color
echo 💩: Or with a specific emoji

🎁 Bonus Toegevoegde waarde

Deze methode is erg handig, vooral wanneer uw broneditor voor het script het weergeven van Unicode ondersteunt. Dan kun je het kleurrijke script ook zien voordat je het uitvoert en direct in de bron! :

_{Afbeelding van een scriptbestand in de VSCode}

Opmerking: mogelijk moet je de Unicode van de emoji rechtstreeks doorgeven:

echo $'\U0001f972'  // this emoji: 🥲

_{Let op de hoofdletter Uvoor Unicode-tekens >= 10000}

Ookkomt zelden voor, maar het kan zijn dat u de code als volgt moet doorgeven:

echo <0001f972>

Met dank aan @joanis van reacties voor het vermelden hiervan

Antwoord 30

Hier is de eenvoudigste en meest leesbare oplossing.
Met bashj (https://sourceforge.net/projects/bashj/), zou je gewoon kiezen een van deze regels:

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

256x256x256kleuren zijn beschikbaar als u over kleurondersteuning beschikt in uw terminaltoepassing.

Hoe de uitgangskleur van ECHO in Linux