it-swarm.com.de

Wie gebe ich farbigen Text auf einem Linux-Terminal aus?

Wie drucke ich farbige Zeichen auf ein Linux-Terminal, das dies unterstützt?

Wie kann ich feststellen, ob das Terminal Farbcodes unterstützt?

271
Macha

Sie müssen ANSI-Farbcodes ausgeben . Beachten Sie, dass dies nicht von allen Terminals unterstützt wird. Wenn Farbsequenzen nicht unterstützt werden, wird Müll angezeigt.

Beispiel:

 cout << "\033[1;31mbold red text\033[0m\n";

Hier ist \033 Das ESC-Zeichen, ASCII 27. Es folgt [, Dann null oder mehr durch ; Getrennte Zahlen. und schließlich der Buchstabe m. Die Zahlen beschreiben die Farbe und das Format, zu dem von diesem Punkt an gewechselt werden soll.

Die Codes für Vorder- und Hintergrundfarben sind:

         foreground background
black        30         40
red          31         41
green        32         42
yellow       33         43
blue         34         44
Magenta      35         45
cyan         36         46
white        37         47

Zusätzlich können Sie diese verwenden:

reset             0  (everything back to normal)
bold/bright       1  (often a brighter shade of the same colour)
underline         4
inverse           7  (swap foreground and background colours)
bold/bright off  21
underline off    24
inverse off      27

In der Tabelle auf Wikipedia finden Sie weitere, weniger häufig unterstützte Codes.


Lesen Sie den Wert der Umgebungsvariablen TERM, um festzustellen, ob Ihr Terminal Farbsequenzen unterstützt. Es sollte den speziellen verwendeten Terminaltyp angeben (z. B. vt100, gnome-terminal, xterm, screen, ...). Dann schauen Sie in der terminfo-Datenbank nach ; Überprüfen Sie die Funktion colors.

356
Thomas

Grundlagen

Ich habe eine C++ - Klasse geschrieben, mit der die Vordergrund- und Hintergrundfarbe der Ausgabe festgelegt werden kann. Dieses Beispielprogramm dient als Beispiel für das Drucken von This ->Word<- is red. und formatieren Sie es so, dass die Vordergrundfarbe von Word rot ist.

#include "colormod.h" // namespace Color
#include <iostream>
using namespace std;
int main() {
    Color::Modifier red(Color::FG_RED);
    Color::Modifier def(Color::FG_DEFAULT);
    cout << "This ->" << red << "Word" << def << "<- is red." << endl;
}

Quelle

#include <ostream>
namespace Color {
    enum Code {
        FG_RED      = 31,
        FG_GREEN    = 32,
        FG_BLUE     = 34,
        FG_DEFAULT  = 39,
        BG_RED      = 41,
        BG_GREEN    = 42,
        BG_BLUE     = 44,
        BG_DEFAULT  = 49
    };
    class Modifier {
        Code code;
    public:
        Modifier(Code pCode) : code(pCode) {}
        friend std::ostream&
        operator<<(std::ostream& os, const Modifier& mod) {
            return os << "\033[" << mod.code << "m";
        }
    };
}

Fortgeschritten

Möglicherweise möchten Sie der Klasse zusätzliche Funktionen hinzufügen. Es ist zum Beispiel möglich, die Farbe Magenta und sogar Stile wie Fettdruck hinzuzufügen. Dazu nur ein weiterer Eintrag in der Aufzählung Code. This ist eine gute Referenz.

91
Joel Sjögren

Bevor Sie eine Farbe ausgeben, vergewissern Sie sich, dass Sie sich in einem Terminal befinden:

[ -t 1 ] && echo 'Yes I am in a terminal'  # isatty(3) call in C

Dann müssen Sie überprüfen, ob das Terminal die Farbe unterstützt

auf Systemen mit terminfo(Linux-basiert) können Sie die Anzahl der unterstützten Farben als erhalten

Number_Of_colors_Supported=$(tput colors)

auf Systemen mit termcap(BSD-basiert) erhalten Sie die Anzahl der unterstützten Farben als

Number_Of_colors_Supported=$(tput Co)

Dann treffen Sie Ihre Entscheidung:

[ ${Number_Of_colors_Supported} -ge 8 ] && {
    echo 'You are fine and can print colors'
} || {
    echo 'Terminal does not support color'
}

Übrigens, verwenden Sie keine Farben, wie sie zuvor für ESC-Zeichen vorgeschlagen wurden. Verwenden Sie die Standardfunktion zum Anrufen von Terminals, mit der Sie RICHTIGE Farben für die jeweilige Terminalunterstützung erhalten.

fg_black="$(tput AF 0)"
fg_red="$(tput AF 1)"
fg_green="$(tput AF 2)"
fg_yellow="$(tput AF 3)"
fg_blue="$(tput AF 4)"
fg_Magenta="$(tput AF 5)"
fg_cyan="$(tput AF 6)"
fg_white="$(tput AF 7)"
reset="$(tput me)"
fg_black="$(tput setaf 0)"
fg_red="$(tput setaf 1)"
fg_green="$(tput setaf 2)"
fg_yellow="$(tput setaf 3)"
fg_blue="$(tput setaf 4)"
fg_Magenta="$(tput setaf 5)"
fg_cyan="$(tput setaf 6)"
fg_white="$(tput setaf 7)"
reset="$(tput sgr0)"
echo -e "${fg_red}  Red  ${fg_green} Bull ${reset}"
41
Alex

Wie bereits erwähnt, können Sie Escape-Zeichen verwenden. Sie können mein Header verwenden, um es einfacher zu machen:

#ifndef _COLORS_
#define _COLORS_

/* FOREGROUND */
#define RST  "\x1B[0m"
#define KRED  "\x1B[31m"
#define KGRN  "\x1B[32m"
#define KYEL  "\x1B[33m"
#define KBLU  "\x1B[34m"
#define KMAG  "\x1B[35m"
#define KCYN  "\x1B[36m"
#define KWHT  "\x1B[37m"

#define FRED(x) KRED x RST
#define FGRN(x) KGRN x RST
#define FYEL(x) KYEL x RST
#define FBLU(x) KBLU x RST
#define FMAG(x) KMAG x RST
#define FCYN(x) KCYN x RST
#define FWHT(x) KWHT x RST

#define BOLD(x) "\x1B[1m" x RST
#define UNDL(x) "\x1B[4m" x RST

#endif  /* _COLORS_ */

Ein Beispiel für die Verwendung der Makros des Headers könnte sein:

#include <iostream>
#include "colors.h"
using namespace std;

int main()
{
    cout << FBLU("I'm blue.") << endl;
    cout << BOLD(FBLU("I'm blue-bold.")) << endl;
    return 0;
}

enter image description here

32
gon1332

Ich benutze die folgende Lösung, sie ist recht einfach und elegant, kann problemlos in den Quellcode eingefügt werden und funktioniert unter Linux/Bash:

const std::string red("\033[0;31m");
const std::string green("\033[1;32m");
const std::string yellow("\033[1;33m");
const std::string cyan("\033[0;36m");
const std::string Magenta("\033[0;35m");
const std::string reset("\033[0m");

std::cout << "Measured runtime: " << yellow << timer.count() << reset << std::endl;
15
Daniel Langr

Dies ist ein altes Thema, aber ich habe eine Klasse mit verschachtelten Unterklassen und statischen Elementen für Farben geschrieben, die von einfachen C-Makros definiert werden.

Ich habe die Funktion color von diesem Beitrag erhalten Farbtext in C-Programmierung in dreamincode.net vom Benutzer no2pencil.

Ich habe es so gemacht, um die statischen Konstanten in std :: cout stream wie folgt verwenden zu können:

cout << zkr::cc::fore::red << "This is red text. " 
     << zkr::cc::console << "And changing to console default colors, fg, bg."
     << endl;

Die Klasse und ein Testprogramm-Quellcode können heruntergeladen werden hier .

cc::console wird auf die Standardfarben und -attribute der Konsole zurückgesetzt, cc::underline unterstreicht den Text, der auf PuTTY funktioniert, auf dem ich das Testprogramm getestet habe.

Farben:

black
blue
red
Magenta
green
cyan
yellow
white

lightblack
lightblue
lightred
lightmagenta
lightgreen
lightcyan
lightyellow
lightwhite

Kann mit den statischen Unterklassen fore und back der statischen Klasse cc verwendet werden.

EDIT 2017

Ich füge hier nur den Klassencode hinzu, um es praktischer zu machen.

Die Farbcode-Makros:

#define CC_CONSOLE_COLOR_DEFAULT "\033[0m"
#define CC_FORECOLOR(C) "\033[" #C "m"
#define CC_BACKCOLOR(C) "\033[" #C "m"
#define CC_ATTR(A) "\033[" #A "m"

und die Hauptfarbfunktion, die eine Farbe oder ein Attribut für den Bildschirm definiert:

char *cc::color(int attr, int fg, int bg)
{
    static char command[13];

    /* Command is the control command to the terminal */
    sprintf(command, "%c[%d;%d;%dm", 0x1B, attr, fg + 30, bg + 40);
    return command;
}

ccolor.h

#include <stdio.h>

#define CC_CONSOLE_COLOR_DEFAULT "\033[0m"
#define CC_FORECOLOR(C) "\033[" #C "m"
#define CC_BACKCOLOR(C) "\033[" #C "m"
#define CC_ATTR(A) "\033[" #A "m"

namespace zkr
{
    class cc
    {
    public:

        class fore
        {
        public:
            static const char *black;
            static const char *blue;
            static const char *red;
            static const char *Magenta;
            static const char *green;
            static const char *cyan;
            static const char *yellow;
            static const char *white;
            static const char *console;

            static const char *lightblack;
            static const char *lightblue;
            static const char *lightred;
            static const char *lightmagenta;
            static const char *lightgreen;
            static const char *lightcyan;
            static const char *lightyellow;
            static const char *lightwhite;
        };

        class back
        {
        public:
            static const char *black;
            static const char *blue;
            static const char *red;
            static const char *Magenta;
            static const char *green;
            static const char *cyan;
            static const char *yellow;
            static const char *white;
            static const char *console;

            static const char *lightblack;
            static const char *lightblue;
            static const char *lightred;
            static const char *lightmagenta;
            static const char *lightgreen;
            static const char *lightcyan;
            static const char *lightyellow;
            static const char *lightwhite;
        };

        static char *color(int attr, int fg, int bg);
        static const char *console;
        static const char *underline;
        static const char *bold;
    };
}

ccolor.cpp

#include "ccolor.h"

using namespace std;

namespace zkr
{
    enum Color
    {
        Black,
        Red,
        Green,
        Yellow,
        Blue,
        Magenta,
        Cyan,
        White,
        Default = 9
    };

    enum Attributes
    {
        Reset,
        Bright,
        Dim,
        Underline,
        Blink,
        Reverse,
        Hidden
    };

    char *cc::color(int attr, int fg, int bg)
    {
        static char command[13];
        /* Command is the control command to the terminal */
        sprintf(command, "%c[%d;%d;%dm", 0x1B, attr, fg + 30, bg + 40);
        return command;
    }

    const char *cc::console = CC_CONSOLE_COLOR_DEFAULT;
    const char *cc::underline = CC_ATTR(4);
    const char *cc::bold = CC_ATTR(1);

    const char *cc::fore::black = CC_FORECOLOR(30);
    const char *cc::fore::blue = CC_FORECOLOR(34);
    const char *cc::fore::red = CC_FORECOLOR(31);
    const char *cc::fore::Magenta = CC_FORECOLOR(35);
    const char *cc::fore::green = CC_FORECOLOR(92);
    const char *cc::fore::cyan = CC_FORECOLOR(36);
    const char *cc::fore::yellow = CC_FORECOLOR(33);
    const char *cc::fore::white = CC_FORECOLOR(37);
    const char *cc::fore::console = CC_FORECOLOR(39);

    const char *cc::fore::lightblack = CC_FORECOLOR(90);
    const char *cc::fore::lightblue = CC_FORECOLOR(94);
    const char *cc::fore::lightred = CC_FORECOLOR(91);
    const char *cc::fore::lightmagenta = CC_FORECOLOR(95);
    const char *cc::fore::lightgreen = CC_FORECOLOR(92);
    const char *cc::fore::lightcyan = CC_FORECOLOR(96);
    const char *cc::fore::lightyellow = CC_FORECOLOR(93);
    const char *cc::fore::lightwhite = CC_FORECOLOR(97);

    const char *cc::back::black = CC_BACKCOLOR(40);
    const char *cc::back::blue = CC_BACKCOLOR(44);
    const char *cc::back::red = CC_BACKCOLOR(41);
    const char *cc::back::Magenta = CC_BACKCOLOR(45);
    const char *cc::back::green = CC_BACKCOLOR(42);
    const char *cc::back::cyan = CC_BACKCOLOR(46);
    const char *cc::back::yellow = CC_BACKCOLOR(43);
    const char *cc::back::white = CC_BACKCOLOR(47);
    const char *cc::back::console = CC_BACKCOLOR(49);

    const char *cc::back::lightblack = CC_BACKCOLOR(100);
    const char *cc::back::lightblue = CC_BACKCOLOR(104);
    const char *cc::back::lightred = CC_BACKCOLOR(101);
    const char *cc::back::lightmagenta = CC_BACKCOLOR(105);
    const char *cc::back::lightgreen = CC_BACKCOLOR(102);
    const char *cc::back::lightcyan = CC_BACKCOLOR(106);
    const char *cc::back::lightyellow = CC_BACKCOLOR(103);
    const char *cc::back::lightwhite = CC_BACKCOLOR(107);
}
12
Christos Lytras

Nach meinem Verständnis ein typischer ANSI-Farbcode

"\033[{FORMAT_ATTRIBUTE};{FORGROUND_COLOR};{BACKGROUND_COLOR}m{TEXT}\033[{RESET_FORMATE_ATTRIBUTE}m"

besteht aus (Name und Codec)

  • FORMAT ATTRIBUTE

    { "Default", "0" },
    { "Bold", "1" },
    { "Dim", "2" },
    { "Underlined", "3" },
    { "Blink", "5" },
    { "Reverse", "7" },
    { "Hidden", "8" }
    
  • FORGROUND FARBE

    { "Default", "39" },
    { "Black", "30" },
    { "Red", "31" },
    { "Green", "32" },
    { "Yellow", "33" },
    { "Blue", "34" },
    { "Magenta", "35" },
    { "Cyan", "36" },
    { "Light Gray", "37" },
    { "Dark Gray", "90" },
    { "Light Red", "91" },
    { "Light Green", "92" },
    { "Light Yellow", "93" },
    { "Light Blue", "94" },
    { "Light Magenta", "95" },
    { "Light Cyan", "96" },
    { "White", "97" }
    
  • HINTERGRUNDFARBE

    { "Default", "49" },
    { "Black", "40" },
    { "Red", "41" },
    { "Green", "42" },
    { "Yellow", "43" },
    { "Blue", "44" },
    { "Megenta", "45" },
    { "Cyan", "46" },
    { "Light Gray", "47" },
    { "Dark Gray", "100" },
    { "Light Red", "101" },
    { "Light Green", "102" },
    { "Light Yellow", "103" },
    { "Light Blue", "104" },
    { "Light Magenta", "105" },
    { "Light Cyan", "106" },
    { "White", "107" }
    
  • TEXT

  • RESET FORMAT ATTRIBUTE

    { "All", "0" },
    { "Bold", "21" },
    { "Dim", "22" },
    { "Underlined", "24" },
    { "Blink", "25" },
    { "Reverse", "27" },
    { "Hidden", "28" }
    

Mit diesen Informationen ist es einfach, eine Zeichenfolge "Ich bin eine Banane!" Einzufärben. mit der Vordergrundfarbe "Gelb" und der Hintergrundfarbe "Grün" wie folgt

"\033[0;33;42mI am a Banana!\033[0m"

Oder mit einer C++ - Bibliothek colorize

auto const& colorized_text = color::rize( "I am a banana!", "Yellow", "Green" );
std::cout << colorized_text << std::endl;

Weitere Beispiele mit FORMAT ATTRIBUTE hier enter image description here

11
Feng Wang

Sie können Escape-Sequenzen verwenden, wenn Ihr Terminal dies unterstützt. Zum Beispiel:

echo \[\033[32m\]Hello, \[\033[36m\]colourful \[\033[33mworld!\033[0m\]
9
Vlad

Eine erweiterte Version des Headers von gon1332:

//
//  COLORS.h
//
//  Posted by Gon1332 May 15 2015 on StackOverflow
//  https://stackoverflow.com/questions/2616906/how-do-i-output-coloured-text-to-a-linux-terminal#2616912
//
//  Description: An easy header file to make colored text output to terminal second nature.
//  Modified by Shades Aug. 14 2018

// PLEASE carefully read comments before using this tool, this will save you a lot of bugs that are going to be just about impossible to find.
#ifndef COLORS_h
#define COLORS_h

/* FOREGROUND */
// These codes set the actual text to the specified color
#define RESETTEXT  "\x1B[0m" // Set all colors back to normal.
#define FOREBLK  "\x1B[30m" // Black
#define FORERED  "\x1B[31m" // Red
#define FOREGRN  "\x1B[32m" // Green
#define FOREYEL  "\x1B[33m" // Yellow
#define FOREBLU  "\x1B[34m" // Blue
#define FOREMAG  "\x1B[35m" // Magenta
#define FORECYN  "\x1B[36m" // Cyan
#define FOREWHT  "\x1B[37m" // White

/* BACKGROUND */
// These codes set the background color behind the text.
#define BACKBLK "\x1B[40m"
#define BACKRED "\x1B[41m"
#define BACKGRN "\x1B[42m"
#define BACKYEL "\x1B[43m"
#define BACKBLU "\x1B[44m"
#define BACKMAG "\x1B[45m"
#define BACKCYN "\x1B[46m"
#define BACKWHT "\x1B[47m"

// These will set the text color and then set it back to normal afterwards.
#define BLK(x) FOREBLK x RESETTEXT
#define RED(x) FORERED x RESETTEXT
#define GRN(x) FOREGRN x RESETTEXT
#define YEL(x) FOREYEL x RESETTEXT
#define BLU(x) FOREBLU x RESETTEXT
#define MAG(x) FOREMAG x RESETTEXT
#define CYN(x) FORECYN x RESETTEXT
#define WHT(x) FOREWHT x RESETTEXT

// Example usage: cout << BLU("This text's color is now blue!") << endl;

// These will set the text's background color then reset it back.
#define BackBLK(x) BACKBLK x RESETTEXT
#define BackRED(x) BACKRED x RESETTEXT
#define BackGRN(x) BACKGRN x RESETTEXT
#define BackYEL(x) BACKYEL x RESETTEXT
#define BackBLU(x) BACKBLU x RESETTEXT
#define BackMAG(x) BACKMAG x RESETTEXT
#define BackCYN(x) BACKCYN x RESETTEXT
#define BackWHT(x) BACKWHT x RESETTEXT

// Example usage: cout << BACKRED(FOREBLU("I am blue text on a red background!")) << endl;

// These functions will set the background to the specified color indefinitely.
// NOTE: These do NOT call RESETTEXT afterwards. Thus, they will set the background color indefinitely until the user executes cout << RESETTEXT
// OR if a function is used that calles RESETTEXT i.e. cout << RED("Hello World!") will reset the background color since it calls RESETTEXT.
// To set text COLOR indefinitely, see SetFore functions below.
#define SetBackBLK BACKBLK
#define SetBackRED BACKRED
#define SetBackGRN BACKGRN
#define SetBackYEL BACKYEL
#define SetBackBLU BACKBLU
#define SetBackMAG BACKMAG
#define SetBackCYN BACKCYN
#define SetBackWHT BACKWHT

// Example usage: cout << SetBackRED << "This text's background and all text after it will be red until RESETTEXT is called in some way" << endl;

// These functions will set the text color until RESETTEXT is called. (See above comments)
#define SetForeBLK FOREBLK
#define SetForeRED FORERED
#define SetForeGRN FOREGRN
#define SetForeYEL FOREYEL
#define SetForeBLU FOREBLU
#define SetForeMAG FOREMAG
#define SetForeCYN FORECYN
#define SetForeWHT FOREWHT

// Example usage: cout << SetForeRED << "This text and all text after it will be red until RESETTEXT is called in some way" << endl;

#define BOLD(x) "\x1B[1m" x RESETTEXT // Embolden text then reset it.
#define BRIGHT(x) "\x1B[1m" x RESETTEXT // Brighten text then reset it. (Same as bold but is available for program clarity)
#define UNDL(x) "\x1B[4m" x RESETTEXT // Underline text then reset it.

// Example usage: cout << BOLD(BLU("I am bold blue text!")) << endl;

// These functions will embolden or underline text indefinitely until RESETTEXT is called in some way.

#define SetBOLD "\x1B[1m" // Embolden text indefinitely.
#define SetBRIGHT "\x1B[1m" // Brighten text indefinitely. (Same as bold but is available for program clarity)
#define SetUNDL "\x1B[4m" // Underline text indefinitely.

// Example usage: cout << setBOLD << "I and all text after me will be BOLD/Bright until RESETTEXT is called in some way!" << endl;

#endif /* COLORS_h */

Wie Sie sehen, verfügt es über weitere Funktionen, z. B. die Möglichkeit, die Hintergrundfarbe vorübergehend und auf unbestimmte Zeit festzulegen, sowie weitere Funktionen. Ich glaube auch, dass es ein bisschen anfängerfreundlicher und einfacher ist, sich alle Funktionen zu merken.

#include <iostream>
#include "COLORS.h"

int main() {
  std::cout << SetBackBLU << SetForeRED << endl;
  std::cout << "I am red text on a blue background! :) " << endl;
  return 0;
}

Fügen Sie einfach die Header-Datei in Ihr Projekt ein und schon können Sie mit der farbigen Terminal-Ausgabe loslegen.

5
Shades

Sie können ANSI-Farbcodes verwenden.

benutze diese Funktionen.

enum c_color{BLACK=30,RED=31,GREEN=32,YELLOW=33,BLUE=34,Magenta=35,CYAN=36,WHITE=37};
enum c_decoration{NORMAL=0,BOLD=1,FAINT=2,ITALIC=3,UNDERLINE=4,RIVERCED=26,FRAMED=51};
void pr(const string str,c_color color,c_decoration decoration=c_decoration::NORMAL){
  cout<<"\033["<<decoration<<";"<<color<<"m"<<str<<"\033[0m";
}

void prl(const string str,c_color color,c_decoration decoration=c_decoration::NORMAL){
   cout<<"\033["<<decoration<<";"<<color<<"m"<<str<<"\033[0m"<<endl;
}
3
Shanaka Rusith

probieren Sie meinen Header hier aus, um schnell und einfach Text einzufärben: Aedi's Color Header


Escape-Sequence-Color-Header

Färben Sie Ihre Ausgabe in Unix mit C++!


Textattributoptionen:

ATTRIBUTES_OFF, BOLD, UNDERSCORE, BLINK, REVERSE_VIDEO, CONCEALED


Farboptionen:

BLACK, RED, GREEN, YELLOW, BLUE, Magenta, CYAN, WHITE


Format:

Allgemeines Format, geben Sie den gewünschten Wert in $ variable $ ein

COLOR_$Foreground_Color$_$Background_Color$
COLOR_$Text_Attribute$_$Foreground_Color$_$Background_Color$
COLOR_NORMAL  // To set color to default

z.B.

COLOR_BLUE_BLACK // Leave Text Attribute Blank if no Text Attribute appied
COLOR_UNDERSCORE_YELLOW_RED
COLOR_NORMAL


Verwendungszweck:

Verwenden Sie einfach, um die gewünschte Farbe vor der Textausgabe zu streamen, und verwenden Sie erneut, um die Farbe nach der Textausgabe auf Normal einzustellen.

cout << COLOR_BLUE_BLACK << "TEXT" << COLOR_NORMAL << endl;
cout << COLOR_BOLD_YELLOW_CYAN << "TEXT" << COLOR_NORMAL << endl;
3
Uduse

Der beste Weg ist, die ncurses-Bibliothek zu verwenden - obwohl dies ein Vorschlaghammer sein kann, um eine Nuss zu knacken, wenn Sie nur eine einfache farbige Zeichenfolge ausgeben möchten

2
Nick

unter OSX Shell funktioniert dies für mich (einschließlich 2 Leerzeichen vor "rotem Text"):

$ printf "\e[033;31m  red text\n"
$ echo "$(tput setaf 1)  red text"
2
BananaAcid