在办公软件WPS的JSA中模拟键盘输入

cutebe · 发表于 2026-4-26 23:12:03

办公软件WPS的表格：通过ExecuteExcel4Macro调用WinAPI实现

测试与调用函数： //打开记事本，输入内容

function 找到记事本窗口键盘输入测试(){ //记事本编辑框中输入内容
console.clear();
const 执行宏调用=ExecuteExcel4Macro;
let 记事本类="Notepad"; //找到那个打开的记事本窗口
var 记事本句柄=执行宏调用(`CALL("User32","FindWindowA","JFJ","${记事本类}",0)`);
console.log("记事本句柄："+记事本句柄);
if(!记事本句柄){
let 记事本进程句柄=执行宏调用(`CALL("Shell32","ShellExecuteA","JJFFJJJ",0,"open","notepad",0,0,1)`);
console.log("记事本进程句柄："+记事本进程句柄);
alert("等待，确定后向记事本写入信息");
记事本句柄=执行宏调用(`CALL("User32","FindWindowA","JFJ","${记事本类}",0)`);
console.log("记事本句柄："+记事本句柄);
}
执行宏调用(`CALL("User32","SetForegroundWindow","JJ",${记事本句柄})`); //前置
let 字符串="BatHome.Net"; //批处理之家论坛网址，作为填写内容
let 字符数组=字符串.split(''),按键数组=[];
for(let i=0;i<字符串.length;i++){
var 字符=字符数组[i];
if(字符>='a' && 字符<='z'){字符=字符.toUpperCase();}
按键数组[i]=键盘操作对象(字符);
}
操作键盘(按键数组); /*****键盘操作*****/
}
function 操作键盘(操作数组){
let 序号=0,键盘数组=[];
if(Array.isArray(操作数组)){
for(let i=0;i<操作数组.length;i++){
if(Array.isArray(操作数组[i])){
for(let j=0;j<操作数组[i].length;j++){
键盘数组[序号]=操作数组[i][j];序号++;
}
}else{键盘数组[序号]=操作数组[i];序号++;}
}
}else{键盘数组[序号]=操作数组;}
let 操作组数=键盘数组.length;
let 结构字节数=对象字节数(键盘数组[0]); /*****计算结构对象字节数*****/
let 总字节=结构字节数*操作组数;
const 数组缓冲=new ArrayBuffer(总字节); //操作对象数组写入缓冲
for(let i=0;i<操作组数;i++){
结构对象填入数组缓冲(数组缓冲,i*结构字节数,键盘数组[i]); /*****对象转数组缓冲*****/
}
const 执行宏调用=ExecuteExcel4Macro; //申请内存
const 内存地址=执行宏调用(`CALL("Kernel32","VirtualAlloc","JJJJJ",0,${总字节},${0x3000},4)`);
数据写入内存(内存地址,数组缓冲,总字节); /*****写入键盘操作结构*****/ //执行键盘操作
键盘操作结果=执行宏调用(`CALL("User32","SendInput","JJJJ",${操作组数},${内存地址},${结构字节数})`);
if(!键盘操作结果){console.log("错误代码："+执行宏调用(`CALL("Kernel32","GetLastError","I")`));}
执行宏调用(`CALL("Kernel32", "VirtualFree", "JJJJ", ${内存地址}, 0, ${0x8000})`); //释放内存
}
function 键盘操作对象(键码){
class 键盘操作 { //类
constructor(按键,动作){ //类的构造方法，用于构造属性
this.输入类型1 = [4,1], //键盘1 //字节数，数据
this.虚拟键码2 = [4,按键], //同ASCII码
this.键扫描码3 = [4,0],
this.输入操作4 = [4,动作], //按键弹起2 启用扫描码8
this.时间戳值5 = [4,0], //系统确定
this.扩展信息6 = [4,0],
this.数据填充0 = [4,0] //都是4*7=28字节，不足部分补足
}
};
if(键码>='A'&&键码<='Z'){键码=键码.charCodeAt(0);}
if(键码=='.'){键码=0xBE;}
let 键盘对象 = new 键盘操作(键码,4|2); //统一码0x4|2键弹起
return 键盘对象;
}
function 对象字节数(结构对象){
let 对象数据字节数=0;
for (let 属性名 in 结构对象) {
if (结构对象.hasOwnProperty(属性名)) {
对象数据字节数+=结构对象[属性名][0]; //累加字节数
}
}
return 对象数据字节数;
}
function 结构对象填入数组缓冲(数组缓冲,偏移,结构对象){
const 数据操作=new DataView(数组缓冲);
let 字节数,待填数据;
for (let 属性名 in 结构对象) {
if (结构对象.hasOwnProperty(属性名)) {
字节数=结构对象[属性名][0],待填数据=结构对象[属性名][1];
if(字节数==4){数据操作.setInt32(偏移,待填数据,true);} //小端序
else{if(字节数==2){数据操作.setInt32(偏移,待填数据,true);}
else{if(字节数==1){数据操作.setInt32(偏移,待填数据,true);}}}
偏移+=字节数;
}
}
}
function 数据写入内存(内存地址,数组缓冲,字节数){
const 数据操作=new DataView(数组缓冲);
let 偏移=i=0,待写数据=[],写入字节=[];
while(字节数>偏移){
if(字节数-偏移>=4){待写数据[i]=数据操作.getInt32(偏移,true);写入字节[i]=4;i++;偏移+=4;}
else{if(字节数-偏移>=2){待写数据[i]=数据操作.getInt16(偏移,true);写入字节[i]=2;i++;偏移+=2;}
else{if(字节数-偏移==1){待写数据[i]=数据操作.getInt8(偏移,true);写入字节[i]=1;i++;偏移++;}}}
}
const 执行宏调用=ExecuteExcel4Macro;
for(偏移=i=0;i<写入字节.length;i++){ //写入
执行宏调用(`CALL("Kernel32","RtlMoveMemory","2JNJ",${内存地址+偏移},${待写数据[i]},${写入字节[i]})`);
偏移+=写入字节[i];
}
}

