批处理 读取剪贴板

批处理 将命令输出写如剪贴板

批处理中如果想把命令的输出写入剪贴板是很容易的,使用管道符+clip即可实现,例如

1
dir | clip

这个命令把dir命令的输出写入到剪贴板中,剪贴板中的文本,如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 驱动器 G 中的卷是 原来的C盘
卷的序列号是 0C02-061D

G:\Desktop\Vscode测试 的目录

2019/08/26 23:14 <DIR> .
2019/08/26 23:14 <DIR> ..
2019/07/22 01:44 28 spanButtonCSS.txt
2019/08/26 23:06 146 test.bat
2019/07/23 17:22 314 test.html
2019/07/12 23:33 852 Test.java
2019/05/29 11:18 8,350 test.jsp
2019/07/24 21:19 1,588 test.md
2019/08/26 22:58 57 tmp.txt
2019/08/26 22:24 245 treej.bat
2019/04/29 13:50 613 正则表达式步骤.md
9 个文件 12,193 字节
2 个目录 215,235,579,904 可用字节

批处理 读取剪贴板

遗憾的是,批处理好像没有提供读取剪贴板的功能(反正我查了好久没查到).那只能迂回实现了.

for命令可以遍历另一个命令的输出结果

如下格式的for命令,可以遍历单引号中命令的输出结果.注意,命令要写在单引号中.

1
2
3
FOR /F "delims=" %%i in ('命令') do (
echo %%i
)

所以,我只要自己写一个PrintClip命令:这个PrintClip命令可以打印出剪贴板中的文本到标准输出.这样我就可通过上述的for命令遍历PrintClip命令的标准输出,进入实现读取剪贴板的功能。

java代码

这个输出剪贴板文本的代码很简单,如下所示:

PrintClip.java

1
2
3
4
5
6
7
8
9
10
package clipoard.output;
import clipboard.util.SysClipboardUtil;
/**
* 输出剪贴板中的内容.
*/
public class PrintClip {
public static void main(String[] args) {
System.out.print(SysClipboardUtil.getSysClipboardText());
}
}

其中SysClipboardUtil是读写剪贴板的工具类,该工具类源码如下:

SysClipboardUtil.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
package clipboard.util;

import java.awt.Image;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.image.BufferedImage;
import java.io.IOException;

public class SysClipboardUtil
{
/**
* 从剪贴板中获取文本.
*
* @return 如果剪贴板中没有文本,则返回null.如果获取到文本,则返回文本.
*/
public static String getSysClipboardText()
{
// 代码兼容JDK6,不然剪贴板获取文本可能错误
System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");
String text = null;
Clipboard sysClip = Toolkit.getDefaultToolkit().getSystemClipboard();
// 获取剪切板中的内容
Transferable clipTf = sysClip.getContents(null);

if (clipTf != null)
{
// 检查内容是否是文本类型
if (clipTf.isDataFlavorSupported(DataFlavor.stringFlavor))
{
try
{
// 转换为文本
text = (String) clipTf
.getTransferData(DataFlavor.stringFlavor);
} catch (Exception e)
{
e.printStackTrace();
}
}
}

return text;
}
/**
* 把字符串写到系统剪贴板。
*
* @param writeMe
* 要写入剪贴板的文本
*/
public static void setSysClipboardText(String writeMe)
{
Clipboard clip = Toolkit.getDefaultToolkit().getSystemClipboard();
Transferable tText = new StringSelection(writeMe);
clip.setContents(tText, null);
}
/**
* 从系统剪贴板获取图片。
*
* @return 系统剪贴板里面的图片。
*/
public static BufferedImage getImageFromClipboard()
{
try
{
Clipboard sysc = Toolkit.getDefaultToolkit().getSystemClipboard();
Transferable cc = sysc.getContents(null);
if (cc == null)
return null;
else if (cc.isDataFlavorSupported(DataFlavor.imageFlavor))
return (BufferedImage) cc
.getTransferData(DataFlavor.imageFlavor);
} catch (Exception e)
{
e.printStackTrace();
}
return null;
}

/**
* 把图片复制到剪贴板中。
*
* @param image
* 要复制到剪贴板的图片。
*/
public static void setClipboardImage(final Image image)
{
Transferable trans = new Transferable()
{
public DataFlavor[] getTransferDataFlavors()
{
return new DataFlavor[]
{DataFlavor.imageFlavor};
}

public boolean isDataFlavorSupported(DataFlavor flavor)
{
return DataFlavor.imageFlavor.equals(flavor);
}

public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException, IOException
{
if (isDataFlavorSupported(flavor))
return image;
throw new UnsupportedFlavorException(flavor);
}

};
Toolkit.getDefaultToolkit().getSystemClipboard().setContents(trans,
null);
}

}

