如何为Java输出着色？
例如在C语言和其他语言中,我可以使用ANSI-escape \033[0m来执行此操作.但在Java中它不起作用.
public static void main(String[] x) {
System.out.println("\033[0m BLABLA \033[0m\n");
}
dylnmc.. 108
您可能无法对Window进行着色cmd prompt,但它应该可以在许多unix(或unix-like)终端中使用.
另外,请注意,某些终端根本不支持某些(如果有)ANSI转义序列,特别是24位颜色.
请参阅底部的Curses部分以获得最佳解决方案.对于个人或简单的解决方案(尽管不是跨平台解决方案),请参阅ANSI Escape Sequences部分.
java:System.out.println((char)27 + "[31m" + "ERROR MESSAGE IN RED");
python:print(chr(27) + "[31m" + "ERROR MESSAGE IN RED")
bash或zsh:printf '\x1b[31mERROR MESSAGE IN RED'
这也适用于Os X: printf '\e[31mERROR MESSAGE IN RED'
sh:printf 'CTRL+ V,CTRL+[[31mERROR MESSAGE IN RED'
即按CTRL + V然后按CTRL + [以便ESC在转义解释不可用时获得"原始" 字符
如果做得正确,你应该看到一个^[.虽然它看起来像两个角色,但它实际上只是一个ESC角色.
您也可以按CTRL+ V,CTRL+ [在VIM在任何编程或sripting汉语语言的,因为它使用的文字ESC字符
此外,你可以用... 替换Ctrl+ [,ESC例如,你可以使用CTRL+ V,ESC但我发现前者更容易,因为我已经按下了CTRL,因为[不那么偏僻.
虽然这不是最好的方法,但在编程或脚本语言中执行此操作的最简单方法是使用转义序列.从该链接:
转义序列是用于更改计算机及其连接的外围设备状态的一系列字符.这些也称为控制序列,反映了它们在设备控制中的使用.
然而,它比视频文本终端更容易,因为这些终端使用ANSI转义序列.从该链接:
ANSI转义序列是带内信令的标准,用于控制视频文本终端上的光标位置,颜色和其他选项.某些字节序列(大多数以Esc和'['开头)嵌入到文本中,终端查找并解释为命令,而不是字符代码.
转义序列以转义字符开头; 对于ANSI转义序列,序列始终以ESC(ASCII:27/ hex :) 开头0x1B.
有关您可以执行的操作的列表,请参阅Wikipedia上的ANSI转义序列列表
一些编程语言(如Java)不会解释\e或\x1b作为ESC字符.然而,我们知道,ASCII字符27 是该ESC字符,所以我们可以简单地强制转换27到char并用它来开始转义序列.
以下是一些使用通用编程语言的方法:
Java的
System.out.println((char)27 + "[33mYELLOW");
Python 3
print(chr(27) + "[34mBLUE");
print("\x1b[35mMAGENTA");
请注意,\x1b在python中正确解释
节点JS
以下内容不会在Web控制台的JavaScript中输出颜色
console.log(String.fromCharCode(27) + "[36mCYAN");
console.log("\x1b[30;47mBLACK_ON_WHITE");
请注意,它\x1b也适用于节点
If you are working with bash or zsh, it is quite easy to color the output (in most terminals). In Linux, Os X, and in some Window's terminals, you can check to see if your terminal supports color by doing both of the following:
printf '\e[31mRED'
printf '\x1b[31mRED'
If you see color for both, then that's great! If you see color for only one, then use that sequence. If you do not see color for either of them, then double check to make sure you typed everything correctly and that you are in bash or zsh; if you still do not see any color, then your terminal probably does not support ANSI escape sequences.
If I recall correctly, linux terminals tend to support both \e and \x1b escape sequences, while os x terminals only tend to support \e, but I may be wrong. Nonetheless, if you see something like the following image, then you're all set! (Note that I am using the shell, zsh, and it is coloring my prompt string; also, I am using urxvt as my terminal in linux.)
"How does this work?" you might ask. Bascially, printf is interpretting the sequence of characters that follows (everything inside of the single-quotes). When printf encounters \e or \x1b, it will convert these characters to the ESC character (ASCII: 27). That's just what we want. Now, printf sends ESC31m, and since there is an ESC followed by a valid ANSI escape sequence, we should get colored output (so long as it is supported by the terminal).
You can also use echo -e '\e[32mGREEN' (for example), to color output. Note that the -e flag for echo "[enables] interpretation of backslash escapes" and must be used if you want echo to appropriately interpret the escape sequence.
ANSI escape sequences can do more than just color output, but let's start with that, and see exactly how color works; then, we will see how to manipulate the cursor; finally, we'll take a look and see how to use 8-bit color and also 24-bit color (although it only has tenuous support).
On Wikipedia, they refer to ESC[ as CSI, so I will do the same.
To color output using ANSI escapes, use the following:
CSI n m
CSI: escape character—^[[ or ESC[
n: a number—one of the following:
30-37, 39: foreground
40-47, 49: background
m: a literal ASCII m—terminates the escape sequence
I will use bash or zsh to demonstrate all of the possible color combinations. Plop the following in bash or zsh to see for yourself (You may need to replace \e with \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;
Result:
+~~~~~~+~~~~~~+~~~~~~~~~~~+ | 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 | +~~~~~~+~~~~~~+~~~~~~~~~~~+
SGR just allows you to change the text. Many of these do not work in certain terminals, so use these sparingly in production-level projects. However, they can be useful for making program output more readable or helping you distinguish between different types of output.
Color actually falls under SGR, so the syntax is the same:
CSI n m
CSI: escape character—^[[ or ESC[
n: a number—one of the following:
0: reset
1-9: turns on various text effects
21-29: turns off various text effects (less supported than 1-9)
30-37, 39: foreground color
40-47, 49: background color
38: 8- or 24-bit foreground color (see 8/24-bit Color below)
48: 8- or 24-bit background color (see 8/24-bit Color below)
m: a literal ASCII m—terminates the escape sequence
Although there is only tenuous support for faint (2), italic (3), underline (4), blinking (5,6), reverse video (7), conceal (8), and crossed out (9), some (but rarely all) tend to work on linux and os x terminals.
It's also worthwhile to note that you can separate any of the above attributes with a semi-colon. For example printf '\e[34;47;1;3mCRAZY TEXT\n' will show CRAZY TEXT with a blue foreground on a white background, and it will be bold and italic.
Eg:
Plop the following in your bash or zsh shell to see all of the text effects you can do. (You may need to replace \e with \x1b.)
for i in {1..9}; do printf "\e[${i}m~TEST~\e[0m "; done
Result:
You can see that my terminal supports all of the text effects except for faint (2), conceal (8) and cross out (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
While most terminals support this, it is less supported than 0-7,9 colors.
Syntax:
CSI 38;5; n m
CSI: escape character—^[[ or ESC[
38;5;: literal string that denotes use of 8-bit colors for foreground
n: a number—one of the following:
0-255
If you want to preview all of the colors in your terminal in a nice way, I have a nice script on gist.github.com.
It looks like this:
If you want to change the background using 8-bit colors, just replace the 38 with a 48:
CSI 48;5; n m
CSI: escape character—^[[ or ESC[
48;5;: literal string that denotes use of 8-bit colors for background
n: a number—one of the following:
0-255
Also known as true color, 24-bit color provides some really cool functionality. Support for this is definitely growing (as far as I know it works in most modern terminals except urxvt, my terminal [insert angry emoji]).
24-bit color is actually supported in vim (see the vim wiki to see how to enable 24-bit colors). It's really neat because it pulls from the colorscheme defined for gvim; eg, it uses the fg/bg from highlight guibg=#______ guifg=#______ for the 24-bit colors! Neato, huh?
Here is how 24-bit color works:
CSI 38;2; r ; g ; b m
CSI: escape character—^[[ or ESC[
38;2;: literal string that denotes use of 24-bit colors for foreground
r,g,b: numbers—each should be 0-255
To test just a few of the many colors you can have ((2^8)^3 or 2^24 or 16777216 possibilites, I think), you can use this in bash or 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;
Result (this is in gnome-terminal since urxvt DOES NOT SUPPORT 24-bit color ... get it together, urxvt maintainer ... for real):
If you want 24-bit colors for the background ... you guessed it! You just replace 38 with 48:
CSI 48;2; r ; g ; b m
CSI: escape character—^[[ or ESC[
48;2;: literal string that denotes use of 24-bit colors for background
r,g,b: numbers—each should be 0-255
Sometimes \e and \x1b will not work. For example, in the sh shell, sometimes neither works (although it does on my system now, I don't think it used to).
To circumvent this, you can use CTRL+V,CTRL+[ or CTRLV,ESC
This will insert a "raw" ESC character (ASCII: 27). It will look like this ^[, but do not fret; it is only one character—not two.
Eg:
Refer to the Curses (Programming Library) page for a full reference on curses. It should be noted that curses only works on unix and unix-like operating systems.
I won't go into too much detail, for search engines can reveal links to websites that can explain this much better than I can, but I'll discuss it briefly here and give an example.
If you read the above text, you might recall that \e or \x1b will sometimes work with printf. Well, sometimes \e and \x1b will not work at all (this is not standard and I have never worked with a terminal like this, but it is possible). More importantly, more complex escape sequences (think Home and other multi-character keys) are difficult to support for every terminal (unless you are willing to spend a lot of time and effort parsing terminfo and termcap and and figuring out how to handle every terminal).
Curses solves this problem. Basically, it is able to understand what capabilities a terminal has, using these methods (as described by the wikipedia article linked above):
Most implementations of curses use a database that can describe the capabilities of thousands of different terminals. There are a few implementations, such as PDCurses, which use specialized device drivers rather than a terminal database. Most implementations use terminfo; some use termcap. Curses has the advantage of back-portability to character-cell terminals and simplicity. For an application that does not require bit-mapped graphics or multiple fonts, an interface implementation using curses will usually be much simpler and faster than one using an X toolkit.
Most of the time, curses will poll terminfo and will then be able to understand how to manipulate the cursor and text attributes. Then, you, the programmer, use the API provided by curses to manipulate the cursor or change the text color or other attributes if the functionality you seek is desired.
I find python is really easy to use, but if you want to use curses in a different programming language, then simply search it on duckduckgo or any other search engine. :) Here is a quick example in 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)
result:
You might think to yourself that this is a much more round-about way of doing things, but it really is much more cross-platform (really cross-terminal … at least in the unix- and unix-like-platform world). For colors, it is not quite as important, but when it comes to supporting other multi-sequence escape sequences (such as Home, End, Page Up, Page Down, etc), then curses becomes all the more important.
tput is a command line utility for manipulating cursor and text
tput comes with the curses package. If you want to use cross-terminal (ish) applications in the terminal, you should use tput, as it parses terminfo or whatever it needs to and uses a set of standardized commands (like curses) and returns the correct escape sequence.
example:
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\!"
Result:
see: http://linuxcommand.org/lc3_adv_tput.php to see how tput works
see: http://invisible-island.net/ncurses/man/terminfo.5.html for a list of commands that you can use
小智.. 32
这对我有用:
System.out.println((char)27 + "[31mThis text would show up red" + (char)27 + "[0m");
你需要结尾"[37m"将颜色恢复为白色(或者你正在使用的任何颜色).如果你不这样做,它可能会使一切都跟随"红色".
您可能无法对Window进行着色cmd prompt,但它应该可以在许多unix(或unix-like)终端中使用.
另外,请注意,某些终端根本不支持某些(如果有)ANSI转义序列,特别是24位颜色.
请参阅底部的Curses部分以获得最佳解决方案.对于个人或简单的解决方案(尽管不是跨平台解决方案),请参阅ANSI Escape Sequences部分.
java:System.out.println((char)27 + "[31m" + "ERROR MESSAGE IN RED");
python:print(chr(27) + "[31m" + "ERROR MESSAGE IN RED")
bash或zsh:printf '\x1b[31mERROR MESSAGE IN RED'
这也适用于Os X: printf '\e[31mERROR MESSAGE IN RED'
sh:printf 'CTRL+ V,CTRL+[[31mERROR MESSAGE IN RED'
即按CTRL + V然后按CTRL + [以便ESC在转义解释不可用时获得"原始" 字符
如果做得正确,你应该看到一个^[.虽然它看起来像两个角色,但它实际上只是一个ESC角色.
您也可以按CTRL+ V,CTRL+ [在VIM在任何编程或sripting汉语语言的,因为它使用的文字ESC字符
此外,你可以用... 替换Ctrl+ [,ESC例如,你可以使用CTRL+ V,ESC但我发现前者更容易,因为我已经按下了CTRL,因为[不那么偏僻.
虽然这不是最好的方法,但在编程或脚本语言中执行此操作的最简单方法是使用转义序列.从该链接:
转义序列是用于更改计算机及其连接的外围设备状态的一系列字符.这些也称为控制序列,反映了它们在设备控制中的使用.
然而,它比视频文本终端更容易,因为这些终端使用ANSI转义序列.从该链接:
ANSI转义序列是带内信令的标准,用于控制视频文本终端上的光标位置,颜色和其他选项.某些字节序列(大多数以Esc和'['开头)嵌入到文本中,终端查找并解释为命令,而不是字符代码.
转义序列以转义字符开头; 对于ANSI转义序列,序列始终以ESC(ASCII:27/ hex :) 开头0x1B.
有关您可以执行的操作的列表,请参阅Wikipedia上的ANSI转义序列列表
一些编程语言(如Java)不会解释\e或\x1b作为ESC字符.然而,我们知道,ASCII字符27 是该ESC字符,所以我们可以简单地强制转换27到char并用它来开始转义序列.
以下是一些使用通用编程语言的方法:
Java的
System.out.println((char)27 + "[33mYELLOW");
Python 3
print(chr(27) + "[34mBLUE");
print("\x1b[35mMAGENTA");
请注意,\x1b在python中正确解释
节点JS
以下内容不会在Web控制台的JavaScript中输出颜色
console.log(String.fromCharCode(27) + "[36mCYAN");
console.log("\x1b[30;47mBLACK_ON_WHITE");
请注意,它\x1b也适用于节点
If you are working with bash or zsh, it is quite easy to color the output (in most terminals). In Linux, Os X, and in some Window's terminals, you can check to see if your terminal supports color by doing both of the following:
printf '\e[31mRED'
printf '\x1b[31mRED'
If you see color for both, then that's great! If you see color for only one, then use that sequence. If you do not see color for either of them, then double check to make sure you typed everything correctly and that you are in bash or zsh; if you still do not see any color, then your terminal probably does not support ANSI escape sequences.
If I recall correctly, linux terminals tend to support both \e and \x1b escape sequences, while os x terminals only tend to support \e, but I may be wrong. Nonetheless, if you see something like the following image, then you're all set! (Note that I am using the shell, zsh, and it is coloring my prompt string; also, I am using urxvt as my terminal in linux.)
"How does this work?" you might ask. Bascially, printf is interpretting the sequence of characters that follows (everything inside of the single-quotes). When printf encounters \e or \x1b, it will convert these characters to the ESC character (ASCII: 27). That's just what we want. Now, printf sends ESC31m, and since there is an ESC followed by a valid ANSI escape sequence, we should get colored output (so long as it is supported by the terminal).
You can also use echo -e '\e[32mGREEN' (for example), to color output. Note that the -e flag for echo "[enables] interpretation of backslash escapes" and must be used if you want echo to appropriately interpret the escape sequence.
ANSI escape sequences can do more than just color output, but let's start with that, and see exactly how color works; then, we will see how to manipulate the cursor; finally, we'll take a look and see how to use 8-bit color and also 24-bit color (although it only has tenuous support).
On Wikipedia, they refer to ESC[ as CSI, so I will do the same.
To color output using ANSI escapes, use the following:
CSI n m
CSI: escape character—^[[ or ESC[
n: a number—one of the following:
30-37, 39: foreground
40-47, 49: background
m: a literal ASCII m—terminates the escape sequence
I will use bash or zsh to demonstrate all of the possible color combinations. Plop the following in bash or zsh to see for yourself (You may need to replace \e with \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;
Result:
+~~~~~~+~~~~~~+~~~~~~~~~~~+ | 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 | +~~~~~~+~~~~~~+~~~~~~~~~~~+
SGR just allows you to change the text. Many of these do not work in certain terminals, so use these sparingly in production-level projects. However, they can be useful for making program output more readable or helping you distinguish between different types of output.
Color actually falls under SGR, so the syntax is the same:
CSI n m
CSI: escape character—^[[ or ESC[
n: a number—one of the following:
0: reset
1-9: turns on various text effects
21-29: turns off various text effects (less supported than 1-9)
30-37, 39: foreground color
40-47, 49: background color
38: 8- or 24-bit foreground color (see 8/24-bit Color below)
48: 8- or 24-bit background color (see 8/24-bit Color below)
m: a literal ASCII m—terminates the escape sequence
Although there is only tenuous support for faint (2), italic (3), underline (4), blinking (5,6), reverse video (7), conceal (8), and crossed out (9), some (but rarely all) tend to work on linux and os x terminals.
It's also worthwhile to note that you can separate any of the above attributes with a semi-colon. For example printf '\e[34;47;1;3mCRAZY TEXT\n' will show CRAZY TEXT with a blue foreground on a white background, and it will be bold and italic.
Eg:
Plop the following in your bash or zsh shell to see all of the text effects you can do. (You may need to replace \e with \x1b.)
for i in {1..9}; do printf "\e[${i}m~TEST~\e[0m "; done
Result:
You can see that my terminal supports all of the text effects except for faint (2), conceal (8) and cross out (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
While most terminals support this, it is less supported than 0-7,9 colors.
Syntax:
CSI 38;5; n m
CSI: escape character—^[[ or ESC[
38;5;: literal string that denotes use of 8-bit colors for foreground
n: a number—one of the following:
0-255
If you want to preview all of the colors in your terminal in a nice way, I have a nice script on gist.github.com.
It looks like this:
If you want to change the background using 8-bit colors, just replace the 38 with a 48:
CSI 48;5; n m
CSI: escape character—^[[ or ESC[
48;5;: literal string that denotes use of 8-bit colors for background
n: a number—one of the following:
0-255
Also known as true color, 24-bit color provides some really cool functionality. Support for this is definitely growing (as far as I know it works in most modern terminals except urxvt, my terminal [insert angry emoji]).
24-bit color is actually supported in vim (see the vim wiki to see how to enable 24-bit colors). It's really neat because it pulls from the colorscheme defined for gvim; eg, it uses the fg/bg from highlight guibg=#______ guifg=#______ for the 24-bit colors! Neato, huh?
Here is how 24-bit color works:
CSI 38;2; r ; g ; b m
CSI: escape character—^[[ or ESC[
38;2;: literal string that denotes use of 24-bit colors for foreground
r,g,b: numbers—each should be 0-255
To test just a few of the many colors you can have ((2^8)^3 or 2^24 or 16777216 possibilites, I think), you can use this in bash or 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;
Result (this is in gnome-terminal since urxvt DOES NOT SUPPORT 24-bit color ... get it together, urxvt maintainer ... for real):
If you want 24-bit colors for the background ... you guessed it! You just replace 38 with 48:
CSI 48;2; r ; g ; b m
CSI: escape character—^[[ or ESC[
48;2;: literal string that denotes use of 24-bit colors for background
r,g,b: numbers—each should be 0-255
Sometimes \e and \x1b will not work. For example, in the sh shell, sometimes neither works (although it does on my system now, I don't think it used to).
To circumvent this, you can use CTRL+V,CTRL+[ or CTRLV,ESC
This will insert a "raw" ESC character (ASCII: 27). It will look like this ^[, but do not fret; it is only one character—not two.
Eg:
Refer to the Curses (Programming Library) page for a full reference on curses. It should be noted that curses only works on unix and unix-like operating systems.
I won't go into too much detail, for search engines can reveal links to websites that can explain this much better than I can, but I'll discuss it briefly here and give an example.
If you read the above text, you might recall that \e or \x1b will sometimes work with printf. Well, sometimes \e and \x1b will not work at all (this is not standard and I have never worked with a terminal like this, but it is possible). More importantly, more complex escape sequences (think Home and other multi-character keys) are difficult to support for every terminal (unless you are willing to spend a lot of time and effort parsing terminfo and termcap and and figuring out how to handle every terminal).
Curses solves this problem. Basically, it is able to understand what capabilities a terminal has, using these methods (as described by the wikipedia article linked above):
Most implementations of curses use a database that can describe the capabilities of thousands of different terminals. There are a few implementations, such as PDCurses, which use specialized device drivers rather than a terminal database. Most implementations use terminfo; some use termcap. Curses has the advantage of back-portability to character-cell terminals and simplicity. For an application that does not require bit-mapped graphics or multiple fonts, an interface implementation using curses will usually be much simpler and faster than one using an X toolkit.
Most of the time, curses will poll terminfo and will then be able to understand how to manipulate the cursor and text attributes. Then, you, the programmer, use the API provided by curses to manipulate the cursor or change the text color or other attributes if the functionality you seek is desired.
I find python is really easy to use, but if you want to use curses in a different programming language, then simply search it on duckduckgo or any other search engine. :) Here is a quick example in 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)
result:
You might think to yourself that this is a much more round-about way of doing things, but it really is much more cross-platform (really cross-terminal … at least in the unix- and unix-like-platform world). For colors, it is not quite as important, but when it comes to supporting other multi-sequence escape sequences (such as Home, End, Page Up, Page Down, etc), then curses becomes all the more important.
tput is a command line utility for manipulating cursor and text
tput comes with the curses package. If you want to use cross-terminal (ish) applications in the terminal, you should use tput, as it parses terminfo or whatever it needs to and uses a set of standardized commands (like curses) and returns the correct escape sequence.
example:
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\!"
Result:
see: http://linuxcommand.org/lc3_adv_tput.php to see how tput works
see: http://invisible-island.net/ncurses/man/terminfo.5.html for a list of commands that you can use
这对我有用:
System.out.println((char)27 + "[31mThis text would show up red" + (char)27 + "[0m");
你需要结尾"[37m"将颜色恢复为白色(或者你正在使用的任何颜色).如果你不这样做,它可能会使一切都跟随"红色".
不,但有第三方API可以处理它
http://www.javaworld.com/javaworld/javaqa/2002-12/02-qa-1220-console.html
编辑:当然有比我发布的文章更新的文章,但信息仍然可行.
您可以使用JANSI库在Windows中呈现ANSI转义序列.
是的,它是100%可能的
set classpath =%classpath%; d:\ jansi-1.4.jar;
试试以下代码:
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();
}
}
这是Win32控制台的解决方案.
1)在这里获取JavaNativeAccess库:https://github.com/twall/jna/
2)这两个Java类将起到作用.
请享用.
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 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 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();
}
}
}
京公网安备 11010802040832号 | 京ICP备19059560号-6 