复制代码

cutebe · 发表于 2026-4-27 11:15:07

通过SendMessage向文本编辑区填入内容：

function 记事本窗口发送文本测试(){ //记事本编辑框中内容
console.clear();
const 执行宏调用=ExecuteExcel4Macro;
//找到打开的记事本窗口，没有则打开一个新记事本
let 记事本类="Notepad";
var 记事本句柄=执行宏调用(`CALL("User32","FindWindowA","JFJ","${记事本类}",0)`);
console.log("记事本句柄："+记事本句柄);
if(!记事本句柄){
let 记事本进程句柄=执行宏调用(`CALL("Shell32","ShellExecuteA","JJFFJJJ",0,"open","notepad",0,0,1)`);
console.log("记事本进程句柄："+记事本进程句柄);
alert("等待，确定后向记事本写入信息"); //弹窗提示
记事本句柄=执行宏调用(`CALL("User32","FindWindowA","JFJ","${记事本类}",0)`);
console.log("记事本句柄："+记事本句柄);
}
执行宏调用(`CALL("User32","SetForegroundWindow","JJ",${记事本句柄})`); //前置
//定位到记事本的编辑输入区
let 编辑框类="Edit";
let 编辑框句柄=执行宏调用(`CALL("User32","FindWindowExA","JJJFJ",${记事本句柄},0,"${编辑框类}",0)`);
//通过发送消息，向记事本写入文本
let 设置文本=0xC,字符串="BatHome.Net"; //批处理之家论坛网址，作为内容
var 设置文本框内容=执行宏调用(`CALL("User32", "SendMessageA", "JJJJF", ${编辑框句柄},${设置文本},0,"${字符串}")`);
}

复制代码

cutebe · 发表于 2026-5-3 11:11:31

截取全屏和当前窗口函数：

function 截取全屏测试(){ //截屏键PrintScreen
let 按下=0,扩展=1,松开=2;
let 截屏键码=0x2C,截屏扫描码=0x37;
键盘事件(截屏键码,截屏扫描码,按下|扩展); //按下PrintScreen
键盘事件(截屏键码,截屏扫描码,松开|扩展); //松开PrintScreen
}
function 截屏当前窗口测试(){ //当前窗口 Alt + PrintScreen
let 按下=0,扩展=1,松开=2; //Alt0x12,左Alt0xA4
let 修改键码=0x12,截屏键码=0x2C,截屏扫描码=0x37;
键盘事件(修改键码,0,按下); //按下Alt
键盘事件(截屏键码,截屏扫描码,按下|扩展); //按下PrintScreen
键盘事件(截屏键码,截屏扫描码,松开|扩展); //松开PrintScreen
键盘事件(修改键码,0,松开); //松开Alt
}
function 键盘事件(虚拟键码,扫描键码,键标志){
const 执行宏调用=ExecuteExcel4Macro; //扫描码只需要低位，高位0xE0省略 //扩展键才用扫描码
执行宏调用(`CALL("User32","keybd_event","JJJJJ",${虚拟键码},${扫描键码},${键标志},0)`);
}

复制代码

cutebe · 发表于 2026-5-3 11:16:52

打开运行对话框：Win + R

function 打开运行对话框键盘测试(){ //快捷键 Win + R
let 按下=0,扩展=1,松开=2;
//键盘事件(虚拟键码,扫描键码,键标志);
let 左窗口=0x5B,运行=0x52;
键盘事件(左窗口,左窗口,按下|扩展); //按下LWin
键盘事件(运行,0,按下); //按下R
键盘事件(运行,0,松开); //松开R
键盘事件(左窗口,左窗口,松开|扩展); //松开LWin //合成 LWin + R 运行
}
function 键盘事件(虚拟键码,扫描键码,键标志){
const 执行宏调用=ExecuteExcel4Macro; //扫描码只需要低位，高位0xE0省略 //扩展键才用扫描码
执行宏调用(`CALL("User32","keybd_event","JJJJJ",${虚拟键码},${扫描键码},${键标志},0)`);
}