PrintClip.java导出成可执行Jar包,然后写一个同名的批处理文件PrintClip.bat来运行这个可执行jar,如下:

1
2
@echo off
java -jar "E:\dev2\idea_workspace\MyJavaTools\runable\PrintClip.jar"

配置path环境变量

为了让PrintClip.bat可以在任意地方调用,需要把PrintClip.bat文件所在的目录的路径配置到**Path环境变量**中,这和把java.exe所在的路径配置到Path环境变量之后,就可也在cmd中执行java命令是一样的道理。
配置好Path环境变量后就可以通过自定义的PrintClip命令来输出剪贴板中的内容了。

测试

现在复制下面的测试字符串:

1
HelloWorld!

然后打开cmd,运行PrintClip命令,效果如下所示:

1
2
3
4
5
6
Microsoft Windows [版本 10.0.17134.915]
(c) 2018 Microsoft Corporation。保留所有权利。

G:\Desktop\Vscode测试>PrintClip
HelloWorld!
G:\Desktop\Vscode测试>

好的现在自定义的命令PrintClip已经可以输出剪贴板中的内容到标准输出了,接下来用for命令遍历PrintClip命令的输出即可读取剪贴板中的内容。

使用For命令读入PrintClip命令的输出

1
2
3
4
5
6
7
8
@echo off
FOR /F "delims=" %%i in ('PrintClip') do (
::保存下剪贴板中的内容
set strInClip=%%i
)
:: 输出剪贴板中的内容
echo 剪贴板中的内容:%strInClip%
pause

现在复制下面的测试字符串:

1
HelloWorld!

然后运行这个批处理,运行效果如下:

1
2
剪贴板中的内容:HelloWorld!
请按任意键继续. . .

好的,这就实现了读取剪贴板的内容了.

应用

我这么做是为了,方便使用自定义的mytree命令打印Java项目的目录结构,这样我在IDE中复制好Java项目的路径之后,就可以通过读取剪贴板中项目的路径,切换盘符,进入项目所在的路径,然后就可以调用mytree命令将项目的目录结构输出到剪贴板中.接着再调用另一个自定义命令m,将剪贴板中的数据格式化成Markdown代码块.
说了一堆,这个批处理代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
@echo off
:: 读取剪贴板中的内容,注意这里要求输入的是Java项目的路径.
FOR /F "delims=" %%i in ('PrintClip') do (
::切换盘符
%%~di
::进入目录
cd %%i
)
:: 打印Java项目的目录结构,并输出重定向到剪贴板中.
mytree java|clip
:: 将剪贴板中的文本封装成Markdown代码块
m cb cmd

其中%%~di是变量拓展,获取该路径所在的盘符的意思,cd %%i表示切换到该路径下.剩下的倒数两个命令是我自定义的命令.

批处理 start命令

帮助文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
启动一个单独的窗口以运行指定的程序或命令。

START ["title"] [/D path] [/I] [/MIN] [/MAX] [/SEPARATE | /SHARED]
[/LOW | /NORMAL | /HIGH | /REALTIME | /ABOVENORMAL | /BELOWNORMAL]
[/NODE <NUMA node>] [/AFFINITY <hex affinity mask>] [/WAIT] [/B]
[command/program] [parameters]

