Note

il se peut que vous ne puissiez pas colorer le cmd prompt de Window , mais il devrait fonctionner dans de nombreux terminaux unix (ou de type unix).

aussi, notez que certains terminaux ne supportent tout simplement pas certaines (si elles existent) séquences d'échappement ANSI et, surtout, les couleurs 24 bits.

Utilisation

veuillez vous référer à la section malédictions au bas pour la meilleure solution. Pour un personnel de ou solution facile (bien que et non comme solution de plateforme), se référer à la section séquences D'échappement ANSI .

---

TL; DR

• java : System.out.println((char)27 + "[31m" + "ERROR MESSAGE IN RED");

• python : print(chr(27) + "[31m" + "ERROR MESSAGE IN RED")

• bash ou zsh : printf '\x1b[31mERROR MESSAGE IN RED'
  • cela peut aussi fonctionner pour Os X: printf '\e[31mERROR MESSAGE IN RED'
• sh : printf ' CTRL + V , CTRL + [ [31mERROR MESSAGE IN RED'
  • c'est à dire, appuyez sur CTRL+V et ensuite CTRL+ [ afin d'obtenir un "raw" ESC caractère lorsque l'interprétation de l'évasion n'est pas disponible
  • Si fait correctement, vous devriez voir un ^[ . Bien qu'il ressemble à deux caractères, il est vraiment juste un, le ESC caractère.
  • vous pouvez aussi appuyer sur CTRL + V , CTRL + [ dans vim dans l'un des langages de programmation ou d'écriture parce que qui utilise un littéral ESC caractère
  • Aussi, vous pouvez remplacer Ctrl + [ avec ESC ... par exemple, vous pouvez utiliser CTRL + V , ESC , mais je trouve le premier plus facile, puisque je presse déjà CTRL et puisque [ est moins hors du chemin.

---

des Séquences d'Échappement ANSI

arrière-plan sur les Séquences d'Échappement

bien que ce ne soit pas la meilleure façon de le faire, la façon la plus facile de le faire dans une programmation ou un script la langue est d'utiliser séquences d'évasion . De ce lien:

Une séquence d'échappement est une série de caractères utilisée pour modifier l'état des ordinateurs et de leurs périphériques connectés. Ces séquences sont également connues sous le nom de séquences de contrôle, ce qui reflète leur utilisation dans le contrôle des appareils.

Backgound sur des Séquences d'Échappement ANSI

cependant, il obtient encore plus facile que dans les terminaux de texte vidéo, car ces terminaux utilisent "ANSI escape sequences . De ce lien:

ANSI escape sequences sont une norme pour la signalisation en bande pour contrôler l'emplacement du curseur, la couleur, et d'autres options sur les terminaux de texte vidéo. Certaines séquences d'octets, la plupart commençant par Esc et ' [ ' , sont intégrées dans le texte, que le terminal recherche et interprète comme des commandes, pas des codes de caractères.

comment utiliser les séquences D'échappement ANSI

en général

• les séquences D'échappement commencent par un caractère d'échappement; pour les séquences d'échappement ANSI, la séquence commence toujours par ESC (ASCII: 27 / hex: 0x1B ).
• pour une liste de ce que vous pouvez faire, reportez-vous au ANSI Escape La séquence de la Liste sur Wikipédia

Dans Les Langues De Programmation

certains langages de programmation (comme Java) n'interprètent pas \e ou \x1b comme le caractère ESC . Cependant, nous savons que le caractère ASCII 27 est le caractère ESC , de sorte que nous pouvons simplement dactylographier 27 à un char et utiliser que pour commencer la séquence d'échappement.

voici quelques façons de le faire dans les langages de programmation communs:

• Java

  • System.out.println((char)27 + "[33mYELLOW");

• Python 3

  • print(chr(27) + "[34mBLUE");
  • print("\x1b[35mMAGENTA");
    • notez que \x1b est interprété correctement en python

• Node Js

  • , La suite PAS sortie de la couleur dans le code JavaScript dans la Console Web
  • console.log(String.fromCharCode(27) + "[36mCYAN");
  • console.log("\x1b[30;47mBLACK_ON_WHITE");
    • notez que \x1b fonctionne aussi dans le noeud

Dans l'Invite du Shell Scripts OU

si vous travaillez avec bash ou zsh , il est assez facile de colorer la sortie (dans la plupart des terminaux). Sous Linux, Os X, et dans certains terminaux Windows, vous pouvez vérifier si votre terminal prend en charge la couleur en faisant les deux ce qui suit:

• printf '\e[31mRED'
• printf '\x1b[31mRED'

si vous voyez la couleur pour les deux, alors c'est génial! Si vous voyez une couleur pour un seul, puis utiliser cette séquence. Si vous ne voyez pas de couleur pour l'un ou l'autre d'entre eux, alors vérifiez deux fois pour s'assurer que vous avez tapé tout correctement et que vous êtes en bash ou zsh; si vous ne voyez toujours pas de couleur, alors votre terminal ne supporte probablement pas ANSI escape séquence.

si je me souviens bien, les terminaux linux ont tendance à prendre en charge à la fois les séquences d'échappement \e et \x1b , alors que les terminaux os x ne prennent en charge que \e , mais je me trompe peut-être. Néanmoins, si vous voyez quelque chose comme l'image suivante, alors vous êtes prêt! (Notez que j'utilise le shell, zsh , et qu'il colore ma chaîne prompt; aussi, j'utilise urxvt comme terminal sous linux.)

"Comment cela fonctionne?" pourriez-vous demander. Bascially, printf est interpretting la séquence de caractères qui suit (tout à l'intérieur de la simples guillemets ). Lorsque printf rencontre \e ou \x1b , il convertira ces caractères au caractère ESC (ASCII: 27). C'est exactement ce que nous voulons. Maintenant, printf envoie ESC 31m , et puisqu'il y a un ESC suivi d'une séquence d'évasion ANSI valide, nous devrions obtenir la sortie colorée (tant qu'elle est supportée par le terminal).

vous pouvez également utiliser echo -e '\e[32mGREEN' (par exemple), pour la sortie de couleur. Notez que le drapeau -e pour echo " [permet] l'interprétation des échappées de revers" et doit être utilisé si vous voulez echo pour interpréter correctement la séquence d'évasion.

---

Plus sur des Séquences d'Échappement ANSI

ANSI séquences d'évasion peut faire plus que juste la sortie de couleur, mais nous allons commencer par cela, et voir exactement comment la couleur fonctionne; ensuite, nous verrons comment manipuler le curseur; enfin, nous allons jeter un oeil et voir comment utiliser la couleur 8 bits et aussi 24 bits (bien qu'il a seulement fragile de soutien).

sur Wikipedia , ils font référence à ESC [ comme CSI , donc je vais faire la même chose.

Couleur

pour colorer la sortie en utilisant des échappées ANSI, utilisez ce qui suit:

• CSI n m
  • CSI : le personnage de l'évasion- ^[[ ou ESC [
  • n : un numéro un des suivants:
    • 30 - 37 , 39 : premier plan 15191930920"
    • 40 - 47 , 49 : historique
  • m : un littéral ASCII m -met fin à la séquence d'échappement

je vais utiliser bash ou zsh pour démontrer toutes les combinaisons de couleurs possibles. Plop les suivantes en bash ou zsh pour voir par vous-même (Vous devrez peut-être remplacer \e avec \x1b ):

• for fg in {30..37} 39; do for bg in {40..47} 49; do printf "\e[${fg};${bg}m~TEST~"; done; printf "\n"; done;

résultat:

rapide Référence (Couleur)

+~~~~~~+~~~~~~+~~~~~~~~~~~+
|  fg  |  bg  |  color    |
+~~~~~~+~~~~~~+~~~~~~~~~~~+
|  30  |  40  |  black    |
|  31  |  41  |  red      |
|  32  |  42  |  green    |
|  33  |  43  |  yellow   |
|  34  |  44  |  blue     |
|  35  |  45  |  magenta  |
|  36  |  46  |  cyan     |
|  37  |  47  |  white    |
|  39  |  49  |  default  |
+~~~~~~+~~~~~~+~~~~~~~~~~~+

Sélectionnez Graphique du Rendu (SGR)

SGR vous permet juste de changer le texte. Bon nombre d'entre eux ne fonctionnent pas dans certains terminaux, alors utilisez-les avec parcimonie dans les projets au niveau de la production. Cependant, ils peuvent être utiles pour rendre la sortie de programme plus lisible ou vous aider à distinguer entre différents types de sortie.

la couleur tombe en fait sous SGR, donc la syntaxe est la même:

• CSI n m
  • CSI : caractère de fuite - ^[[ ou ESC [
  • n : un numéro un des suivants:
    • 0 : réinitialiser
    • 1 - 9 : tourne sur divers effets de texte
    • 21 - 29 : éteint divers effets de texte (moins supporté que 1 - 9 )
    • 30 - 37 , 39 : couleur au premier plan
    • 40 - 47 , 49 : couleur de fond
    • 38 : 8 ou 24 bits couleur de premier plan (voir la section 8/24-bit Couleur ci-dessous)
    • 48 : 8 ou 24 bits couleur de fond (voir 8/24-couleur bit ci-dessous)
  • m : un littéral ASCII m -met fin à la séquence d'échappement

Même s'il n'est ténue de soutien pour les faibles (2), italique (3), souligné (4), clignotant (5,6), inverse vidéo (7), dissimuler (8), et barré (9), certains (mais rarement tous) ont tendance à fonctionner sur linux et os x terminal.

il est également intéressant de noter que vous pouvez séparer l'un des attributs ci-dessus avec un point-virgule. Par exemple printf '\e[34;47;1;3mCRAZY TEXT\n' affiche CRAZY TEXT avec un blue foreground sur un white background , et il sera bold et italic .

par exemple:

Plop le suivant dans votre shell bash ou zsh pour voir tout des effets de texte que vous pouvez faire. (Vous devrez peut-être remplacer \e par \x1b .)

• for i in {1..9}; do printf "\e[${i}m~TEST~\e[0m "; done

résultat:

vous pouvez voir que mon terminal supporte tous les effets de texte sauf pour faible (2), dissimuler (8) et croix (9).

de Référence Rapide (SGR Attributs de 0 à 9)

+~~~~~+~~~~~~~~~~~~~~~~~~+
|  n  |  effect          |
+~~~~~+~~~~~~~~~~~~~~~~~~+
|  0  |  reset           |
|  1  |  bold            |
|  2  |  faint*          |
|  3  |  italic**        |
|  4  |  underline       |
|  5  |  slow blink      |
|  6  |  rapid blink*    |
|  7  |  inverse         |
|  8  |  conceal*        |
|  9  |  strikethrough*  |
+~~~~~+~~~~~~~~~~~~~~~~~~+

* not widely supported
** not widely supported and sometimes treated as inverse

8-bit

alors que la plupart des terminaux supportent cela, il est moins supporté que les couleurs 0-7 , 9 .

syntaxe:

• CSI 38;5; n m
  • CSI : caractère de fuite - ^[[ ou ESC [
  • 38;5; : chaîne littérale qui dénote l'utilisation de couleurs 8 bits pour le premier plan
  • n : un numéro un des suivants:
    • 0 - 255

si vous voulez prévisualiser toutes les couleurs de votre terminal d'une manière agréable, j'ai un beau script sur gist.github.com .

il ressemble à ceci:

si vous voulez changer le fond en utilisant des couleurs 8 bits, il suffit de remplacer le 38 par un 48 :

• CSI 48;5; n m
  • CSI : caractère de fuite - ^[[ ou ESC [
  • 48;5; : chaîne littérale qui dénote l'utilisation de couleurs 8 bits pour le fond
  • n : un numéro un des suivants:
    • 0 - 255

couleur 24 bits

aussi connu sous le nom de true color, 24-bit color fournit certaines fonctionnalités vraiment cool. Le soutien pour cela est certainement en croissance (pour autant que je sache , il fonctionne dans la plupart des terminaux modernes à l'exception de urxvt , mon terminal [insert angry emoji]).

la couleur à 24 bits est réellement prise en charge dans vim (voir le vim wiki pour voir comment activer les couleurs 24 bits). Il est vraiment soigné parce qu'il tire du colorscheme défini pour gvim; par exemple, il utilise le fg/bg de highlight guibg=#______ guifg=#______ pour les couleurs de 24 bits! Neato, hein?

Voici comment fonctionne la couleur 24 bits:

• CSI 38;2; r ; g ; b m
  • CSI : caractère de fuite - ^[[ ou ESC [
  • 38;2; : chaîne littérale qui dénote l'utilisation de couleurs 24 bits pour le premier plan
  • r , g , b : les nombres-chacun doit être 0 - 255

pour tester juste quelques parmi les nombreux couleurs que vous pouvez avoir ( (2^8)^3 ou 2^24 ou 16777216 possibilités, je pense), vous pouvez utiliser cela en bash ou zsh:

• for r in 0 127 255; do for g in 0 127 255; do for b in 0 127 255; do printf "\e[38;2;${r};${g};${b}m($r,$g,$b)\e[0m "; done; printf "\n"; done; done;

résultat (c'est dans gnome-terminal depuis urxvt ne supporte pas la couleur 24 bits ... ressaisis-toi, responsable urxvt ... pour de vrai):

si vous voulez des couleurs 24 bits pour le fond ... vous l'avez deviné! Vous remplacez simplement 38 par 48 :

• CSI 48;2; r ; g ; b m
  • CSI : caractère d'échappement - ^[[ ou ESC [
  • 48;2; : chaîne littérale qui dénote l'utilisation de couleurs de 24 bits pour le fond
  • r , g , b : les nombres-chacun doit être 0 - 255

Insertion Premières Séquences D'Échappement

parfois \e et \x1b ne fonctionnera pas. Par exemple, dans le sh shell, parfois ni l'un ni l'autre ne fonctionne (bien qu'il le fasse sur mon système maintenant , Je ne pense pas qu'il l'a utilisé).

Pour contourner cela, vous pouvez utiliser le bouton CTRL + V , CTRL + [ ou CTRL V , ESC

ce sera insérer un caractère" raw " ESC (ASCII: 27). Il ressemblera à ce ^[ , mais ne vous inquiétez pas, c'est seulement un caractère-pas deux.

par exemple:

---

malédictions

reportez-vous à la Malédictions (Bibliothèque de Programmation) de la page pour une référence complète sur les malédictions. Il est à noter que curses ne fonctionne que sur les systèmes d'exploitation unix et de type unix.

et en cours d'Exécution avec des Malédictions

Je ne vais pas entrer dans trop de détails, car les moteurs de recherche peuvent révéler des liens vers des sites Web qui peuvent expliquer cela beaucoup mieux que je ne peux, Mais je vais en discuter brièvement ici et donner un exemple.

Pourquoi utiliser des Malédictions sur les évasions D'ANSI?

Si vous lisez le texte ci-dessus, vous pouvez vous rappeler que \e ou \x1b travaillent parfois avec printf . Eh bien, parfois, \e et \x1b ne fonctionne pas du tout (ce n'est pas standard et je n'ai jamais travaillé avec un terminal comme ça, mais c'est possible). Plus important encore, les séquences d'évasion plus complexes (pensez Home et autres clés à plusieurs caractères) sont difficiles à supporter pour chaque terminal (à moins que vous ne soyez prêt à passer beaucoup de temps et d'effort à analyser terminfo et termcap et et de comprendre comment gérer tous les terminaux).

malédiction résout ce problème. Fondamentalement, il est capable de comprendre les capacités d'un terminal, en utilisant ces méthodes (comme décrit par l'article wikipedia lié ci-dessus):

la plupart des implémentations de malédictions utilisent une base de données qui peut décrire les capacités de milliers de terminaux différents. Il y a quelques implémentations, comme les PDCurses, qui utilisent des dispositifs spécialisés les pilotes plutôt qu'une base de données de terminal. La plupart des implémentations utilisent terminfo; certaines utilisent termcap. Les malédictions ont l'avantage de la portabilité arrière aux terminaux de type cellule-caractère et de la simplicité. Pour une application qui ne nécessite pas de graphiques à mappage de bits ou de polices multiples, une implémentation d'interface utilisant curses sera généralement beaucoup plus simple et plus rapide qu'une implémentation utilisant un X toolkit.

la plupart du temps, les malédictions sonderont terminfo et seront alors en mesure de comprendre comment manipuler les attributs du curseur et du texte. Ensuite, vous, le programmeur, utilisez L'API fournie par curses pour manipuler le curseur ou changer la couleur du texte ou d'autres attributs si la fonctionnalité que vous recherchez est désirée.

exemple avec Python

je trouve que python est vraiment facile à utiliser, mais si vous voulez utiliser des malédictions dans un autre langage de programmation, alors il suffit de le rechercher sur duckduckgo ou tout autre moteur de recherche. :) Voici un exemple rapide en python 3:

import curses

def main(stdscr):
    # allow curses to use default foreground/background (39/49)
    curses.use_default_colors()

    # Clear screen
    stdscr.clear()

    curses.init_pair(1, curses.COLOR_RED, -1)
    curses.init_pair(2, curses.COLOR_GREEN, -1)
    stdscr.addstr("ERROR: I like tacos, but I don't have any.\n", curses.color_pair(1))
    stdscr.addstr("SUCCESS: I found some tacos.\n", curses.color_pair(2))

    stdscr.refresh() # make sure screen is refreshed
    stdscr.getkey()  # wait for user to press key

if __name__ == '__main__':
    curses.wrapper(main)

résultat:

vous pourriez penser à vous - même que c'est une façon beaucoup plus ronde de faire les choses, mais c'est vraiment beaucoup plus cross-plate-forme (vraiment cross-terminal ... au moins dans le monde unix - et unix-comme-plate-forme). Pour les couleurs, ce n'est pas tout à fait comme important, mais quand il vient à l'appui d'autres séquences d'évasion multi-séquence (comme accueil , fin , Page Up , Page Down , etc), puis les malédictions devient d'autant plus important.

exemple avec débit

• tput est un utilitaire de ligne de commande pour manipuler le curseur et le texte
• tput est livré avec le Paquet curses . Si vous voulez utiliser des applications Cross-terminal (ish) dans le terminal, vous devez utiliser tput, car il analyse terminfo ou tout ce dont il a besoin et utilise un ensemble de commandes standardisées (comme malédictions) et renvoie la séquence d'échappement correcte.
• exemple:

echo "$(tput setaf 1)$(tput bold)ERROR:$(tput sgr0)$(tput setaf 1) My tacos have gone missing"
echo "$(tput setaf 2)$(tput bold)SUCCESS:$(tput sgr0)$(tput setaf 2) Oh good\! I found my tacos\!"

résultat:

Plus D'Information sur le produit 15191660920"

• voir: http://linuxcommand.org/lc3_adv_tput.php pour voir comment fonctionne tput
• voir: http://invisible-island.net/ncurses/man/terminfo.5.html pour une liste de commandes que vous pouvez utiliser""

cela a fonctionné pour moi:

System.out.println((char)27 + "[31mThis text would show up red" + (char)27 + "[0m");

Vous avez besoin de la fin "[37m" pour revenir à la couleur blanche (ou ce que vous utilisez). Si vous ne le faites pas, tout ce qui suit pourrait devenir "rouge".

vous pouvez utiliser la bibliothèque JANSI pour rendre les séquences d'échappement ANSI dans Windows.

Oui c'est 100% possible

set classpath= % classpath%; d:\jansi-1.4.jar;

essayez ce code ci-dessous:

import org.fusesource.jansi.AnsiConsole;
import static org.fusesource.jansi.Ansi.*;
import static org.fusesource.jansi.Ansi.Color.*;

public class Sample

{

  public static void main(String[] args)
  {
    AnsiConsole.systemInstall();

    System.out.println(ansi().fg(RED).a("Hello World").reset());
    System.out.println("My Name is Raman");

    AnsiConsole.systemUninstall();
  }
}

Voici une solution pour Win32 Console.

1) Obtenez JavaNativeAccess libraries ici: https://github.com/twall/jna /

2) Ces deux classes Java feront l'affaire.

de Profiter de.

package com.stackoverflow.util;

import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Platform;
import com.sun.jna.Structure;

public class Win32 {
    public static final int STD_INPUT_HANDLE = -10;
    public static final int STD_OUTPUT_HANDLE = -11;
    public static final int STD_ERROR_HANDLE = -12;

    public static final short CONSOLE_FOREGROUND_COLOR_BLACK        = 0x00;
    public static final short CONSOLE_FOREGROUND_COLOR_BLUE         = 0x01;
    public static final short CONSOLE_FOREGROUND_COLOR_GREEN        = 0x02;
    public static final short CONSOLE_FOREGROUND_COLOR_AQUA         = 0x03;
    public static final short CONSOLE_FOREGROUND_COLOR_RED          = 0x04;
    public static final short CONSOLE_FOREGROUND_COLOR_PURPLE       = 0x05;
    public static final short CONSOLE_FOREGROUND_COLOR_YELLOW       = 0x06;
    public static final short CONSOLE_FOREGROUND_COLOR_WHITE        = 0x07;
    public static final short CONSOLE_FOREGROUND_COLOR_GRAY         = 0x08;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_BLUE   = 0x09;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_GREEN  = 0x0A;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_AQUA   = 0x0B;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_RED    = 0x0C;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_PURPLE = 0x0D;
    public static final short CONSOLE_FOREGROUND_COLOR_LIGHT_YELLOW = 0x0E;
    public static final short CONSOLE_FOREGROUND_COLOR_BRIGHT_WHITE = 0x0F;

    public static final short CONSOLE_BACKGROUND_COLOR_BLACK        = 0x00;
    public static final short CONSOLE_BACKGROUND_COLOR_BLUE         = 0x10;
    public static final short CONSOLE_BACKGROUND_COLOR_GREEN        = 0x20;
    public static final short CONSOLE_BACKGROUND_COLOR_AQUA         = 0x30;
    public static final short CONSOLE_BACKGROUND_COLOR_RED          = 0x40;
    public static final short CONSOLE_BACKGROUND_COLOR_PURPLE       = 0x50;
    public static final short CONSOLE_BACKGROUND_COLOR_YELLOW       = 0x60;
    public static final short CONSOLE_BACKGROUND_COLOR_WHITE        = 0x70;
    public static final short CONSOLE_BACKGROUND_COLOR_GRAY         = 0x80;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_BLUE   = 0x90;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_GREEN  = 0xA0;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_AQUA   = 0xB0;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_RED    = 0xC0;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_PURPLE = 0xD0;
    public static final short CONSOLE_BACKGROUND_COLOR_LIGHT_YELLOW = 0xE0;
    public static final short CONSOLE_BACKGROUND_COLOR_BRIGHT_WHITE = 0xF0;

    // typedef struct _COORD {
    //    SHORT X;
    //    SHORT Y;
    //  } COORD, *PCOORD;
    public static class COORD extends Structure {
        public short X;
        public short Y;
    }

    // typedef struct _SMALL_RECT {
    //    SHORT Left;
    //    SHORT Top;
    //    SHORT Right;
    //    SHORT Bottom;
    //  } SMALL_RECT;
    public static class SMALL_RECT extends Structure {
        public short Left;
        public short Top;
        public short Right;
        public short Bottom;
    }

    // typedef struct _CONSOLE_SCREEN_BUFFER_INFO {
    //    COORD      dwSize;
    //    COORD      dwCursorPosition;
    //    WORD       wAttributes;
    //    SMALL_RECT srWindow;
    //    COORD      dwMaximumWindowSize;
    //  } CONSOLE_SCREEN_BUFFER_INFO;
    public static class CONSOLE_SCREEN_BUFFER_INFO extends Structure {
        public COORD dwSize;
        public COORD dwCursorPosition;
        public short wAttributes;
        public SMALL_RECT srWindow;
        public COORD dwMaximumWindowSize;
    }

    // Source: https://github.com/twall/jna/nonav/javadoc/index.html
    public interface Kernel32 extends Library {
        Kernel32 DLL = (Kernel32) Native.loadLibrary("kernel32", Kernel32.class);

        // HANDLE WINAPI GetStdHandle(
        //        __in  DWORD nStdHandle
        //      );
        public int GetStdHandle(
                int nStdHandle);

        // BOOL WINAPI SetConsoleTextAttribute(
        //        __in  HANDLE hConsoleOutput,
        //        __in  WORD wAttributes
        //      );
        public boolean SetConsoleTextAttribute(
                int in_hConsoleOutput, 
                short in_wAttributes);

        // BOOL WINAPI GetConsoleScreenBufferInfo(
        //        __in   HANDLE hConsoleOutput,
        //        __out  PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
        //      );
        public boolean GetConsoleScreenBufferInfo(
                int in_hConsoleOutput,
                CONSOLE_SCREEN_BUFFER_INFO out_lpConsoleScreenBufferInfo);

        // DWORD WINAPI GetLastError(void);
        public int GetLastError();
    }
}

package com.stackoverflow.util;

import java.io.PrintStream;

import com.stackoverflow.util.Win32.Kernel32;

public class ConsoleUtil {
    public static void main(String[] args)
    throws Exception {
        System.out.print("abc");
        static_color_print(
                System.out, 
                "def", 
                Win32.CONSOLE_BACKGROUND_COLOR_RED, 
                Win32.CONSOLE_FOREGROUND_COLOR_BRIGHT_WHITE);
        System.out.print("def");
        System.out.println();
    }

    private static Win32.CONSOLE_SCREEN_BUFFER_INFO _static_console_screen_buffer_info = null; 

    public static void static_save_settings() {
        if (null == _static_console_screen_buffer_info) {
            _static_console_screen_buffer_info = new Win32.CONSOLE_SCREEN_BUFFER_INFO();
        }
        int stdout_handle = Kernel32.DLL.GetStdHandle(Win32.STD_OUTPUT_HANDLE);
        Kernel32.DLL.GetConsoleScreenBufferInfo(stdout_handle, _static_console_screen_buffer_info);
    }

    public static void static_restore_color()
    throws Exception {
        if (null == _static_console_screen_buffer_info) {
            throw new Exception("Internal error: Must save settings before restore");
        }
        int stdout_handle = Kernel32.DLL.GetStdHandle(Win32.STD_OUTPUT_HANDLE);
        Kernel32.DLL.SetConsoleTextAttribute(
                stdout_handle, 
                _static_console_screen_buffer_info.wAttributes);
    }

    public static void static_set_color(Short background_color, Short foreground_color) {
        int stdout_handle = Kernel32.DLL.GetStdHandle(Win32.STD_OUTPUT_HANDLE);
        if (null == background_color || null == foreground_color) {
            Win32.CONSOLE_SCREEN_BUFFER_INFO console_screen_buffer_info = 
                new Win32.CONSOLE_SCREEN_BUFFER_INFO();
            Kernel32.DLL.GetConsoleScreenBufferInfo(stdout_handle, console_screen_buffer_info);
            short current_bg_and_fg_color = console_screen_buffer_info.wAttributes;
            if (null == background_color) {
                short current_bg_color = (short) (current_bg_and_fg_color / 0x10);
                background_color = new Short(current_bg_color);
            }
            if (null == foreground_color) {
                short current_fg_color = (short) (current_bg_and_fg_color % 0x10);
                foreground_color = new Short(current_fg_color);
            }
        }
        short bg_and_fg_color = 
            (short) (background_color.shortValue() | foreground_color.shortValue());
        Kernel32.DLL.SetConsoleTextAttribute(stdout_handle, bg_and_fg_color);
    }

    public static<T> void static_color_print(
            PrintStream ostream, 
            T value, 
            Short background_color, 
            Short foreground_color)
    throws Exception {
        static_save_settings();
        try {
            static_set_color(background_color, foreground_color);
            ostream.print(value);
        }
        finally {
            static_restore_color();
        }
    }

    public static<T> void static_color_println(
            PrintStream ostream, 
            T value, 
            Short background_color, 
            Short foreground_color)
    throws Exception {
        static_save_settings();
        try {
            static_set_color(background_color, foreground_color);
            ostream.println(value);
        }
        finally {
            static_restore_color();
        }
    }
}

j'ai créé une bibliothèque jar appelée JCDP ( Java Colored Debug Printer ).

Pour Linux, il utilise les codes d'échappement ANSI mentionnés par WhiteFang, mais les résume en utilisant des mots au lieu de codes qui sont beaucoup plus intuitifs.

Pour Windows, il inclut en fait la bibliothèque JAnsi mais crée une couche d'abstraction dessus, maintenant l'interface intuitive et simple créée pour Linux.

Cette bibliothèque est sous licence Licence MIT alors n'hésitez pas à l'utiliser.

regarder JCDP dépôt github .

la méthode la plus simple est d'exécuter votre programme (non modifié) dans la console Cygwin.

la deuxième méthode la plus simple est de lancer votre programme (également non modifié) dans la console Windows ordinaire, pipelinant sa sortie à travers tee.exe (de la distribution Cygwin ou git). Tee.exe reconnaîtra les codes d'échappement et appellera les fonctions WinAPI appropriées.

quelque chose comme:

java MyClass | tee.exe log.txt
java MyClass | tee.exe /dev/null

les séquences D'évasion doivent être interprétées par quelque chose pour être converties en couleur. Le CMD standard.EXE utilisé par java lorsqu'il est démarré à partir de la ligne de commande, ne supporte pas cela, donc Java ne le supporte pas.

vérifiez ceci: j'ai utilisé les valeurs ANSI avec le code escape et cela ne fonctionne probablement pas dans l'invite de commande windows mais dans L'interpréteur de commandes IDEs et Unix. vous pouvez également consulter la bibliothèque 'Jansi' ici pour le support de windows.

System.out.println("\u001B[35m" + "This text is PURPLE!" + "\u001B[0m");

Système

.ERR.println ("Errorrrrrr") il imprimera le texte en couleur rouge sur la console.

j'ai écrit une bibliothèque appelée AnsiScape qui vous permet d'écrire la sortie de couleur d'une manière plus structurée:

exemple:

AnsiScape ansiScape = new AnsiScape();
String colors = ansiScape.format("{red {blueBg Red text with blue background}} {b Bold text}");
System.out.println(colors);

la bibliothèque il vous permet également de définir votre propre" escape classes " semblable à des classes css.

exemple:

AnsiScapeContext context = new AnsiScapeContext();

// Defines a "class" for text
AnsiClass text = AnsiClass.withName("text").add(RED);
// Defines a "class" for the title used
AnsiClass title = AnsiClass.withName("title").add(BOLD, BLUE_BG, YELLOW);
// Defines a "class" to render urls
AnsiClass url = AnsiClass.withName("url").add(BLUE, UNDERLINE);

// Registering the classes to the context
context.add(text).add(title).add(url);

// Creating an AnsiScape instance with the custom context
AnsiScape ansiScape = new AnsiScape(context);

String fmt = "{title Chapter 1}\n" +
              "{text So it begins:}\n" +
              "- {text Option 1}\n" +
              "- {text Url: {url www.someurl.xyz}}";

System.out.println(ansiScape.format(fmt));

cela fonctionne à eclipse juste pour le transformer en rouge, ne sais pas d'autres endroits.

System.err.println(" BLABLA ");