复制代码

cutebe · 发表于 2026-5-3 11:19:36

function 关闭数字灯(){
let 数字键码=0x90;
let 数字灯状态=获取按键状态(数字键码); //关闭0
if(数字灯状态){
let 数字扫描码=0x45,按下=0,扩展=1,松开=2;
键盘事件(数字键码,数字扫描码,按下|扩展); //按下NumLock
键盘事件(数字键码,数字扫描码,松开|扩展); //松开NumLock
}
}
function 打开数字灯(){
let 数字键码=0x90;
let 数字灯状态=获取按键状态(数字键码); //打开1
if(!数字灯状态){
let 数字扫描码=0x45,按下=0,扩展=1,松开=2;
键盘事件(数字键码,数字扫描码,按下|扩展); //按下NumLock
键盘事件(数字键码,数字扫描码,松开|扩展); //松开NumLock
}
}
function 获取按键状态(键盘码){
const 执行宏调用=ExecuteExcel4Macro;
let 状态=执行宏调用(`CALL("User32","GetKeyState","IJ",${键盘码})`);
return 状态;
}
function 键盘事件(虚拟键码,扫描键码,键标志){
const 执行宏调用=ExecuteExcel4Macro; //扫描码只需要低位，高位0xE0省略 //扩展键才用扫描码
执行宏调用(`CALL("User32","keybd_event","JJJJJ",${虚拟键码},${扫描键码},${键标志},0)`);
}

复制代码

cutebe · 发表于 2026-5-3 11:58:52

本帖最后由 cutebe 于 2026-5-3 12:00 编辑

function 显示桌面键盘测试(){ //快捷键 Win + D
let 按下=0,扩展=1,松开=2;
let 左窗口=0x5B,按键D='D'.charCodeAt();
键盘事件(左窗口,左窗口,按下|扩展); //按下LWin
键盘事件(按键D,0,按下); //按下D
键盘事件(按键D,0,松开); //松开D
键盘事件(左窗口,左窗口,松开|扩展); //松开LWin //合成 LWin + D
}
function 键盘事件(虚拟键码,扫描键码,键标志){
const 执行宏调用=ExecuteExcel4Macro; //扫描码只需要低位，高位0xE0省略 //扩展键才用扫描码
执行宏调用(`CALL("User32","keybd_event","JJJJJ",${虚拟键码},${扫描键码},${键标志},0)`);
}

复制代码

扩展按键	虚拟键码	扫描码	说明
----- -----	-----	-----	-----
系统关机		0xE05E
系统睡眠		0xE05F
系统唤醒		0xE063

键盘 PrintScreen 键	0x2C	0xE037
键盘 Pause 键	0x13	0xE046
键盘 Insert 键	0x2D	0xE052
键盘 Home 键	0x24	0xE047
键盘 PageUp 键	0x21	0xE049
键盘 Delete 键	0x2E	0xE053
键盘 End 键	0x23	0xE04F
键盘 PageDown 键	0x22	0xE051
键盘向右→键	0x27	0xE04D
键盘向左←键	0x25	0xE04B
键盘向下↓键	0x28	0xE050
键盘向上↑键	0x26	0xE048
小键盘 Num Lock 键	0x90	0xE045
小键盘 /	0x6F	0xE035
小键盘 ENTER 键	无	0xE01C
键盘应用程序键	0x5D	0xE05D	菜单键VK_APPS，在右Win和右Ctrl之间
键盘电源键	无	0xE05E
键盘左Win 键	0x5B	0xE05B
键盘右Ctrl 键	0xA3	0xE01D	VK_RCONTROL
键盘右Alt 键	0xA5	0xE038	VK_RMENU
键盘右Win 键	0x5C	0xE05C

扫描下一个曲目		0xE019
扫描上一个曲目		0xE010
停止		0xE024
播放/暂停		0xE022
静音		0xE020
音量增大		0xE030
音量减小		0xE02E
AL 使用者控制配置		0xE06D
AL 电子邮件阅读器		0xE06C
AL 计算器		0xE021
AL 本地计算机浏览器		0xE06B
AC 搜索		0xE065
AC 主页		0xE032
AC 返回		0xE06A
AC 向前		0xE069
AC 停止		0xE068
AC 刷新		0xE067
AC 书签		0xE066

cutebe · 发表于 2026-5-3 23:40:55