"title" 在窗口标题栏中显示的标题。
path 启动目录。
B 启动应用程序,但不创建新窗口。
应用程序已忽略 ^C 处理。除非应用程序
启用 ^C 处理,否则 ^Break 是唯一可以中断
该应用程序的方式。
I 新的环境将是传递
cmd.exe 的原始环境,而不是当前环境。
MIN 以最小化方式启动窗口。
MAX 以最大化方式启动窗口。
SEPARATE 在单独的内存空间中启动 16 位 Windows 程序。
SHARED 在共享内存空间中启动 16 位 Windows 程序。
LOW 在 IDLE 优先级类中启动应用程序。
NORMAL 在 NORMAL 优先级类中启动应用程序。
HIGH 在 HIGH 优先级类中启动应用程序。
REALTIME 在 REALTIME 优先级类中启动应用程序。
ABOVENORMAL 在 ABOVENORMAL 优先级类中启动应用程序。
BELOWNORMAL 在 BELOWNORMAL 优先级类中启动应用程序。
NODE 将首选非一致性内存结构(NUMA)节点指定为
十进制整数。
AFFINITY 将处理器关联掩码指定为十六进制数字。
进程被限制在这些处理器上运行。

将 /AFFINITY 和 /NODE 结合使用时,会对关联掩码
进行不同的解释。指定关联掩码,以便将零位作为起始位置(就如将 NUMA
节点的处理器掩码向右移位一样)。
进程被限制在指定关联掩码和 NUMA 节点之间的
那些通用处理器上运行。
如果没有通用处理器,则进程被限制在
指定的 NUMA 节点上运行。
WAIT 启动应用程序并等待它终止。
command/program
如果它是内部 cmd 命令或批文件,则
该命令处理器是使用 cmd.exe 的 /K 开关运行的。
这表示运行该命令之后,该窗口
将仍然存在。

如果它不是内部 cmd 命令或批文件,则
它就是一个程序,并将作为一个窗口化应用程序或
控制台应用程序运行。

parameters 这些是传递给 command/program 的参数。

注意: 在 64 位平台上不支持 SEPARATE 和 SHARED 选项。

通过指定 /NODE,可按照利用 NUMA 系统中的内存区域的方式
创建进程。例如,可以创建两个完全
通过共享内存互相通信的进程以共享相同的首选 NUMA 节点,
从而最大限度地减少内存延迟。只要有可能,
它们就会分配来自相同 NUMA 节点的
内存,并且会在指定节点之外的处理器上自由运行。

start /NODE 1 application1.exe
start /NODE 1 application2.exe

这两个进程可被进一步限制在相同 NUMA 节点内的指定处理器
上运行。在以下示例中,application1 在
节点的两个低位处理器上运行,而 application2
在该节点的其后两个处理器上运行。该示例假定指定节点至少具有四个逻辑处理器。请注意,节点号可更改为该计算机的任何有效节点号,
而无需更改关联掩码。

start /NODE 1 /AFFINITY 0x3 application1.exe
启动 /NODE 1 /AFFINITY 0xc application2.exe

如果命令扩展被启用,通过命令行或 START 命令的外部命令
调用会如下改变:

将文件名作为命令键入,非可执行文件可以通过文件关联调用。
(例如,WORD.DOC 会调用跟 .DOC 文件扩展名关联的应用程序)。
关于如何从命令脚本内部创建这些关联,请参阅 ASSOC
FTYPE 命令。

执行的应用程序是 32 位 GUI 应用程序时,CMD.EXE 不等应用
程序终止就返回命令提示符。如果在命令脚本内执行,该新行为
则不会发生。

如果执行的命令行的第一个符号是不带扩展名或路径修饰符的
字符串 "CMD","CMD" 会被 COMSPEC 变量的数值所替换。这
防止从当前目录提取 CMD.EXE。

如果执行的命令行的第一个符号没有扩展名,CMD.EXE 会使用
PATHEXT 环境变量的数值来决定要以什么顺序寻找哪些扩展
名。PATHEXT 变量的默认值是:

.COM;.EXE;.BAT;.CMD

请注意,该语法跟 PATH 变量的一样,分号隔开不同的元素。

查找可执行文件时,如果没有相配的扩展名,看一看该名称是否
与目录名相配。如果确实如此,START 会在那个路径上调用
Explorer。如果从命令行执行,则等同于对那个路径作 CD /D。

帮助文档解释

