Comment colorer la sortie System.out.println ?[dupliquer]
https://stackoverflow.com/questions/1448858
-
11-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Cette question a déjà une réponse ici :
Comment puis-je colorer la sortie Java ?
Par exemple, en C et dans d'autres langages, je peux utiliser ANSI-escape comme \033[0m pour faire ça.Mais en Java, cela ne fonctionne pas.
public static void main(String[] x) {
System.out.println("\033[0m BLABLA \033[0m\n");
}
La solution
Non, mais il y a des API tiers de qui peut le manipuler
http: //www.javaworld. com / JavaWorld / javaqa / 2002-12 / 02-qa-1220-console.html
Edit: Bien sûr, il y a des articles plus récents que celui-là que j'ai posté, l'information est encore viable si
.Autres conseils
Note
Vous ne pourrez peut-être pas colorer les fenêtres cmd prompt, mais cela devrait fonctionner dans de nombreux terminaux Unix (ou de type Unix).
Notez également que certains terminaux ne prennent tout simplement pas en charge certaines (le cas échéant) séquences d'échappement ANSI et, en particulier, les couleurs 24 bits.
Usage
Veuillez vous référer à la rubrique Malédictions en bas pour la meilleure solution.Pour une solution personnelle ou facile (bien que pas comme solution multiplateforme), reportez-vous au Séquences d'échappement ANSI section.
TL;DR
Java:
System.out.println((char)27 + "[31m" + "ERROR MESSAGE IN RED");python:
print(chr(27) + "[31m" + "ERROR MESSAGE IN RED")- frapper ou zsh:
printf '\x1b[31mERROR MESSAGE IN RED'- cela peut également fonctionner pour Os X :
printf '\e[31mERROR MESSAGE IN RED'
- cela peut également fonctionner pour Os X :
- merde:
printf 'CTRL+V,CTRL+[[31mERROR MESSAGE IN RED'- c'est-à-dire, appuyez sur CTRL+V et puis CTRL+[ afin d'obtenir un "brut" ÉCHAP caractère lorsque l'interprétation d'échappement n'est pas disponible
- Si cela est fait correctement, vous devriez voir un
^[.Bien qu'il ressemble à deux personnages, il n'en est en réalité qu'un, le ÉCHAP personnage. - Vous pouvez également appuyer sur CTRL+V,CTRL+[ dans vigueur dans n'importe lequel des langages de programmation ou de script car cela utilise un littéral ÉCHAP personnage
- Vous pouvez également remplacer Ctrl+[ avec ÉCHAP … par exemple, vous pouvez utiliser CTRL+V,ÉCHAP, mais je trouve le premier plus facile, puisque j'appuie déjà sur CTRL et depuis [ est moins à l'écart.
Séquences d'échappement ANSI
Contexte des séquences d'échappement
Bien que ce ne soit pas la meilleure façon de procéder, la manière la plus simple de le faire dans un langage de programmation ou de script est d'utiliser Séquences d'échappement.À partir de ce lien :
Une séquence d'échappement est une série de caractères utilisée pour modifier l'état des ordinateurs et des périphériques connectés.Celles-ci sont également appelées séquences de contrôle, reflétant leur utilisation dans le contrôle des appareils.
Contexte des séquences d'échappement ANSI
Cependant, cela devient encore plus simple que cela dans les terminaux de vidéotexte, car ces terminaux utilisent Séquences d'échappement ANSI.À partir de ce lien :
Les séquences d'échappement ANSI sont une norme de signalisation intra-bande permettant de contrôler l'emplacement du curseur, la couleur et d'autres options sur les terminaux de vidéotexte.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 et non comme 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 ÉCHAP (ASCII :
27/ hexadécimal :0x1B). - Pour une liste de ce que vous pouvez faire, reportez-vous au Liste des séquences d'échappement ANSI sur Wikipédia
Dans les langages de programmation
Certains langages de programmation (comme Java) n'interpréteront pas \e ou \x1b comme le ÉCHAP personnage.Or, on sait que le caractère ASCII 27 est le ÉCHAP caractère, nous pouvons donc simplement transtyper 27 à un char et utilisez-le pour commencer la séquence d'échappement.
Voici quelques façons de le faire dans les langages de programmation courants :
Java
System.out.println((char)27 + "[33mYELLOW");
Python3
print(chr(27) + "[34mBLUE");print("\x1b[35mMAGENTA");- Noter que
\x1best interprété correctement en python
- Noter que
Nœud JS
- Ce qui suit sera PAS sortie couleur en JavaScript dans la console Web
console.log(String.fromCharCode(27) + "[36mCYAN");console.log("\x1b[30;47mBLACK_ON_WHITE");- Noter que
\x1bfonctionne également dans le nœud
- Noter que
Dans l'invite Shell OU dans les scripts
Si vous travaillez avec frapper 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 effectuant les deux opérations suivantes :
printf '\e[31mRED'printf '\x1b[31mRED'
Si vous voyez de la couleur pour les deux, alors c'est génial !Si vous ne voyez la couleur que pour un seul, utilisez cette séquence.Si vous ne voyez aucune couleur pour l'un ou l'autre, vérifiez à nouveau que vous avez tout tapé correctement et que vous êtes en bash ou zsh ;si vous ne voyez toujours aucune couleur, votre terminal ne prend probablement pas en charge les séquences d'échappement ANSI.
Si je me souviens bien, les terminaux Linux ont tendance à prendre en charge les deux \e et \x1b séquences d'échappement, alors que les terminaux os x ont tendance à ne prendre en charge que \e, mais je peux me tromper.Néanmoins, si vous voyez quelque chose comme l’image suivante, alors vous êtes prêt !(Notez que j'utilise le shell, zsh, et il colore ma chaîne d'invite ;aussi, j'utilise urxvt comme mon terminal sous Linux.)
"Comment cela marche-t-il?" pourriez-vous demander.Au fond, printf interprète la séquence de caractères qui suit (tout ce qui se trouve à l'intérieur du Guillemets simples).Quand printf rencontres \e ou \x1b, il convertira ces caractères en ÉCHAP caractère (ASCII :27).C'est exactement ce que nous voulons.Maintenant, printf envoie ÉCHAP31m, et comme il y a un ÉCHAP suivi d'une séquence d'échappement ANSI valide, nous devrions obtenir une sortie colorée (à condition qu'elle soit prise en charge par le terminal).
Vous pouvez aussi utiliser echo -e '\e[32mGREEN' (par exemple), à la sortie couleur.Notez que le -e drapeau pour echo "[permet] l'interprétation des échappements de barre oblique inverse" et doit être utilisé si vous le souhaitez echo pour interpréter correctement la séquence d'échappement.
En savoir plus sur les séquences d'échappement ANSI
Les séquences d'échappement ANSI peuvent faire plus que simplement afficher des couleurs, mais commençons par cela et voyons exactement comment fonctionne la couleur ;ensuite, nous verrons comment manipuler le curseur ;enfin, nous jetterons un coup d'œil et verrons comment utiliser la couleur 8 bits et également la couleur 24 bits (bien qu'elle n'ait qu'un support ténu).
Sur Wikipédia, ils font référence à ÉCHAP[ comme CSI, donc je ferai la même chose.
Couleur
Pour colorer la sortie à l'aide des échappements ANSI, utilisez ce qui suit :
CSInmCSI:caractère d'échappement-^[[ou ÉCHAP[n:un numéro : l'un des éléments suivants :30-37,39:premier plan40-47,49:arrière-plan
m:un ASCII littéralm— termine la séquence d'échappement
J'utiliserai bash ou zsh pour démontrer toutes les combinaisons de couleurs possibles.Placez ce qui suit dans 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:
Référence rapide (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 le rendu graphique (SGR)
SGR vous permet simplement de modifier le texte.Beaucoup d’entre eux ne fonctionnent pas sur certains terminaux, utilisez-les donc avec parcimonie dans les projets de production.Cependant, ils peuvent être utiles pour rendre la sortie du programme plus lisible ou pour vous aider à distinguer les différents types de sortie.
La couleur relève en fait de SGR, donc la syntaxe est la même :
CSInmCSI:caractère d'échappement-^[[ou ÉCHAP[n:un numéro : l'un des éléments suivants :0:réinitialiser1-9:active divers effets de texte21-29:désactive divers effets de texte (moins pris en charge que1-9)30-37,39:couleur de premier plan40-47,49:Couleur de l'arrière plan38:Couleur de premier plan 8 ou 24 bits (voir Couleur 8/24 bits ci-dessous)48:Couleur d'arrière-plan 8 ou 24 bits (voir Couleur 8/24 bits ci-dessous)
m:un ASCII littéralm— termine la séquence d'échappement
Bien qu'il n'y ait qu'un support ténu pour les caractères pâles (2), italique (3), souligné (4), clignotant (5,6), vidéo inversée (7), masqué (8) et barré (9), certains (mais rarement tous) ont tendance à fonctionner sur les terminaux Linux et OS X.
Il convient également de noter que vous pouvez séparer n'importe lequel des attributs ci-dessus par un point-virgule.Par exemple printf '\e[34;47;1;3mCRAZY TEXT\n' montrera CRAZY TEXT avec un blue foreground sur un white background, et ce sera bold et italic.
Par exemple:
Placez ce qui suit dans votre shell bash ou zsh pour voir tous les effets de texte que vous pouvez effectuer.(Vous devrez peut-être remplacer \e avec \x1b.)
for i in {1..9}; do printf "\e[${i}m~TEST~\e[0m "; done
Résultat:
Vous pouvez voir que mon terminal prend en charge tous les effets de texte sauf pour s'évanouir (2), cacher (8) et barrer (9).
Référence rapide (attributs SGR 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
Couleur 8 bits
Bien que la plupart des terminaux prennent en charge cette fonctionnalité, elle est moins prise en charge que 0-7,9 couleurs.
Syntaxe:
CSI38;5;nmCSI:caractère d'échappement-^[[ou ÉCHAP[38;5;:chaîne littérale qui indique l'utilisation de couleurs 8 bits pour le premier plann:un numéro : l'un des éléments suivants :0-255
Si vous souhaitez prévisualiser toutes les couleurs de votre terminal de manière agréable, j'ai un joli script sur gist.github.com.
Cela ressemble à ceci :
Si vous souhaitez modifier l'arrière-plan en utilisant des couleurs 8 bits, remplacez simplement le 38 avec un 48:
CSI48;5;nmCSI:caractère d'échappement-^[[ou ÉCHAP[48;5;:chaîne littérale qui indique l'utilisation de couleurs 8 bits pour l'arrière-plann:un numéro : l'un des éléments suivants :0-255
Couleur 24 bits
Également connue sous le nom de vraies couleurs, la couleur 24 bits offre des fonctionnalités vraiment intéressantes.Le support pour cela est définitivement en croissance (pour autant que je sache, cela fonctionne dans la plupart des terminaux modernes, sauf urxvt, mon terminal [insérer un emoji en colère]).
La couleur 24 bits est actuellement prise en charge dans vim (voir le wiki vim pour voir comment activer les couleurs 24 bits).C'est vraiment sympa car il s'inspire du schéma de couleurs défini pour gvim ;par exemple, il utilise le fg/bg de highlight guibg=#______ guifg=#______ pour les couleurs 24 bits !Neato, hein ?
Voici comment fonctionne la couleur 24 bits :
CSI38;2;r;g;bmCSI:caractère d'échappement-^[[ou ÉCHAP[38;2;:chaîne littérale qui indique l'utilisation de couleurs 24 bits pour le premier planr,g,b:nombres – chacun doit être0-255
Tester juste un peu des nombreuses couleurs que vous pouvez avoir ((2^8)^3 ou 2^24 ou 16777216 possibilités, je pense), vous pouvez utiliser ceci 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 PREND PAS EN CHARGE les couleurs 24 bits ...rassemblez-vous, responsable urxvt ...pour de vrai):
Si vous voulez des couleurs 24 bits pour l'arrière-plan...tu l'as deviné!vous venez de remplacer 38 avec 48:
CSI48;2;r;g;bmCSI:caractère d'échappement-^[[ou ÉCHAP[48;2;:chaîne littérale qui indique l'utilisation de couleurs 24 bits pour l'arrière-planr,g,b:nombres – chacun doit être0-255
Insertion de séquences d'échappement brutes
Parfois \e et \x1b ne fonctionnera pas.Par exemple, dans le merde shell, parfois ni l'un ni l'autre ne fonctionne (même si c'est le cas sur mon système maintenant, je ne pense pas que c'était le cas avant).
Pour contourner cela, vous pouvez utiliser CTRL+V,CTRL+[ ou CTRLV,ÉCHAP
Cela insérera un "brut" ÉCHAP caractère (ASCII :27).Il ressemblera à ceci ^[, mais ne vous inquiétez pas ;ce n'est qu'un seul personnage, pas deux.
Par exemple:
Malédictions
Se référer au Page Malédictions (Bibliothèque de programmation) pour une référence complète sur les malédictions.Il convient de noter que les malédictions ne fonctionnent que sur les systèmes d'exploitation Unix et de type Unix.
Prêt à fonctionner avec Curses
Je n'entrerai pas dans les détails, car les moteurs de recherche peuvent révéler des liens vers des sites Web qui peuvent expliquer cela bien mieux que moi, mais j'en discuterai brièvement ici et je donnerai un exemple.
Pourquoi utiliser Curses plutôt que les évasions ANSI ?
Si vous lisez le texte ci-dessus, vous vous souviendrez peut-être que \e ou \x1b travaillera parfois avec printf.Eh bien, parfois \e et \x1b ne fonctionnera pas du tout (ce n'est pas standard et je n'ai jamais travaillé avec un terminal comme celui-ci, mais c'est possible).Plus important encore, des séquences d'échappement plus complexes (pensez Maison et autres touches à plusieurs caractères) sont difficiles à prendre en charge pour chaque terminal (à moins que vous ne soyez prêt à consacrer beaucoup de temps et d'efforts à analyser terminfo et termcap et à comprendre comment gérer chaque terminal).
Curses résout ce problème.Fondamentalement, il est capable de comprendre les capacités d'un terminal, en utilisant ces méthodes (telles que décrites dans l'article Wikipédia lié ci-dessus) :
La plupart des implémentations de Cursus utilisent une base de données capable de décrire les capacités de milliers de terminaux différents.Il existe quelques implémentations, telles que PDCurses, qui utilisent des pilotes de périphériques spécialisés plutôt qu'une base de données de terminal.La plupart des implémentations utilisent terminfo ;certains utilisent termcap.Curses présente l'avantage de la rétroportabilité vers les terminaux de cellules de caractères et de la simplicité.Pour une application qui ne nécessite pas de graphiques bitmap ou de plusieurs polices, une implémentation d'interface utilisant des malédictions sera généralement beaucoup plus simple et plus rapide qu'une implémentation utilisant une boîte à outils X.
La plupart du temps, les malédictions interrogeront terminfo et seront alors capables de comprendre comment manipuler le curseur et les attributs du texte.Ensuite, vous, le programmeur, utilisez l'API fournie par Curses pour manipuler le curseur ou modifier la couleur du texte ou d'autres attributs si la fonctionnalité que vous recherchez est souhaitée.
Exemple avec Python
Je trouve que Python est vraiment facile à utiliser, mais si vous souhaitez utiliser des malédictions dans un langage de programmation différent, recherchez-le simplement sur duckduckgo ou sur 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 pensez peut-être qu'il s'agit d'une façon beaucoup plus détournée de faire les choses, mais c'est en réalité beaucoup plus multiplateforme (vraiment multi-terminal… du moins dans le monde des plates-formes Unix et de type Unix).Pour les couleurs, ce n'est pas le cas assez aussi important, mais lorsqu'il s'agit de prendre en charge d'autres séquences d'échappement multi-séquences (telles que Maison, Fin, Page précédente, Bas de page, etc.), alors les malédictions deviennent d'autant plus importantes.
Exemple avec Tput
tputest un utilitaire de ligne de commande pour manipuler le curseur et le textetputvient avec lecursesemballer.Si vous souhaitez utiliser des applications inter-terminaux (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 les 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'informations sur Tput
- 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 des 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 retourner la couleur au blanc (ou tout ce que vous utilisiez). Si vous ne pas pouvez faire tout ce qui suit « rouge ».
Vous pouvez utiliser le bibliothèque de Jansi pour rendre les séquences d'échappement ANSI sous Windows.
Oui, il est possible à 100%
set classpath =% classpath%; d: \ jansi-1.4.jar;
Essayez le 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 console Win32.
1) Obtenir les bibliothèques JavaNativeAccess ici: https://github.com/twall/jna/
2) Ces deux classes Java feront l'affaire.
Profitez.
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é JCDP ( Java couleur débogage imprimante ).
Pour Linux, il utilise les codes d'échappement ANSI qui Whitefang mentionné, mais les mots abrégés en utilisant au lieu de codes qui est beaucoup plus intuitive.
Pour Windows, il comprend effectivement la bibliothèque Jansi mais crée une couche d'abstraction au-dessus, maintien de l'interface intuitive et simple créé pour Linux.
Cette bibliothèque est sous licence MIT License pour se sentir libre de l'utiliser.
Jetez un oeil à dépôt GitHub de JCDP.
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 consiste à exécuter le programme que vous (également non modifiée) dans la console Windows ordinaire, canalisant sa sortie par tee.exe (de la distribution Cygwin ou Git). Tee.exe reconnaîtra les codes d'échappement et appeler des fonctions de WinAPI appropriées.
Quelque chose comme:
java MyClass | tee.exe log.txt
java MyClass | tee.exe /dev/null
Séquences d'échappement doivent être interprétées par quelque chose d'être convertie en couleur. Le cmd.exe standard utilisé par Java lors du démarrage de la ligne de commande, ne supporte pas ainsi donc Java ne fonctionne pas.
Check This Out: i utilisé les valeurs ANSI avec code d'échappement et probablement pas dans les fenêtres d'invite de commande, mais dans IDEs et shell Unix. vous pouvez également consulter la bibliothèque 'Jansi' pour le support Windows.
System.out.println("\u001B[35m" + "This text is PURPLE!" + "\u001B[0m");
System.err.println ( "Errorrrrrr"), il imprime le texte dans la couleur rouge sur la console.
J'ai écrit une bibliothèque appelée AnsiScape qui vous permet d'écrire la sortie couleur d'une façon plus structurée façon:
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 vos propres « classes d'échappement » semblable aux 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 éclipse juste pour le transformer rouge, ne savent pas d'autres endroits.
System.err.println(" BLABLA ");