function 文字模拟数字按键输入测试(){
let 我=52946,爱=45230,你=50403;
let C=0x43,N=0x4E;
let 输出字符串=[我,爱,你,C,N];
for(let i=0;i<输出字符串.length;i++){
组合数码键入对应文字(输出字符串[i]);
}
//光标放在此处：
}
function 组合数码键入对应文字(数字码){ //数字码为内码
let 数字串=数字码.toString(); //转数字字符串
let 按下=0,松开=2,长修码=0x12;
键盘事件(长修码,0,按下); //按下键Alt
for(let i=0;i<数字串.length;i++){
let 数字=数字串[i];
let 小键盘数字码=0x30+数字.charCodeAt(0);
let 小键盘数字扫描码=按键码转扫描码(小键盘数字码);
键盘事件(小键盘数字码,小键盘数字扫描码,按下);
键盘事件(小键盘数字码,小键盘数字扫描码,松开);
}
键盘事件(长修码,0,松开); //松开键Alt
}
function 键盘事件(虚拟键码,扫描键码,键标志){
const 执行宏调用=ExecuteExcel4Macro; //扫描码只需要低位，高位0xE0省略 //扩展键小键盘数字会用到扫描码
执行宏调用(`CALL("User32","keybd_event","JJJJJ",${虚拟键码},${扫描键码},${键标志},0)`);
}
function 按键码转扫描码(按键码){ //返回扫描码
const 执行宏调用=ExecuteExcel4Macro;
let 扫描码=执行宏调用(`CALL("User32","MapVirtualKeyA","JJJ",${按键码},0)`);
return 扫描码;
}

复制代码

cutebe · 发表于 2026-5-4 16:59:21

批处理：Alt+50682，Alt+46246，Alt+49389