上面格式有点长,可以精简为start 选项 程序 参数;

应用

在特定目录下启动cmd

命令格式:start /d 目录路径 cmd.exe
例如:

1
start /d E:\workspace_QingLiangJiJavaEEQiYeYingYongShiZhang5\lazy-init cmd.exe

前言

最近想随机生成一串包含数字和字母的字符串.但是我发现把int类型的数字通过强制类型转换为char类型字符的时候出现了乱码.

原因

字符'0'ASCII编码值是48,如果直接通过类似如下的强制类型转换:

1
char ch=(int) 0;

得到的字符不是'0',而是其他字符。

数字0到9转为’0’到’9’字符的正确做法

先计算出正确的ASCII码在转为字符

使用自动类型转换进行计算

在char类型和int类型进行计算时,会自动把char类型转为int类型,所以可以先把字符'0'数字进行计算得到正确的ASCII编码值,然后再强制类型转为字符.如下所示:

1
2
int i=2;
char c = (char)('0' + i);

直接计算

当然换成如下写法也是可以的.

1
2
int i=2;
char c = (char)(48 + i);

Character.forDigit(数字,进制)方法进行转换

1
2
int i=2;
char c = Character.forDigit(i,10);

快捷键支持

安装Markdown All in One插件,该插件提供了快捷键支持.

加粗

Ctrl+B

切换代办列表

Alt+C

格式化表格

Alt+Shitf+F

快捷键表格

快捷键 功能
Ctrl + B 切换粗体
Ctrl + I 切换斜体
Ctrl + Shift + ] 提升标题
Ctrl + Shift + [ 降低标题
Ctrl + M 切换公式
Alt + C 勾选或者取消勾选任务列表
Ctrl + Shift + V 切换预览
Ctrl + K V 将预览切换到侧边

小结

快捷键支持并不完全.还是算了.

问题描述

今天在idea中导入一个项目的时候出现了乱码,乱码的原因时因为这个项目的编码是GBK,但是我设置idea的编码为UTF-8
我知道怎么在idea把一个文件从gbk转为utf-8.但是我还不知道怎么快速把转换整个项目得我编码。
倒是可以手动一个文件一个文件的该,但是我懒得手动改.所以我决定写个程序来实现。

需求分析

  • 可以转换一个文件的编码
  • 可以转换整个目录(项目)的编码

实现思路

  • 通过IO流以一种编码方式从源文件中读入,然后以另一种编码写到临时文件中.
  • 然后删除源文件,把临时文件重命名为源文件即可。

编码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
package args.java.file;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

/**
* 项目编码转换器,可以把一个目录下的所有文件从一个编码(如GBK)转换成另一个编码(如UTF-8).<br>
*/
public class ConvertProjectEncode
{
/**
* 转换整个目录的编码.
* @param dirFile 目录对应的File对象.
* @param fromCharset 原来的文件编码.
* @param toCharset 要转成的编码.
*/
public static void convertDirEncode(File dirFile, String fromCharset,
String toCharset)
{
File[] dirFileList = dirFile.listFiles();
// 遍历整个目录列表
for (int i = 0; i < dirFileList.length; i++)
{
// 如果是目录
if (dirFileList[i].isDirectory())
{
// 递归处理下一级目录
convertDirEncode(dirFileList[i], fromCharset, toCharset);
}
// 如果是文件
else if (dirFileList[i].isFile())
{
// 转换文件的编码
convertFileEncode(dirFileList[i], fromCharset, toCharset);
}
}
}

/**
* 转换一个文件的编码.
* @param file
* @param fromCharset
* @param toCharset
*/
public static void convertFileEncode(File file, String fromCharset,
String toCharset)
{
// 生成临时文件
File tempFile = createTempFile(file);
// 把源文件复制到临时文件
copyToTempFileByNewEncode(file, fromCharset, tempFile, toCharset);
// 删除源文件,并把临时文件重名为源文件
if (file.delete() && tempFile.renameTo(file))
{
System.out.println("文件:" + file + "由 " + fromCharset + " 转为 "
+ toCharset + " 成功!");
}
}

/**
* 从源文件以fromCharset编码读取,以toCharset编码写入临时文件.
* @param file
* @param fromCharset
* @param toCharset
* @param tempFile
*/
public static void copyToTempFileByNewEncode(File file, String fromCharset,
File tempFile, String toCharset)
{
char[] cbuf = new char[1024];
// 读入文件缓存
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(new FileInputStream(file), fromCharset));

BufferedWriter writer = new BufferedWriter(
new OutputStreamWriter(new FileOutputStream(tempFile),
toCharset));)
{

int size = -1;
// 从源文件中读出
while ((size = reader.read(cbuf)) != -1)
{
// 写入临时文件
writer.write(cbuf, 0, size);
}

} catch (UnsupportedEncodingException e)
{
e.printStackTrace();
} catch (FileNotFoundException e)
{
e.printStackTrace();
} catch (IOException e)
{
e.printStackTrace();
}
}
/**
* 创建一个文件的副本.
* @param file
*/
private static File createTempFile(File file)
{
// 源文件名
String fileName = file.getName();
// 临时文件名
int lastIndexOfDot = fileName.lastIndexOf(".");
String tempFileName = fileName.substring(0, lastIndexOfDot) + "_Temp"
+ fileName.substring(lastIndexOfDot);
File tempFile = new File(file.getParent(), tempFileName);
return tempFile;
}
/**
* 把gbk编码的目录或者文件转换为utf-8编码的.
* @param file
*/
public static void gbkToUtf8(File file)
{
if (file.isDirectory())
{
convertDirEncode(file, "gbk", "utf-8");
} else if (file.isFile())
{
convertFileEncode(file, "gbk", "utf-8");
}
}
/**
* 把utf-8编码的目录或者文件转换为gbk编码的.
* @param file
*/
public static void utf8ToGbk(File file)
{
if (file.isDirectory())
{
convertDirEncode(file, "utf-8", "gbk");
} else if (file.isFile())
{
convertFileEncode(file, "utf-8", "gbk");
}
}
public static void main(String[] args)
{
File file = new File("G:\\Desktop\\测试编码转换\\");
// gbkToUtf8(file);
utf8ToGbk(file);
}

}

