c++ मैं लिनक्स टर्मिनल में रंगीन पाठ कैसे आउटपुट करूं?




linux colors (10)

मैं रंगीन वर्णों को एक लिनक्स टर्मिनल में कैसे प्रिंट करूं जो इसका समर्थन करता है?

मैं कैसे बता सकता हूं कि टर्मिनल रंग कोड का समर्थन करता है या नहीं?

मैं इस कार्यक्रम के लिए सी ++ का उपयोग कर रहा हूँ।


मेरी समझ से, एक सामान्य एएनएसआई रंग कोड

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

से बना है (नाम और कोडेक)

  • फॉर्मेट अटूट

    { "Default", "0" },
    { "Bold", "1" },
    { "Dim", "2" },
    { "Underlined", "3" },
    { "Blink", "5" },
    { "Reverse", "7" },
    { "Hidden", "8" }
    
  • रंगीन रंग

    { "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" }
    
  • पीछे का रंग

    { "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" }
    
  • पाठ

  • रीसेट फॉर्मेट एट्रिब्यूट

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

इस जानकारी के साथ, एक स्ट्रिंग को रंगना आसान है "मैं केले हूं!" इस तरह के भूमिगत रंग "पीला" और पृष्ठभूमि रंग "हरा" के साथ

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

या एक सी ++ लाइब्रेरी colorize

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

यहां फॉर्मेट अटूट के साथ अधिक उदाहरण


यदि आपका टर्मिनल इसका समर्थन करता है तो आप बचने के दृश्यों का उपयोग कर सकते हैं। उदाहरण के लिए:

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

जैसा कि अन्य ने कहा है, आप बचने के पात्रों का उपयोग कर सकते हैं। इसे आसान बनाने के लिए आप मेरे शीर्षलेख का उपयोग कर सकते हैं:

#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_ */

शीर्षलेख के मैक्रोज़ का उपयोग करने वाला एक उदाहरण हो सकता है:

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


किसी भी रंग को आउटपुट करने से पहले आपको यह सुनिश्चित करना होगा कि आप टर्मिनल में हैं:

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

फिर यदि आप रंग का समर्थन करते हैं तो आपको टर्मिनल क्षमता की जांच करनी होगी

terminfo (लिनक्स आधारित) वाले सिस्टम पर आप समर्थित रंगों की मात्रा प्राप्त कर सकते हैं

Number_Of_colors_Supported=$(tput colors)

termcap (बीएसडी आधारित) वाले सिस्टम पर आप समर्थित रंगों की मात्रा प्राप्त कर सकते हैं

Number_Of_colors_Supported=$(tput Co)

फिर आपको निर्णय लेते हैं:

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

बीटीडब्लू, रंग का उपयोग न करें क्योंकि इसे ईएससी पात्रों के साथ पहले सुझाव दिया गया था। टर्मिनल क्षमता के लिए मानक कॉल का उपयोग करें जो आपको सही रंग असाइन करेगा जो विशेष टर्मिनल समर्थन।

बीएसडी आधारित
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}"

सबसे अच्छा तरीका ncurses लाइब्रेरी का उपयोग करना है - हालांकि यह एक अखरोट को तोड़ने के लिए एक स्लेजगेमर हो सकता है यदि आप बस एक साधारण रंगीन स्ट्रिंग आउटपुट करना चाहते हैं


मैं निम्नलिखित समाधान का उपयोग करता हूं, यह काफी सरल और सुरुचिपूर्ण है, आसानी से स्रोत में चिपकाया जा सकता है, और लिनक्स / बैश पर काम करता है:

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;

आपको एएनएसआई रंग कोड आउटपुट करने की आवश्यकता है। ध्यान दें कि सभी टर्मिनल इसका समर्थन नहीं करते हैं; अगर रंग अनुक्रम समर्थित नहीं हैं, तो कचरा दिखाई देगा।

उदाहरण:

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

यहां, \033 ईएससी चरित्र, ASCII 27 है। इसके बाद [ , फिर शून्य या अधिक संख्याएं अलग होती हैं ; , और अंत में पत्र m । संख्याएं उस बिंदु से आगे स्विच करने के लिए रंग और प्रारूप का वर्णन करती हैं।

अग्रभूमि और पृष्ठभूमि रंगों के लिए कोड हैं:

         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

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

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

अन्य, कम व्यापक रूप से समर्थित कोड के लिए विकिपीडिया पर तालिका देखें।

संपादित करें: यह निर्धारित करने के लिए कि आपका टर्मिनल रंग अनुक्रमों का समर्थन करता है, TERM पर्यावरण चर के मान को पढ़ें। इसे निर्दिष्ट विशेष टर्मिनल प्रकार निर्दिष्ट करना चाहिए (उदाहरण के लिए vt100 , gnome-terminal , xterm , screen , ...)। फिर टर्मिनो डेटाबेस में इसे देखें ; colors क्षमता की जांच करें।


मूल बातें

मैंने एक सी ++ कक्षा लिखी है जिसे आउटपुट के अग्रभूमि और पृष्ठभूमि रंग को सेट करने के लिए उपयोग किया जा सकता है। यह नमूना कार्यक्रम प्रिंटिंग का एक उदाहरण के रूप में कार्य करता है This ->word<- is red. और इसे स्वरूपित करना ताकि word का अग्रभूमि रंग लाल हो।

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

स्रोत

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

उन्नत

आप कक्षा में अतिरिक्त सुविधाएं जोड़ना चाह सकते हैं। उदाहरण के लिए, रंग मैजेंटा और बोल्डफेस जैसी शैलियों को भी जोड़ना संभव है। ऐसा करने के लिए, Code गणना में बस एक और प्रविष्टि। This एक अच्छा संदर्भ है।


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

इन कार्यों का उपयोग करें।

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

यह एक पुराना विषय है, लेकिन मैंने सरल सी मैक्रोज़ द्वारा परिभाषित रंगों के लिए नेस्टेड सबक्लास और स्थिर सदस्यों के साथ एक कक्षा लिखी है।

मुझे इस पोस्ट से color फ़ंक्शन में रंगीन पाठ सी प्रोग्रामिंग में dreamincode.net में उपयोगकर्ता no2pencil द्वारा मिला है।

मैंने इसे इस तरह बनाया है ताकि std :: cout स्ट्रीम में स्थिर स्थिरांक का उपयोग करने में सक्षम हो:

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

कक्षा और एक परीक्षण कार्यक्रम स्रोत कोड here डाउनलोड किया जा सकता here

cc::console कंसोल डिफ़ॉल्ट रंगों और विशेषताओं को रीसेट कर देगा, cc::underline टेक्स्ट को रेखांकित करेगी, जो पट्टी पर काम करती है जिसे मैंने परीक्षण कार्यक्रम का परीक्षण किया है।

रंग की:

black
blue
red
magenta
green
cyan
yellow
white

lightblack
lightblue
lightred
lightmagenta
lightgreen
lightcyan
lightyellow
lightwhite

जिसका उपयोग cc स्थैतिक वर्ग के fore और back स्थिर सबक्लास दोनों के साथ किया जा सकता है।

2017 संपादित करें

मैं बस अधिक व्यावहारिक होने के लिए यहां कक्षा कोड जोड़ रहा हूं।

रंग कोड मैक्रोज़:

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

और मुख्य रंग फ़ंक्शन जो स्क्रीन पर रंग या विशेषता को परिभाषित करता है:

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




terminal