function 记事本窗口模拟键盘输入文本测试(){ //记事本编辑框中内容
console.clear();
const 执行宏调用=ExecuteExcel4Macro;
//找到打开的记事本窗口，没有则打开一个新记事本
let 记事本类="Notepad";
var 记事本句柄=执行宏调用(`CALL("User32","FindWindowA","JFJ","${记事本类}",0)`);
console.log("记事本句柄："+记事本句柄);
if(!记事本句柄){
let 记事本进程句柄=执行宏调用(`CALL("Shell32","ShellExecuteA","JJFFJJJ",0,"open","notepad",0,0,1)`);
console.log("记事本进程句柄："+记事本进程句柄);
alert("等待，确定后向记事本写入信息"); //弹窗提示
记事本句柄=执行宏调用(`CALL("User32","FindWindowA","JFJ","${记事本类}",0)`);
console.log("记事本句柄："+记事本句柄);
}
//字符串写入内存，再按数据方式读取出来（即内码）
字符串="批处理之家 BatHome.Net";
let 内存句柄=字符串到内存(字符串); //===写字符串===//
let 读出字符串=内存取字符串(内存句柄);
console.log(读出字符串);
let 数据数组缓冲=内存取数据(内存句柄); //===读取数据===//
显示数组缓冲(数据数组缓冲); //===显示数据===//
执行宏调用(`CALL("Kernel32","GlobalFree","JJ",${内存句柄})`); //释放内存
let 文字内码=数组缓冲转文字内码数组(数据数组缓冲);
console.log("文字内码数组："+文字内码);
//模拟键盘按键，向记事本写入文本
执行宏调用(`CALL("User32","SetForegroundWindow","JJ",${记事本句柄})`); //前置记事本窗口
for(let i=0;i<文字内码.length;i++){
组合数码键入对应文字(文字内码[i]);
} //光标放在此处：
}
function 数组缓冲转文字内码数组(数组缓冲){ //返回数组
const 总字节=数组缓冲.byteLength;
const 数据操作=new DataView(数组缓冲);
let 偏移=0,文字内码=[];
while(偏移<总字节){
var 文字数码=数据操作.getUint8(偏移,true),偏移增量=1;
if(!文字数码){break;}
else{if(文字数码>0x80){文字数码=数据操作.getUint16(偏移),偏移增量=2;}}
文字内码.push(文字数码);
偏移+=偏移增量;
}
return 文字内码;
}
function 组合数码键入对应文字(数字码){ //数字码为内码
let 数字串=数字码.toString(); //转数字字符串
let 按下=0,松开=2,长修码=0x12;
键盘事件(长修码,0,按下); //按下键Alt
for(let i=0;i<数字串.length;i++){
let 数字=数字串[i];
let 小键盘数字码=0x30+数字.charCodeAt(0);
let 小键盘数字扫描码=按键码转扫描码(小键盘数字码);
键盘事件(小键盘数字码,小键盘数字扫描码,按下);
键盘事件(小键盘数字码,小键盘数字扫描码,松开);
}
键盘事件(长修码,0,松开); //松开键Alt
}
function 键盘事件(虚拟键码,扫描键码,键标志){
const 执行宏调用=ExecuteExcel4Macro; //扩展时扫描码只需要低位，高位0xE0省略 //扩展键小键盘数字会用到扫描码
执行宏调用(`CALL("User32","keybd_event","JJJJJ",${虚拟键码},${扫描键码},${键标志},0)`);
}
function 按键码转扫描码(按键码){ //返回扫描码
const 执行宏调用=ExecuteExcel4Macro;
let 扫描码=执行宏调用(`CALL("User32","MapVirtualKeyA","JJJ",${按键码},0)`);
return 扫描码;
}
function 字符串到内存(字符串){ //返回内存句柄
const 执行宏调用=ExecuteExcel4Macro;
let 分段文本=[],分段字节=[],总字节=0,段长度=127; //可申请256字节内存，结束符1字节，汉字最长127
for(let 起始=i=0;起始<字符串.length;起始+=段长度,i++){
分段文本.push(字符串.slice(起始,起始+段长度));
分段字节.push(分段文本[i].replace(/[^\x00-\xff]/g,'xx').length); //一个汉字占两个字节
总字节+=分段字节[i];
} //分配内存 //分配GlobalAlloc对应销毁GlobalFree //分配GlobalAlloc对应销毁GlobalFree
const 内存句柄=执行宏调用(`CALL("Kernel32","GlobalAlloc","JJJ",${0x42},${总字节+1})`);
if(内存句柄){ //内存分配成功，然后锁写解内存。 //锁定全局内存对象，会返回其内存地址
const 内存地址=执行宏调用(`CALL("Kernel32","GlobalLock","JJ",${内存句柄})`);
for(let 偏移字节=i=0;i<分段文本.length;i++){ //字符串（JS变量）分批复制到刚申请的内存中。分批是因为有限长
执行宏调用(`CALL("Kernel32","lstrcpynW","JJFJ",${内存地址+偏移字节},"${分段文本[i].replace(/\"/g,'\"\"')}",${分段字节[i]})`);
偏移字节+=分段字节[i]; //返回地址J。 //字符串两个双引号解释成一个
}
执行宏调用(`CALL("Kernel32","GlobalUnlock","JJ",${内存句柄})`); //解锁全局内存对象，以释放资源
return 内存句柄;
}else{console.log("未能分配内存！");}
}
function 内存取字符串(内存句柄){ //返回字符串
const 执行宏调用=ExecuteExcel4Macro,段长度=127;
const 内存地址=执行宏调用(`CALL("Kernel32","GlobalLock","JJ",${内存句柄})`); //锁定，获取内存地址
if(内存地址){
const 总字节=执行宏调用(`CALL("Kernel32","lstrlenA","JJ",${内存地址})`); //内存文本字节数
let 偏移字节=0,文本字符串=分段文本='';
while(偏移字节<总字节){ //返回字符串F。 //返回超255字节时，也需要分段操作
分段文本=执行宏调用(`CALL("Kernel32","lstrcpynW","FFJJ","",${内存地址+偏移字节},${段长度})`);
//偏移字节+=分段文本.replace(/[^\x00-\xff]/g,'xx').length; //计算字符串字节数
偏移字节+=执行宏调用(`LENB("${分段文本.replace(/"/g,'x')}")`);
文本字符串+=分段文本;
} //解锁全局内存对象，以释放资源
执行宏调用(`CALL("Kernel32","GlobalUnlock","JJ",${内存句柄})`);
return 文本字符串;
}else{console.log("未找到内存地址！");}
}
function 内存取数据(内存句柄){ //返回数组缓冲
const 执行宏调用=ExecuteExcel4Macro;
const 总字节=执行宏调用(`CALL("Kernel32","GlobalSize","JJ",${内存句柄})`); //内存对象空间大小
let 偏移,i,读取字节=[],读出数据;
for(偏移=i=0;偏移<总字节;i++){
if(总字节-偏移>=4){读取字节[i]=4;偏移+=4;}
else{if(总字节-偏移>=2){读取字节[i]=2;偏移+=2;}
else{if(总字节-偏移==1){读取字节[i]=1;偏移++;}}}
}
const 数组缓冲=new ArrayBuffer(总字节); //用于存储读出的数据
const 数据操作=new DataView(数组缓冲);
const 内存地址=执行宏调用(`CALL("Kernel32","GlobalLock","JJ",${内存句柄})`);
if(内存地址){ //var 文本=执行宏调用(`CALL("Kernel32","lstrcpynW","FFJJ","",${内存地址},${127})`);
for(偏移=i=0;偏移<总字节;i++){ //库Kernel32.dll和NtDll.dll里都有RtlMoveMemory
读出数据=执行宏调用(`CALL("Kernel32","RtlMoveMemory","1NJJ",${内存地址},${内存地址+偏移},${读取字节[i]})`); //读出
if(读取字节[i]==4){数据操作.setInt32(偏移,读出数据,true);偏移+=4;}
else{if(读取字节[i]==2){数据操作.setInt16(偏移,读出数据,true);偏移+=2;}
else{if(读取字节[i]==1){数据操作.setInt8(偏移,读出数据,true);偏移++;}}}
}
执行宏调用(`CALL("Kernel32","GlobalUnlock","JJ",${内存句柄})`); //解锁内存对象，以释放资源
return 数组缓冲; //返回
}else{console.log("未找到内存地址！");}
}
function 显示数组缓冲(数组缓冲){
const 数据操作=new DataView(数组缓冲);
var 字节数码串=[],字符串=[],行号,四分隔,八分隔;
for(let 偏移=0;偏移<数组缓冲.byteLength;偏移++){
var 字节数码=数据操作.getInt8(偏移);
行号=Math.floor(偏移/16);
if((偏移+1)%4){四分隔=''}else{四分隔=' '};
if((偏移+1)%8){八分隔=''}else{八分隔=' '};
if(typeof 字节数码串[行号]=="undefined"){字节数码串[行号]=''}
var 字节高位=(字节数码>>>4&0xF).toString(16).toUpperCase(),字节低位=(字节数码&0xF).toString(16).toUpperCase();
字节数码串[行号]+=字节高位+字节低位+" "+四分隔+八分隔;
if(typeof 字符串[行号]=="undefined"){字符串[行号]=''}
if(字节数码){字符串[行号]+=String.fromCharCode(字节数码);}else{字符串[行号]+=' ';}
}
for(let 行号=0;行号<字节数码串.length;行号++){
var 十六进制行号=('000'+(行号<<4).toString(16)).slice(-4).toUpperCase();
console.log(十六进制行号+"："+字节数码串[行号]+"\t["+字符串[行号]+"]");
}
}