原文链接

https://blog.csdn.net/shahuhu000/article/details/83965642#commentBox

问题描述

最近发现使用git clone的速度比较慢,于是找到了办法分享给大家:

分析原因

git clone特别慢是因为github.global.ssl.fastly.net域名被限制了。只要找到这个域名对应的ip地址,然后在hosts文件中加上ip 域名的映射,刷新DNS缓存便可。

解决方案

查找域名对应IP地址

在网站https://www.ipaddress.com/分别搜索:

1
2
github.global.ssl.fastly.net
github.com

得到域名对应的IP地址如下:

Name Type Data
github.global.ssl.fastly.net A 151.101.185.194
Name Type Data
github.com A 192.30.253.112
github.com A 192.30.253.113

添加IP和域名到hosts文件

打开hosts文件:

  • Windows上的hosts文件路径在C:\Windows\System32\drivers\etc\hosts
  • Linux上的hosts文件路径在:sudo vim /etc/hosts

hosts文件末尾添加IP地址和对应的域名,以空格隔开,如下所示:

1
2
192.30.253.112 github.com
151.101.185.194 github.global.ssl.fastly.net

保存更新DNS

  • Winodws上的做法:打开CMD,输入ipconfig /flushdns
  • Linux上的做法:在终端输入sudo /etc/init.d/networking restart

测试git clone

github.com有两个IP地址:192.30.253.112192.30.253.113,哪个快就用哪个,我这里测试得到192.30.253.112稍微快点.

idea 2019.2导出可执行Jar

项目结构

实例项目结构如下,现在我想导出module01中的Test类.
这里有一张图片

导出可执行jar步骤

导出可执行jar需要的设置

打开Project Structure

依次点击File->Project Structure打开Project Structure对话框:
这里有一张图片
这里有一张图片

打开Create jar from modules对话框

然后依次点击:Artifacts->加号->JAR->From modules with dependencies...打开Create jar from modules对话框
这里有一张图片

