Comment sortir du texte en couleur sur un terminal Linux ?

Vous devez générer des codes de couleur ANSI. Notez que tous les terminaux ne le prennent pas en charge ; si les séquences de couleurs ne sont pas prises en charge, des ordures apparaîtront.

Exemple :

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

Ici, \033 est le caractère ESC, ASCII 27. Il est suivi de [ , puis zéro ou plusieurs chiffres séparés par ; , et enfin la lettre m . Les nombres décrivent la couleur et le format vers lesquels basculer à partir de ce moment.

Les codes pour les couleurs de premier plan et d'arrière-plan sont :

         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

De plus, vous pouvez les utiliser :

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

Consultez le tableau sur Wikipedia pour d'autres codes moins largement pris en charge.

Pour déterminer si votre terminal prend en charge les séquences de couleurs, lisez la valeur du TERM variables d'environnement. Il doit spécifier le type de terminal particulier utilisé (par exemple, vt100 , gnome-terminal , xterm , screen , ...). Ensuite, recherchez-le dans la base de données terminfo; vérifier le colors capacité.

Avant de sortir une couleur dont vous avez besoin, assurez-vous que vous êtes dans un terminal :

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

Ensuite, vous devez vérifier la capacité du terminal s'il prend en charge la couleur

sur les systèmes avec terminfo (basé sur Linux) vous pouvez obtenir la quantité de couleurs prises en charge comme

Number_Of_colors_Supported=$(tput colors)

sur les systèmes avec termcap (basé sur BSD) vous pouvez obtenir la quantité de couleurs prises en charge comme

Number_Of_colors_Supported=$(tput Co)

Alors prenez votre décision :

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

BTW, n'utilisez pas la coloration comme cela a été suggéré auparavant avec les caractères ESC. Utilisez la capacité standard d'appel au terminal qui vous attribuera les couleurs CORRECTES prises en charge par le terminal particulier.

Basé sur BSD

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

Basé sur Linux

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

Utiliser comme

echo -e "${fg_red}  Red  ${fg_green} Bull ${reset}"

Bases

J'ai écrit une classe C++ qui peut être utilisée pour définir la couleur de premier plan et d'arrière-plan de la sortie. Cet exemple de programme sert d'exemple d'impression de This ->word<- is red. et le formater pour que la couleur de premier plan de word est rouge.

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

Origine

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

Avancé

Vous pouvez ajouter des fonctionnalités supplémentaires à la classe. Il est par exemple possible d'ajouter la couleur magenta et même des styles comme gras . Pour ce faire, il suffit d'ajouter une autre entrée au Code énumération. C'est une bonne référence.