复制代码

cutebe · 发表于 5 小时前

function 超量多码(){
console.clear();
var 剪贴板文本=获取剪贴板文本(); //编辑取自剪贴板
var 数字串=剪贴板文本.replace(/[^\d^,]+/g,','); //非数字替换成分隔符
var 数串数组=数字串.split(','),除重对象={},数码="",计数=0; //数组：六位除重
for(var 序号=0;序号<数串数组.length;序号++){
if(数串数组[序号].length==6 && typeof 除重对象[数串数组[序号]]=='undefined'){
除重对象[数串数组[序号]]=1;计数++;数码+=数串数组[序号]+',';
}
}
console.log("编码："+数码); //数码即编码数组。
if(数码=='' || 数码==','){alert("编码为空！退出……");return;} //空串，即没有编码
let 标题="多品种商品选择",类="FNWNS3100";
let 选择窗口句柄=查找窗口(标题,类);
if(!选择窗口句柄){alert("未找到超量多码输入窗口，退出！");return;}
let 自身窗口句柄=获取活动窗口句柄(); //最小化自身，方便输入编码
窗口最小化(自身窗口句柄);
前置窗口(选择窗口句柄);延时(300);
let 添加按钮标题='添加(&A)',按钮类='Button';
let 添加按钮句柄=下一个子窗口(选择窗口句柄,0,添加按钮标题,0);
let 按钮范围=获取窗口范围(添加按钮句柄);
var 按钮水平=按钮范围[0],按钮垂直=按钮范围[1];
let 编码框中水平=按钮水平-136,编码框中垂直=按钮垂直+12; //添加按钮相对编码框距离
设置鼠标位置(编码框中水平,编码框中垂直);
鼠标点击(); //光标定位编码框中
let 编码组=数码.split(',');
for(let i=0;i<编码组.length;i++){
if(编码组[i]!=""){
模拟键盘输入编码(编码组[i]); //输入编码
模拟键盘回车(); //回车确定
延时(800); //处理弹出对话框或窗口：一、已存在；二、错误；三、不全需要选择。
let 错误对话框句柄=查找对话框窗口("错误"); //输入编码不存在
if(错误对话框句柄){延时(200);
let 确定按钮=下一个子窗口(错误对话框句柄,0,"确定",0);
发送点击按钮消息(确定按钮);
}
let 提示对话框句柄=查找对话框窗口("提示"); //重复，编码已在列表中
if(提示对话框句柄){延时(200);
let 确定按钮=下一个子窗口(提示对话框句柄,0,"确定",0);
发送点击按钮消息(确定按钮);
} //还有一个列表选择窗未处理
}
}
延时(300); //恢复窗口显示
let 恢复结果=恢复窗口(自身窗口句柄);
}
function 获取剪贴板文本(){ //返回字符串
let 内存地址,剪贴板文本="",执行宏调用=ExecuteExcel4Macro;
if(执行宏调用(`CALL("user32.dll","OpenClipboard","JJ",0)`)){ //打开剪贴板
const 内存句柄=执行宏调用(`CALL("user32.dll","GetClipboardData","JJ",1)`); //获取剪贴板文本，返回句柄。
if(内存句柄){ //锁定全局内存对象，获取内存地址
内存地址=执行宏调用(`CALL("kernel32.dll","GlobalLock","JJ",${内存句柄})`);
let 总字节,偏移字节=0,段长度=127,分段文本='';
总字节=执行宏调用(`CALL("Kernel32","lstrlenA","JJ",${内存地址})`); //剪贴板文本字节数
while(偏移字节<总字节){ //返回字符串F。返回值超255字节时，也需要分段操作
分段文本=执行宏调用(`CALL("Kernel32","lstrcpynW","FFJJ","",${内存地址+偏移字节},${段长度})`);
偏移字节+=分段文本.replace(/[^\x00-\xff]/g,'xx').length; //计算分段文本字节数
剪贴板文本+=分段文本;
}
执行宏调用(`CALL("kernel32.dll","GlobalUnlock","JJ",${内存句柄})`); //解锁
}else{console.log("未能获取剪贴板数据的内存句柄！");}
执行宏调用(`CALL("user32.dll","CloseClipboard","J")`); //关闭剪贴板，让其它应用可以使用剪贴板
return 剪贴板文本; //返回字符串
}else{alert('无法打开剪贴板！');}
}
function 查找窗口(标题,类){ //返回句柄
const 执行宏调用=ExecuteExcel4Macro;
var 窗口句柄;
if(!标题){ //标题为0
if(!类){ 窗口句柄=执行宏调用(`CALL("User32","FindWindowA","JJJ",0,0)`); //类为0
}else{ 窗口句柄=执行宏调用(`CALL("User32","FindWindowA","JFJ","${类}",0)`);}
}else{
if(!类){ 窗口句柄=执行宏调用(`CALL("User32","FindWindowA","JJF",0,"${标题}")`); //类为0
}else{ 窗口句柄=执行宏调用(`CALL("User32","FindWindowA","JFF","${类}","${标题}")`);}
}
return 窗口句柄;
}
function 获取活动窗口句柄(){ //进程所在自身窗口
const 执行宏调用=ExecuteExcel4Macro;
let 自身窗口句柄=执行宏调用(`CALL("User32","GetActiveWindow","J")`);
return 自身窗口句柄;
}
function 前置窗口(窗口句柄){
const 执行宏调用=ExecuteExcel4Macro;
let 前置结果=执行宏调用(`CALL("User32","SetForegroundWindow","JJ",${窗口句柄})`);
return 前置结果;
}
function 窗口最小化(窗口句柄){let 激活最小化=2;return 显示窗口(窗口句柄,激活最小化);}
function 恢复窗口(窗口句柄){let 恢复=9;return 显示窗口(窗口句柄,恢复);}
function 显示窗口(窗口句柄,显示标识){ //普通显示=1,显示=5,激活最小化=2,最小化=6,恢复=9;
const 执行宏调用=ExecuteExcel4Macro;
let 显示结果=执行宏调用(`CALL("User32","ShowWindow","AJJ",${窗口句柄},${显示标识})`);
return 显示结果;
}
function 延时(毫秒数){
const 执行宏调用=ExecuteExcel4Macro;
执行宏调用(`CALL("Kernel32","Sleep","JJ",${毫秒数})`);
}
function 下一个子窗口(父句柄,上个子句柄,标题,类){
const 执行宏调用=ExecuteExcel4Macro;
var 子句柄;
if(!标题){ //标题为0
if(!类){ 子句柄=执行宏调用(`CALL("User32","FindWindowExA","JJJJJ",${父句柄},${上个子句柄},0,0)`); //类为0
}else{ 子句柄=执行宏调用(`CALL("User32","FindWindowExA","JJJFJ",${父句柄},${上个子句柄},"${类}",0)`);}
}else{
if(!类){ 子句柄=执行宏调用(`CALL("User32","FindWindowExA","JJJJF",${父句柄},${上个子句柄},0,"${标题}")`); //类为0
}else{ 子句柄=执行宏调用(`CALL("User32","FindWindowExA","JJJFF",${父句柄},${上个子句柄},"${类}","${标题}")`);}
}
return 子句柄;
}
function 获取窗口范围(窗口句柄){ //返回坐标数组：左上右下
const 执行宏调用=ExecuteExcel4Macro;
let 内存地址=申请虚拟内存(16); //===申请内存===//
let 结果=执行宏调用(`CALL("User32","GetWindowRect","JJJ",${窗口句柄},${内存地址})`);
let 数组缓冲=内存读取数据(内存地址,16); //===读取数据===/
释放虚拟内存(内存地址); //===释放内存===//
let 坐标数组=缓冲转数组(数组缓冲); //===转数组===//
return 坐标数组;
}
function 申请虚拟内存(字节数){ //返回内存地址
const 执行宏调用=ExecuteExcel4Macro;
const 内存地址=执行宏调用(`CALL("Kernel32","VirtualAlloc","JJJJJ",0,${字节数},${0x3000},4)`);
return 内存地址;
}
function 释放虚拟内存(内存地址){
const 执行宏调用=ExecuteExcel4Macro;
执行宏调用(`CALL("Kernel32","VirtualFree","JJJJ",${内存地址},0,${0x8000})`);
}
function 内存读取数据(内存地址,字节数){ //返回数组缓冲
const 执行宏调用=ExecuteExcel4Macro;
let 偏移,i,读取字节=[],读出数据;
for(偏移=i=0;偏移<字节数;i++){
if(字节数-偏移>=4){读取字节[i]=4;偏移+=4;}
else{if(字节数-偏移>=2){读取字节[i]=2;偏移+=2;}
else{if(字节数-偏移==1){读取字节[i]=1;偏移++;}}}
}
const 数组缓冲=new ArrayBuffer(字节数); //用于存储读出的数据
const 数据操作=new DataView(数组缓冲);
for(偏移=i=0;偏移<字节数;i++){ //库Kernel32.dll和NtDll.dll里都有RtlMoveMemory //读出
读出数据=执行宏调用(`CALL("Kernel32","RtlMoveMemory","1NJJ",${内存地址},${内存地址+偏移},${读取字节[i]})`);
if(读取字节[i]==4){数据操作.setInt32(偏移,读出数据,true);偏移+=4;}
else{if(读取字节[i]==2){数据操作.setInt16(偏移,读出数据,true);偏移+=2;}
else{if(读取字节[i]==1){数据操作.setInt8(偏移,读出数据,true);偏移++;}}}
}
return 数组缓冲; //返回
}
function 缓冲转数组(数组缓冲){ //返回数组[]
let 总字节=数组缓冲.byteLength;
let 组数=Math.ceil(总字节/4);
const 数据操作=new DataView(数组缓冲);
let 数组=[];
for(let i=0;i<组数;i++){
数组[i]=数据操作.getInt32(i*4,true);
}
return 数组;
}
function 设置鼠标位置(水平,垂直){
const 执行宏调用=ExecuteExcel4Macro;
var 定位结果=执行宏调用(`CALL("User32","SetCursorPos","AJJ",${水平},${垂直})`);
return 定位结果; //成功返回true
}
function 鼠标单击(){鼠标事件(6);}
function 鼠标点击(){鼠标事件(6);}
function 鼠标双击(){鼠标单击();鼠标点击();}
function 鼠标右击(){鼠标事件(0x18);}
function 鼠标事件(动作){
const 执行宏调用=ExecuteExcel4Macro;
执行宏调用(`CALL("User32","mouse_event","JJJJJJ",${动作},0,0,0,0)`);
}
function 模拟键盘输入编码(编码串){ //六位数字编码串，可能有0开头的字符串
for(let i=0;i<编码串.length;i++){
let 数字码=编码串[i];
小键盘输入单个数字(数字码);
}
}
function 模拟键盘回车(){let 回车码=0xD;模拟键盘按键(回车码);}
function 模拟键盘按键(按键码){
let 扫描码=按键码转扫描码(按键码);let 按下=0,松开=2;
键盘事件(按键码,扫描码,按下);键盘事件(按键码,扫描码,松开);
}
function 小键盘输入单个数字(数字){ //单个数字0～9
let 小键盘数字码;
if(typeof 数字=='number'){小键盘数字码=0x60+数字;}else{
if(typeof 数字=="string"){小键盘数字码=0x30+数字.charCodeAt(0);}}
let 小键盘数字扫描码=按键码转扫描码(小键盘数字码);
let 按下=0,松开=2;
键盘事件(小键盘数字码,小键盘数字扫描码,按下);
键盘事件(小键盘数字码,小键盘数字扫描码,松开);
}
function 按键码转扫描码(按键码){ //返回扫描码
const 执行宏调用=ExecuteExcel4Macro;
let 扫描码=执行宏调用(`CALL("User32","MapVirtualKeyA","JJJ",${按键码},0)`);
return 扫描码;
}
function 键盘事件(虚拟键码,扫描键码,键标志){
const 执行宏调用=ExecuteExcel4Macro; //扫描码只需要低位，高位0xE0省略 //扩展键才用扫描码
执行宏调用(`CALL("User32","keybd_event","JJJJJ",${虚拟键码},${扫描键码},${键标志},0)`);
}
function 查找对话框窗口(标题){
var 对话框句柄=查找窗口(标题,"#32770"); //对话框类#32770
return 对话框句柄;
}
function 发送点击按钮消息(按钮句柄){var 点击=0xF5;发送消息(按钮句柄,点击);}
function 发送关闭窗口消息(窗口句柄){var 关闭=0x10;发送消息(窗口句柄,关闭);}
function 发送消息(窗口句柄,消息){ //等待结果返回
const 执行宏调用=ExecuteExcel4Macro;
执行宏调用(`CALL("User32","SendMessageA","JJJJJ",${窗口句柄},${消息},0,0)`);
}

复制代码

		自动登录	找回密码
密码			注册

[新手上路]批处理新手入门导读	[视频教程]批处理基础视频教程	[视频教程]VBS基础视频教程	[批处理精品]批处理版照片整理器
[批处理精品]纯批处理备份&还原驱动	[批处理精品]CMD命令50条不能说的秘密	[在线下载]第三方命令行工具	[在线帮助]VBScript / JScript 在线参考

[转载代码] 在办公软件WPS的JSA中模拟键盘输入

评分

模拟键盘输入应用：截屏

模拟键盘输入应用：打开运行对话框

模拟键盘输入应用：打开/关闭小键盘数字指示灯

模拟键盘输入测试：内码转文字

模拟键盘输入文字：Alt + 内码

找到窗口，模拟键盘输入数字编码