选择模块 选择主类

  1. Module选择框中选择要导出的模块,
  2. Main Class选择框中选择要主类.
  3. 其他的默认,然后点击OK即可.
    这里有一张图片
  4. 继续点击OK:
    这里有一张图片

这时候会在模块根目录下生成一个MANIFEST.ME文件,如下所示:
这里有一张图片

生成可执行Jar

点击Build->Build artifacts...
这里有一张图片
然后在弹出的对话框中选择Build:
这里有一张图片

运行可执行jar

最后会在out目录下的artifacts目录下生成jar文件,如下所示:
这里有一张图片
打开jar文件所在的目录,然后在该目录下打开cmd,使用java -jar xxxx.jar命令运行该jar包:
这里有一张图片
运行效果如下所示:
这里有一张图片

idea快捷键

idea向上/向下插入空行

注意下面的快捷不是默认的快捷键,我已经修改过了,所以我给出了快捷键对应的功能的英文名称,可以根据功能名查找对应的快捷键,然后自己修改即可.

功能 描述 快捷
Start New Line Before Current 向上插入空行 ctrl+alt+enter
Start New Line 向下插入空行 shift+enter
Reformat Code 格式化代码 Ctrl+Alt+L
Duplicate Entire Lines 复制向下复制一行代码 Ctrl+向下箭头
Move Line Up 移动代码到上一行 alt+向上箭头
Move Line down 移动代码到下一行 alt+向下箭头
Expand 展开代码 ctrl+加号
Collapse 折叠代码 ctrl+减号
Select Opposite Diff Pane 向前切换窗口 ctrl+tab,如果打开了多个代码可以通过,通过上下箭头选择
Select Position In Opposite Diff Pane 向后切换窗口 shift+ctrl+tab

idea中使用eclipse快捷键

功能 描述 快捷键
Delete Line 删除一行 ctrl+d

批处理 命令返回值

批处理命令的返回值会保存在errorlevel变量中。一般而言:

  • 如果命令执行成功,则返回0
  • 如果命令执行失败,则返回1

批处理 延时命令

前言

因为我偶尔要在浏览器上看些视频,而播放视频有时候需要Flash,但是要命的是Flash带广告插件,经过我的排查,我发现广告是FlashHelperService.exe这个服务造成的,可以通过如下命令杀死这个进程:

1
taskkill /im FlashHelperService.exe /f

但是还是没有用,因为不知道什么时候FlashHelperService.exe这个服务又会偷偷运行,我需要反复杀进程,一两次还可以,多了真是烦躁.
于是我想着写个批处理脚本来定时杀进程

timeout命令

timeout是延时等待命令,该命令帮助文档如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
timeout [/t] timeout [/nobreak] 
描述:
这个工具接受超时参数,等候一段指定的时间(秒)或等按任意键。它还接受
一个参数,忽视按键。
参数列表:
/t timeout 指定等候的秒数。有效范围从 -199999 秒。
/nobreak 忽略按键并等待指定的时间。
/? 显示此帮助消息。
注意: 超时值 -1 表示无限期地等待按键。
示例:
timeout /?
timeout /t 10
timeout /t 300 /nobreak
timeout /t -1

从帮助文档可以看出:timeout /t 10就是延迟10秒的意思.

定时杀死进程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@echo off
:again
:: 查找FlashHelperService.exe这个进程
tasklist | findstr /i FlashHelperService.exe
:: 如果返回值大于或者等于1
IF ERRORLEVEL 1 (
:: 返回值大于0表示上述命令失败,也就是找不到FlashHelperService.exe这个进程
echo ERRORLEVEL=%errorlevel%,找不到FlashHelperService.exe进程
) ELSE (
:: 返回值为0表示上述命令成功,也就是找到FlashHelperService.exe这个进程
echo ERRORLEVEL=%errorlevel%,找到FlashHelperService.exe进程
echo 杀死这个该死的进程.%date%%time%>>杀死FlashHelp日志.txt
:: 打开日志,让我知道
notepad 杀死FlashHelp日志.txt
taskkill /im FlashHelperService.exe /f
)
:sleep
:: 延时60*15=5400秒,也就是15分钟运行一次.
timeout /t 5400
:: 清屏
cls
:: 循环继续开始
goto again