系统参数用 ^ 符号 (请勿修改)
指定模板用 @ 符号
名称空间转向用 > 符号
-------
^MAXTIER = 20
^IGNORECASE_NODE_KEY = 1
_FAPPATH = FAP文件路径
_LASPATH = 脚本文件路径
_LASDIR =  脚本文件目录
_IMPORTDIR = 插件目录路径
_VERSION = LASCRIPT版本号
_STOPHKEY = 模拟程序停止热键
_ALERT = 
_NULL = 0
_TRUE = 1
_FALSE = 0
_G[""] = 全局变量表,参数为变量名
_G  = >
do =  开始一个语句块,必须以end;结束
end =  语句块结束
function = @ function()         end;
return = 返回一个值,例:return true; \n如果不在end;结束语句前面应放到do end;中间
if =  @if( )then\n\nend;--条件判断语句
ife =  @if( )then\n\nelse\n\nend;--条件分支语句
ifeif =  @if( )then\n\nelseif( )then\n\nend;--多条件分支语句
then =  则...  
else =  否则...  
elseif = @elseif( )then --如果符合其他条件...  
local =  声明局部变量 
and =  逻辑与运算符
not =  逻辑非运算符
or = 逻辑或运算符
repeat = @repeat\n	\nuntil( nStop() == false );\n--循环...直到(条件为真)
until = 循环控制语句
while = @while( (true) and nStop() ) do\n	delay(10)   \nend;\n--循环(如果条件为真)...
break =  中断循环语句,\n如果不在end;结束语句前面应放到do end;中间
for = @for i=1,10,1    do      end;
forkv = @for k,v in pairs(tab) do    end;--遍历列表(键值对)
foriv = @for i,v in ipairs(tab) do    end;--遍历数组(索引为数字)
fors = @for c,c2 in string.gmatch( str,"(.)") do    end;--搜索字符串
forw = @\nimport("std")\nfor hwnd,title in std.win.gfind("类名") do--搜索窗体\n	if( string.find(title,"标题包含") )then\n\n	break;--中断循环\n	end;\nend;
wait = @while(  nStop() ) do --如果用户没有按[停止热键]则循环\n	delay(200) --延时0.2秒\n\n	if( )then --如果条件满足\n	  break;--退出循环\n	end;  \nend;
pairs = 迭代函数
ipairs = 迭代函数
rawequal = 比较两个参数
true = 布尔值：真
false = 布尔值：假
nil = 空值
select( , ) = 第一个参数指定索引，返回其后指定位置的参数
assert( = 检测返回值并显示错误信息\n例:assert(f());
error("错误信息") = 抛出一个错误
getmetatable(tab) = 读取元配置表
setmetatable(tab, = setmetatable(tab, metatable) \n设置元配置表
getfenv( = getfenv(0) \n读取函数环境表
setfenv( = setfenv (1, tab) \n设置函数环境表
next(tab, = 
load(getlas,"name") = 调用getlas函数读取脚本创建新函数体，直到getlas返回nil
print("") = 输出字符串到控制台窗口
loadfile("") = 加载*.LAS脚本文件\n例:f=loadfile(_LASDIR.."test.LAS");\npcall(f);
dofile("") = 加载并运行*.LAS脚本文件\n例: dofile(_LASDIR.."test.LAS")
import("") = 导入插件dll
tonumber("") = 转换为数字
tostring( = 转换为字符串
type( = type (v) 返回对象类型
unpack = 返回一个对象的所有元素\n例： f(unpack(a))\nunpack返回a所有的元素作为f()的参数
nStop() = 模拟程序是否正在运行
stop() =  停止模拟程序(*.fap)\n停止所有LAS程序(*.LAS)
collectgarbage(."stop") = 禁用垃圾收集器
collectgarbage(."restart") = 重启垃圾收集器
collectgarbage(."count") = 查询内存占用(Kb)
collectgarbage(."steppause",1) = 垃圾收集中断量(1-100)
collectgarbage(."setstepmul",2) = 垃圾收集工作量(1-100)
collectgarbage(."collect") = 完全垃圾收集
collectgarbage(."step",1) = 垃圾收集
gcinfo() =  废除.
loadlib = @local init,err1,err2 = loadlib("","");assert (init,(err1 or '')..(err2 or ''));init();--加载dll插件
loadstring("") = 加载LAScript代码\n例:f=loadstring("win.messageBox('运行','标题');");\npcall(f);
rawget( = Rawget(t,i)的调用以raw access方式访问表
rawset( = 调用rawset(t,k,v)不掉用任何metamethod对表t的k域赋值为v
pcall( = 调用函数并捕获错误\n例:pcall(fun);
xpcall(,err ) = 类似pcall,例:\nerr =  function(e) win.messageBox(e) end;\nxpcall(func,err);

table.foreach(tab, = 不推荐,请使用 for ... in pairs
table.foreachi(tab, = 不推荐,请使用 for ... in ipairs
table.maxn(tab) = 返回表内数组大小(数字索引元素);
table.insert(tab, ) = 插入元素 例：table.insert(tab, "测试")
table.remove(tab, ) = table.remove (table [, pos]) 移除元素,\n例:table.remove(tab,1);
table.concat(tab, = table.concat (tab [, sep [, i [, j]]])
table.sort(tab) = 排序
table.sort(tab,sproc) = 排序,sproc指定比较函数
table.save(tab,":\\") = 序列化table列表到xml文件
table.save(tab) = 序列化table列表返回字符串
table.loadXML(str) = 将XML文件或XML数据转换为table列表
table.saveXML(tab,":\\") = 将table列表转换为XML文件
table.saveXML(tab) = 将table列表转换为XML字符串
table.load("")  = 读取table列表,参数(文件路径 或 XML格式字符串)
table.saveList(tab,",") = 将字典转换为列表字符串
table.loadList(str,",") = 从列表字符串创建table列表
table.concat(tab) = 将数组转换为字符串
table.concat(tab,",",1,) = 参数(表,分隔符,起始索引,最大索引)
table = 请输入.显示table库成员列表
debug.debug() =
debug.getfenv( =
debug.gethook() =
debug.getinfo( =
debug.getlocal( =
debug.getmetatable( =
debug.getregistry() =
debug.getupvalue( =
debug.setfenv( =
debug.sethook( , =
debug.setlocal( =
debug.setmetatable( , =
debug.setupvalue( , , =
debug.traceback( =
debug = 调试库
coroutine = 多线程协同程序库
coroutine.create( = 例:co=coroutine.create(f)\n创建线程,f为函数名或函数体
coroutine.resume(co, = coroutine.resume (co, val1, ...)运行线程,可传递任意多个参数
coroutine.status(co) = 例:print(coroutine.status(co))\n返回线程状态.
coroutine.wrap( = 例:return coroutine.wrap (f) \n创建协同程序;但是返回值不是线程而是返回一个函数
coroutine.yield( = coroutine.yield (val1, ...)\n挂起当前线程;
math.pow(x,y) = 返回x的y次幂
math.modf( , =
math.fmod( , = 求余,同math.mod
math.ceil( = 将数字向上舍入为最接近的整数
math.floor( = 将数字向下舍入为最接近的整数
math.abs( = 计算绝对值
math.acos( = 计算反余弦值
math.asin( = 计算反正弦值
math.atan( = 计算反正切值
math.atan2( , = 计算从x坐标轴到点的角度
math.cos( = 计算余弦值
math.cosh = 余弦值(角度)
math.deg( = 转换为度
math.rad( = 转换为弧度
math.exp( = 计算指数值
math.frexp( = 返回实数x的指数部分和假数部分
math.ldexp( , = 先以2为底数进行exp的指数运算, 然后乘以实数x
math.log( = 计算自然对数
math.log10( = 返回一个整数的常用对数
math.max( , = 返回两个整数中较大的一个
math.min( , = 返回两个整数中较小的一个
math.mod = @fmod( , )
math.pi = 圆周与直径的比值常数
math.random( , ) = 生成随机数，参数指定范围
math.randomseed(os.time()) = 设置随机数发生器的种子
math.sinh( = 正弦值(角度)
math.sin( = 计算正弦值
math.sqrt( = 计算平方根
math.tanh( = 计算正切值(角度)
math.tan( = 计算正切值
math = 数学计算库
string.byte( , ) = 参数(s, i)将字符串s的第i个字符的转换成整数
string.char( = 获取0个或多个整数,将每一个数字转换成字符
string.find( ,"" ) = string.find(字符串, 查找模式串,起始位置)
string.find( ,"",1,true) = 不使用模式匹配的简单查找
string.match(, "")  = 搜索并返回一个或多个字符串(模式中的每个括号匹配)
string.match(, "",1) = 指定搜索的起始位置
string.gmatch( ,"")  = 参考fors模板
string.gfind = @gmatch( ,)
string.format( = 格式化字符串
string.gsub( = 全局字符串替换
string.left( ,1) = 左侧截取字符串
string.right( ,1) = 右侧截取字符串
string.trim( ," ") =  去除字符串首尾指定的字符(参数2，可指定多个)
string.split( ,",") = 折分字符串并返回table数组，\n参数2为分隔符(可指定多个)
string.splitX( ,",") = 同split拆分字符串返回table数组，\n不合并重复分隔符,\n不忽略空值
string.splitRaw( ,"\0") = 同split拆分字符串返回table数组，\n分隔符可以指定\0，但不可以指定多个
string.len( = 返回字符串的长度
string.lower( = 转换为小写
string.rep( = string.rep(s, n) 返回重复n次字符串s的串
string.sub( = string.sub(s,i,j)函数截取字符串s的从第i个字符到第j个字符之间的串
string.upper( = 转换为大写
string.encode(  = base64编码;
string.decode(  = base64解码;
string.encode( ,"k") = 加密字符串
string.decode( ,"k") = 解密字符串(必须是已加密的字符串)
string.decode( ,"",true) = 解密字符串(自动检测字符串是否加密)
string.save( ,":\\") = 保存到文件,例: string.save("test","t.txt");
string.save( ,":\\","w+b") = 保存到文件并指定模式,a:追加，b:二进制,w+:自动新建;
string.load(":\\") = 从文件读取,例: str=string.load("t.txt");
string.load(":\\","rb") = 从文件读取,例: str=string.load("t.txt");
string.zip("") = 压缩字符串或二进制数据
string.unzip("") = 解压缩字符串或二进制数据
string.toUnicode(str,_CP_ACP) = 转换为unicode;
string.fromUnicode(str,_CP_ACP) = 从unicode还原
string.dump(fun) = 将函数予编译为字符串
string.reverse("") = 字符串从后向前反转顺序
string.time("2006/6/6 0:0:0","%Y/%m/%d %H:%M:%S") = 将字符串格式化为时间
string.ftime("%Y/%m/%d %H:%M:%S", ) = 将时间转换为字符串
string.c(lps) = 从c指针生成字符串
string = 字符串操作库
os.clock() = 系统时钟(秒)
os.clock() = 运行时钟(秒)
os.tick() = 系统时钟(毫秒)
os.date() = 返回时间
os.difftime( = os.difftime(t2, t1)\n计算时间差,以秒为单位
os.execute("") =  调用系统命令行,成功返回0
os.exit(0) = 退出程序,函数指向win.exit()
os.getenv( = os.getenv(varname)\n读取环境变量
os.remove("") = 删除指定的文件\n成功返回true,失败返回nil
os.rename("","") = 重命名\n成功返回true,失败返回nil
os.setlocale( = os.setlocale(locale [, category])
os.time( = os.time([table]) 
os.tmpname() = 生成临时文件名
os = 操作系统库
io.stderr = 标准错误输出
io.stdin =  标准输入
io.stdout = 标准输出
stderr: = >f:
stdin: = >f:
stdout: = >f:
io.seek( =    
io.tmpfile( = 
io.close(f) = 
io.popen("","r") = 创建一个进程打开目标程序并绑定输入输出，例：\nf=io.popen("ipconfig /all","r")
io.open("","r") =  打开文本r为读,w+为写入
io.input( = 设置输入文件
io.output = 设置输出文件
io.write( = 输出任意多个字符串参数
io.type(f) = 检测文件句柄状态
io.read("*all") = 
io = IO库
f:.flush() = 输出缓冲区数据
f:.write("") = 写数据
f:.write( , ) = 支持任意多个字符串或数字参数
f:.read("*a") = 读取全部数据
f:.read("*n") = 读取数字
f:.read("*l") = 读取下一行
f:.close() = 关闭文件流
f:.seek() = 得到当前位置
f:.seek("end") = 移动指针至结束处
f:.seek("end",0) = 移动至结束处相对偏移量
f:.seek("cur",0) = 移动至当前相对偏移量
f:.seek("set") = 移动指针到开始
f:.seek("set",0) = 移动至开始处相对偏移量
f:.lines () = 返回全部行
f:.setvbuf("no") = 禁用缓冲
f:.setvbuf("full",) = 全部缓冲
f:.setvbuf("line",) = 缓冲每行
--下面是推荐使用的变量名
f2: = >f:
file: = >f:
file2: = >f:
<.事件 =   @事件 源="键盘按" 键="" 延时="125" />
<.循环输入 = @循环输入 文本="" />
<.![CDATA[ = @![CDATA[\n\n\n        ]]>
<.!-- = @!--    -->
delay(1000) = 延时1秒(1000毫秒)
delay(0) = 无限制等待
delay( _CMD_LOOP ) = 同delay(0)
sleep(10) = 休眠,参数为毫秒数字值
失败="._CMD_LOOP = 指示模拟精灵再次尝试检测,\n直到成功为止
失败="._CMD_NEXT = 指示模拟精灵忽略这个错误,\n继续执行后面的操作
失败="._CMD_OUT = 指示模拟精灵跳出这个模块,\n并执行后面的模块
失败=".LAScript: return _CMD_LOOP = 使用LAScript脚本返回指令
_CMD_LOOP = 再次尝试检测,\n直到成功为止
_CMD_NEXT = 继续下一步,\n如果有错误尝试清除并忽略
_CMD_OUT = 跳出不执行当前模块,\n并执行下一个模块
LAScript:.return _CMD_NEXT = 设置继续运行指令
LAScript: = 回调脚本标记
ape:.getModule("") = 例:\nm = ape:getModule("n")\nif(type(m)=="function")then \nm(); --脚本区块\nelse\n --模拟区块\nend;\n
ape:.getModule( = 例:m = ape:getModule(1) \n参数为区块的指针值
ape:.setRunNumber( = 设置模拟程序循环总次数
ape:.getRunNumber() = 读取模拟程序循环总次数
ape:.runCount() = 读取模拟程序当前循环次数
ape:.getPosition( = 返回相应区块的指针值。\n参数为区块名字,nil参数返回当前指针值\n例:p = ape:getPosition(nil); p = ape:getPosition("区块A");
ape:.setNextPosition( = 设置下一个回放指针,\n参数可以是指针值,也可以是区块名字,\n例:ape:setNextPosition(1);ape:setNextPosition("区块A");
ape:.call( = 立即运行指定的模块,\n运行完成返回true,错误返回false,\n参数可以是指针值,也可以是区块名字,\n例:ape:.call(1); ape:.call("区块A");
ape:.moduleCount() = 返回模块总数（包含模块区块和脚本区块)
ape:.loadSetting() =  读取配置表,返回值为table类型\n例:_set = ape:getSetting()
ape:.saveSetting(_set) = 保存配置表
ape:.loadTable("t") = 从数据区块读取table列表,参数（存取标记）
ape:.loadTable() = 从数据区块读取table列表(标记:table)
ape:.saveTable(,"t") = 保存table到数据区块,,参数（table列表,存取标记)\n第二个参数可忽略
ape:.validate("",true) = 启用指定区块，第一个参数指定区块名字
ape:.dir() = 返回fap当前目录
ape: = ape对象指向当前模拟程序
m() = @m = ape:getModule("") if(type(m)=="function") then m() end;
m:.setNextPosition() = 设置下一个回放指针指向本区块
m:.left() = 返回当前模块锚点位置横坐标
m:.top() = 返回当前模块锚点位置纵坐标
m:.moveTo( = 移动当前模块到指定坐标
m:.name() = 返回模块名字
m:.getFindImageRect() = 返回四个数字值指定模块抓图区块
m:.getFindPixRect() = 返回四个数字值指定模块抓点区块
m:.setFindImageRect( = 设置指定模块抓图区块,四个数字值参数
m:.setFindPixRect( = 设置指定模块抓点区块,四个数字值参数
m:.setRunNumber( = 设置模拟程序循环总次数
m:.getRunNumber() = 读取模拟程序循环总次数
m:.getPosition( = 读取当前区块的回放指针值。
m:.runCount() = 读取模拟区块在本次循环中的局部循环次数
m:.runCount_G() =  读取模拟区块总循环次数
m:.setStringList( = 设置自动循环发送的字符串列表,参数为table列表
m:.getStringList() = 返回一个table列表(当前模块循环发送的字符串列表)
m:.setCode( = 设置循环发送文本的自动编号初始值(替换\c),例：m:setCode(12);
m:.getCode() = 返回当前自动编号
m:.setImageBytes(,"bmp") =  设置抓图节点图像的二进制数据
m:.getImageBytes() =  读取抓图节点图像的二进制数据
m:.getWindow() = 返回主窗体句柄。
m:.getCtrl() = 返回目标控件句柄。
m:.getCtrlX() = 返回指向控件句柄。
m:.validate(true) = 启用模拟区块
m: = 模拟区块对象
this: = >m:
--下面是推荐使用的变量名
m2: = >m:
key.getProc = @getProc=function(m,k,x,y)\n	return true;--继续监视\n	--return false;--停止监视\n	--return _FALSE; --继续但是禁止发送该键(key.get参数为0则不支持)\nend;
key.get(0) = 0:监视鼠标键盘 1:仅监视键盘 2:仅监视鼠标,\n返回值(事件源,键名,x坐标,y坐标),例:\n m,k,x,y = key.get(0); print(m,k,x,y)
key.get(0,true) = 0:监视鼠标键盘 1:仅监视键盘 2:仅监视鼠 \n启动监控并自动调用key.getProc，无返回值
key.press( = press([n],k,[k1,k2,k3......]) \n软件模拟输入按键,支持不定个数键名参数,n为延时
key.pressIO( = pressIO([n],k,[k1,k2,k3......]) \n硬件模拟输入按键,支持不定个数键名参数,n为延时
key.getIO(true) = 等待按键，返回值(键名，是否按下) \n k,down = key.getIO(true);
key.getDnIO(true) = 等待按键,返回值为键名
key.getUpIO(true) = 等待弹起键,返回值为键名
key.getDnIO(false) = 等待按键并禁用,返回值为键名
key.getUpIO(false) = 等待弹起键并禁用,返回值为键名
key.getState("") = 参数(键名),检测指定键是否被按下(消息)
key.getStateX("") = 参数(键名),检测指定键是否被按下(状态)
key.waitKey("") = 参数(键名),等待按键
key.down("") = 参数(键名),按下指定键
key.up("") = 参数(键名),释放指定键
key.downIO("") = 参数(键名),按下指定键(硬件模拟)
key.upIO("") = 参数(键名),释放指定键(硬件模拟)
key.regHK(":\\", = 添加热键绑定,例:\nok,err = key.regHK("c:\\test.fap","CTRL","R")
key = 键盘模拟库
mouse.getPos() = x,y=mouse.getPos()\n返回当前鼠标位置
mouse.getCur() = hico=mouse.getCur();\n返回鼠标指针句柄
mouse.setPos( = setPos(x,y)\n设置当前鼠标位置
mouse.down(0,0,false) = 参数(x坐标,y坐标,是否绝对定位)\n 鼠标左键按下
mouse.up(0,0,false) = 参数(x坐标,y坐标,是否绝对定位)\n 鼠标左键释放
mouse.downRB(0,0,false) = 
mouse.upRB(0,0,false) = 
mouse.downMB(0,0,false) = 
mouse.upMB(0,0,false) = 
mouse.down(0,0,false) =  鼠标左键按下
mouse.up(0,0,false) = 鼠标左键释放
mouse.click(0,0,false) = 参数(x坐标,y坐标,是否绝对定位)\n 鼠标左键单击
mouse.clickDB(0,0,false) = 参数(x坐标,y坐标,是否绝对定位)\n 鼠标左键双击
mouse.clickRB(0,0,false) = 参数(x坐标,y坐标,是否绝对定位)\n 鼠标右键单击
mouse.clickMB(0,0,false) = 参数(x坐标,y坐标,是否绝对定位)\n 鼠标中键单击
mouse.move(10,-10,false) = 参数(x坐标,y坐标,是否绝对定位)\n移动鼠标
mouse.moveTo( , ,10) = 参数(x坐标,y坐标,移动速度)\n移动鼠标并显示轨迹
mouse.dragTo( , ,10) = 参数(x坐标,y坐标,移动速度)
mouse.roll(-1) = 参数负值鼠标滚轮向下,正值向上
mouse.downIO(0,0,false) = 硬件模拟鼠标左键按下
mouse.upIO(0,0,false) = 硬件模拟鼠标左键释放
mouse.downRBIO(0,0,false) = 硬件模拟鼠标右键按下
mouse.upRBIO(0,0,false) =  硬件模拟鼠标右键释放
mouse.downMBIO(0,0,false) = 硬件模拟参鼠标中键按下
mouse.upMBIO(0,0,false) = 硬件模拟鼠标中键释放
mouse.clickIO(0,0,false) = 硬件模拟鼠标左键单击
mouse.clickRBIO(0,0,false) = 硬件模拟鼠标右键单击
mouse.clickMBIO(0,0,false) = 硬件模拟鼠标中键单击
mouse.clickDBIO(0,0,false) = 硬件模拟鼠标左键双击
mouse.moveIO(10,-10,false) = 硬件模拟鼠标移动
mouse.openIO() = 打开键盘鼠标端口
mouse.closeIO() = 关闭键盘鼠标端口
mouse.getStateLB() = 检测左键按下消息
mouse.getStateRB() = 检测右键按下消息
mouse.getStateMB() = 检测中键按下消息
mouse.getStateLBX() = 检测左键按下状态
mouse.getStateRBX() = 检测右键按下状态
mouse.getStateMBX() = 检测中键按下状态
mouse.waitDB() = 等待双击左键
mouse.waitLB() = 等待点击左键
mouse.waitRB() = 等待点击右键
mouse.waitMB() = 等待点击中键
mouse = 鼠标模拟库
win.tip("","标题",1000,3) = 显示汽球提示\n参数(内容,标题,延时,图标类型)\n图标类型1表示提示\n2表示警告\n3表示错误
win.tip("") = 显示汽球提示
win.version.major = Windows主版本号
win.version.minor = Windows副版本号
win.version.build = WindowsBuild版本号
win.version.isNT = 是否NT系统(相对9x)
win.exit(1) = 关机\n{exit=0;Shutdown=1,Restart=2,LogOff=3,standBy=4,Hibernate=5}
win.topMost(hwnd,true) = 设置窗体始终在最前面
win.consoleOpen() =  打开控制台DOS窗口
win.consoleClose() = 关闭控制台DOS窗口
win.doEvents() = 释放控制权,让操作系统响应其它的事件,用户点击停止则返回false。
win.messageBox("") = 弹出对话框(信息)
win.messageBox("","") = 弹出对话框(信息,标题)
win.messageBox("","",0x0) = 弹出对话框(信息,标题,样式)
win.messageBoxTest("") = 询问对话框(信息)
win.messageBoxTest("","") =  弹出询问对话框(信息,标题)\n返回布尔值
win.messageBoxTest("","",0x1) =  弹出询问对话框(信息,标题,样式)\n返回布尔值
win.inputBox() = 弹出输入对话框
win.inputBox("") = 弹出输入对话框(信息)
win.inputBox("","") = 弹出输入对话框(信息,标题)
win.messagePrint("") = 在浮动信息窗口上输出字符串
win.desktop() = 获得桌面窗口句柄
win.find("","") = find(类名,窗口标题)查找窗体
win.findX(hwndParent,hwndAfter,"","") = 参数(父窗口，前面的窗口，类名，窗口标题)
win.findXX(hwndParent,"","",0) = 在指定窗体中查找子窗口，参数(父窗口，类名,标题包含字符,控件id)
win.fromPos( , )= fromPos(x,y)查找指定坐标的窗体
win.getParent(hwnd) = 返回指定窗体的父窗体.
win.getTop(hwnd) = 返回指定窗体的最顶层父窗体.
win.getForeground() = 返回桌面上最前面的窗体句柄
win.setForeground(hwnd) = 把窗体激活并移动到最前面
win.show(hwnd,true) = 显示窗口\nimport("std")\nwin.show(hwnd,_SW_MAX)
win.close(hwnd) = 关闭窗口
win.min(hwnd) = 最小化窗口
win.max(hwnd) = 最大化窗口
win.restore(hwnd) = 恢复窗口大小
win.getRect(hwnd) = x,y,x2,y2=win.getRect(hwnd)返回窗体区块与坐标
win.setRect(hwnd, = setRect(hwnd,x,y,x2,y2) 设置窗体区块与坐标
win.getFocus(hwnd) = 获取hwnd窗体的输入焦点控件句柄
win.setFocus(hwnd) = 设置输入焦点(按钮除外)
win.minAll() = 全部最小化
win.minAll(false) = 取消全部最小化
win.sendString(hwnd,"") = 发送字符串(MBCS)
win.sendStringX(hwnd,"") = 发送字符串(ANSI)
win.sendStringXX(hwnd,"") = 发送字符串(SEND)
win.sendString("") = 向顶层窗口发送字符串(MBCS)
win.sendStringX("") = 向顶层窗口发送字符串(ANSI)
win.sendStringXX("") = 向顶层窗口发送字符串(SEND)
win.mouseDown(hwnd, , ) = 后台按鼠标左键\n参数(句柄,x,y)
win.mouseUp(hwnd, , ) = 后台释放鼠标左键\n参数(句柄,x,y)
win.mouseDownRB(hwnd, , ) = 后台按鼠标右键\n参数(句柄,x,y)
win.mouseUpRB(hwnd, , ) = 后台释放鼠标右键\n参数(句柄,x,y)
win.mouseDownMB(hwnd, , ) = 后台按鼠标中键\n参数(句柄,x,y)
win.mouseUpMB(hwnd, , ) = 后台释放鼠标中键\n参数(句柄,x,y)
win.mouseClickDB(hwnd,  , ) = 后台发送鼠标双击指令\n参数(句柄,x,y)
win.keyDown(hwnd,"") = 发送按键\n参数(句柄,键名)
win.keyUp(hwnd,"") = 发送释放键\n参数(句柄,键名)
win.mouseDown( , ) = 向顶层窗口发送按鼠标左键\n参数(x,y)
win.mouseUp( , ) = 向顶层窗口发送释放鼠标左键\n参数(x,y)
win.keyDown("") = 向顶层窗口发送按键\n参数(键名)
win.keyUp("") = 向顶层窗口发送释放键\n参数(键名)
win.click() = 点击顶层窗口焦点按钮、或菜单项
win.click(hwnd) = 点击指定窗口焦点按钮
win.click(hwnd,) = 点击按钮，参数(句柄,控件ID或菜单ID)
win.getString(hwnd) = win.getString(hwnd) 获取窗体文本
win.paste(hwnd) = 粘贴
win.copy(hwnd) = 拷贝
win.isHung(hwnd) = 是否失去响应
win.isEnabled(hwnd) = 窗口是否启用
win.isMax(hwnd) = 窗口是否最大化
win.isMin(hwnd) = 窗口是否最小化
win.isVisible(hwnd) = 窗口是否可见
win.top(hwnd) = 前置窗口
win.bottom(hwnd) = 后置窗口
win.enable(hwnd,true) = 启用窗口
win.exec("","") = 参数(文件名,参数,工作目录,显示样式)，返回值(是否成功,进程ID);
win.exec("","","",5,true) = 打开并等待程序结束
win.exePID("") = 返回exe文件进程id
win.PID(hwnd) = 返回窗口进程id
wintPID() = @--系统进程列表\ntpids = win.tPID();\nfor pid,pinfo in pairs(tpids) do\n\nend;
win.tPID("") = 指定文件名并获取进程列表\ntpids = win.tPID("qq.exe");
win.fromFile("exe") = 通过应用程序文件名查找窗体，可以有多个返回值\nhwnd,hwnd2 = win.fromFile("exe")
win.fromPID(pid) = 通过进程ID查找窗体，可以有多个反回值\nthwnd = { win.fromPID(pid) }
win.fromFile("exe","#32770") = 参数(进程id,类名) 
win.fromPID(pid,"#32770") = 参数(进程id,类名)
win.fromFile("exe","#32770","") = 参数(进程id,类名,标题包含) 
win.fromPID(pid,"#32770","") = 参数(进程id,类名,标题包含)
win.getScreen() = 例:w,h=win.getScreen()获取当前屏幕分辩率
win.threadID() = 读取主线程ID
win.threadID(0) = 读取当前线程ID
win.threadID(hwnd) = 读取指定窗体线程ID
win.postThreadMessage(tid, ,0,0) = 发送消息，参数(线程id,msg,wparam,lparam)
win.postMessage(hwnd, ,0,0) =  向目标窗口发送消息,\n四个数值参数(hwnd,msg,wparam,lparam)
win.sendMessage(hwnd, ,0,0) =  向目标窗口发送消息并等待返回值,\n四个数值参数(hwnd,msg,wparam,lparam)
win.peekMessage() = 检查消息队列\nmsg,wParam,lParam,hwnd,time,x,y = win.peekMessage();\n指定参数可限制消息范围 win.peekMessage(min.max);
win.getMessage() = 用法同peekMessage,但是没有消息会休眠并等待消息。
win.enumProc = @enumProc = function(dir,filename)\n    if(dir)then  else   end;return true;--继续查找\nend;\nwin.enumDir("D:\\模拟精灵","*.*")
win.setClipBD("") = 设置剪贴板文本
win.getClipBD() = 读取剪贴板文本
win.flashOpen("", , ) = 参数分别为(swf文件路径或网址,x坐标,y坐标)
win.flashClose() = 关闭flash动画
win.playSound("") = 播放wav声音文件
win.createDir("") = 创建新目录
win.getSysDir() = 返回系统目录
win.getWinDir() = 返回windows目录
win.getTempDir() = 返回临时目录
win.getExeDir() = 返回模拟精灵主程序当前目录
win.getExeFile() = 模拟精灵主程序路径
win.getDir() = 读取当前目录
win.setDir("") = 设置当前目录
win.path("") = 快速查找本地文件并转换为绝对路径
win.pathDir("") = 取得目录\ndir,dr=win.pathDir("c:\\dir\\f.ext")
win.pathName("") = 取得文件名\nfn,ext=win.pathDir("c:\\dir\\f.ext")
win.pathEx("") = 取得后缀名\next,fn=win.pathDir("c:\\dir\\f.ext")
win.pathOK("") = 本地文件路径是否有效
win.drID("C:\\") = 读取硬盘序列号(数值)
win.saveDlg( = 保存文件对话框,参数(标题，文件类型,默认文件名)，例：\nwin.saveDlg()\nwin.saveDlg("另存为")\nwin.saveDlg("另存为","All Files (*.*)|*.*||","test.txt") 
win.openDlg() = 打开文件对话框
win.openDlg("") = 打开文件对话框(标题)
win.openDlg("","") = 打开文件对话框(标题,文件类型)
win.dirDlg() = 目录对话框
win.dirDlg("") = 目录对话框(标题)
win.MAKEWORD(,) = 组合成字
win.MAKELONG(,) = 组合成双字 
win.LOWORD( = 取字低位
win.HIWORD( = 取字高位
win.LOBYTE( = 取字节低位
win.HIBYTE( = 取字节高位
win.lastError() = code,msg=win.lastError();\n读取系统最后一次错误记录\nwin.lastError(0);设置错误代码,0为清除
win.SetPrivilege("SeBackupPrivilege",true) = 提升NT系统进程权限
win.kill(pid) = 关闭进程,成功返回true
win.kill("") = 通过文件名(注意大小写)关闭进程
win.getf(":\\") = 读取文件属性\nattr,creat,access,write = win.getf("c:\\t.txt")
win.setf(":\\",_FATTR_NORMAL , , , ) = 参数(路径,属性,创建时间、访问时间、修改时间)
win.id(hwnd) = 读取控件ID
win.class(hwnd) = 读取窗口类名
win.screen() = 屏幕信息\nwsrc=win.screen()\nprint(wsrc.bits)
win.cpu() = CPU信息\nwcpu=win.cpu()\nprint(wcpu.num)
win.mem() = 内存信息\nwmem=win.mem()\nprint(wmem.phy)
win.findMenu(hwnd, = 在窗体上搜索菜单项，\n返回菜单句柄,菜单项ID，例:\nhMenu,idItem = findMenu(hwnd,"文件",2,"&P");\nwin.click(hwnd,id);
wincpu = @wcpu=win.cpu()
wcpu.num =  cpu数目
wcpu.type =  cpu类型
wcpu.level = cpu 等级
wcpu.id =  OEMId
wcpu.page =  cpu页面大小
winmem = @wmem=win.mem()
wmem.phy = 物理内存
wmem.phy2 = 可用内存
wmem.page = 交换文件
wmem.page2 = 可用交换文件
wmem.virtual = 虚拟内存
wmem.virtual2 = 可用虚拟内存
winsrc = @wsrc=win.screen()
wsrc.width = 屏幕宽
wsrc.height = 屏幕高
wsrc.bits = 颜色位数
wsrc.bpp = 颜色分辨率
win = 窗口操作库,参数中hwnd为窗口句柄
pinfo.file = 程序文件名
pinfo.parent = 父进程
pinfo.treads = 线程数
pinfo.usage = 引用数
pinfo.PRI = 优先级
mem.close() = 关闭进程句柄
mem.open() = 打开当前模拟区块进程
mem.open("") = 打开指定文件的进程，成功返回句柄
mem.open(pid) = 参数为线程ID，成功返回线程句柄\nhandle = mem.open(pid)
mem.openHWND(hwnd) = 数为窗体句柄，成功返回句柄
mem.query(0x0,,) = import("std")\nsize,b,p,t = mem.query(b,_PAGE_READWRITE,_MEM_PRIVATE);
mem.query(0x0) = size,b,p,t = mem.query(b);
mem.read(0x, ) = read(addr,size)读取内存[string]
mem.write(0x, ) = write(addr,str)写内存[string]
mem.readInt(0x, )  = readInt(addr,size)读取内存值.
mem.readFloat(0x = readFloat(addr)读取单精度浮点值
mem.readDouble(0x = readDouble(addr)读取双精度浮点值
mem.writeInt(0x, , ) = writeInt(addr,value,size)写内存值
mem.writeFloat(0x, ) = writeFloat(addr,f)写内存浮点值
mem.writeDouble(0x, ) = writeDouble(addr,d)写内存双精度浮点值
mem = 内存操作库
dll.open("", "", "V()") = 导入DLL函数，参数(文件名,函数名,函数原型,调用方式-可略)
dll.def( ,nil, ,  = 第一个参数为函数对象\n其他参数对应参数声明的顺序\n必须的参数指定nil值，可选参数指定默认字符串或数字值
dll.close( = 关闭导入函数库
dll = dll支持库
stdcall = 
cdecl = 
color.new() = 创建颜色对象,例:local cl = color.new();
color.new( , ) = 从屏幕指定坐标抓点并创建颜色对象实例:\ncl = color.new(120,2)
color.new( = 从数值创建颜色对象实例:\ncl = color.new(25)
color.new("#") = 从字符串创建颜色对象实例,例:\ncl = color.new("#AFAFBA")
color.new( , , )  = 从RGB值创建颜色对象,例:\ncl = color.new(2,22,222)
color.new(cl) = 复制新的颜色对象,例:\ncl2 = color.new(cl)
color.del(cl) = 删除颜色对象
color.getRGB(cl) = 
color.setRGB(cl, , , ) =  
color.getHSL(cl) = 
color.setHSL(cl, , , ) =  
color.getString(cl) = 
color.setString(cl, "#") =  
color.getNumber(cl) =  
color.setNumber(cl, ) =  
color.fromPos(cl, , ) =  
color.toPos(cl, , ) =  
color.find(cl,x,y,x2,y2) =
color.find(0, , , , ) = 
color.find("#FFFFFF", , , , ) =
image.bpp(cl,4) = 
color = 颜色操作库,参数中cl变量为color实例对象
cl:.bpp(8) = 在指定BPP值的调色板中取近似色\n1位(黑白)、4位(16色)、8位(256色)、24位(真彩色)
cl:.getHSL() = 读取HSL(色调,饱和度,亮度)值 例:\nh,s,l = cl:getHSL()
cl:.setHSL( , , ) =  设置HSL(色调,饱和度,亮度),成功返回数值 例:\n n = cl:setHSL(2,22,222))
cl:.getRGB() = 读取RGB(红,绿,蓝)值 例:\nr,g,b = cl:getRGB()
cl:.setRGB( , , ) =  设置RGB(红,绿,蓝)值例,成功返回数值:\n n = cl:setRGB(2,22,222))
cl:.getString() =   返回字符串\n str = cl:getString()
cl:.setString( "#") = 通过字符串设置颜色,返回数值\n n = cl:setString("#AFAFBA")
cl:.getNumber() = 返回数值\n n = cl:getNumber()
cl:.setNumber(  = 通过数值设置颜色,返回数值\n n = cl:setNumber(25)
cl:.fromPos( , ) = 通过屏幕抓点读取颜色,返回数值\n n = cl:fromPos(120,2)
cl:.toPos( , ) = 设置屏幕指点坐标颜色
cl:.find(0,0, , ) = 例:x,y=cl:find(0,0,win.getScreen() )
cl2: = >cl:
image.new() = 创建图像,例:local img = image.new();
image.new(":\\") =  从指定路径读取图片文件并创建图片对象
image.new( , ,24) = 创建图像，参数(宽,高,bpp)
image.new( , ) = 创建图像，参数(宽,高),bpp=24
image.new(img) = 复制新的图像
image.del(img) = 删除图像
image.capture(img, = 
image.captureX(img, =  
image.split(img, , ) = 
image.ok(img) = 
image.Crop(img, , , , ) = 
image.getPos(img, , ) = 
image.setPos(img, , , ) = 
image.test(img,img2) = 
image.testX(img,img2) = 
image.testXX(img,img2) = 
image.getURL(img,"http://","") = 
image.load(img,"") = 
image.save(img,"") = 
image.getClipBD(img) = 
image.setClipBD(img) = 
image.setBytes(img, ,"") =  
image.getBytes(img,"") = 
image.getBits(img,1) = 
image.setBits(img,1,str) = 
image.find(img,img2,0,0,0,0,5) =  
image.bpp(img,4) = 
image.median(img,3) = 
image.repair(img, , ) = 
image.mix(img,img2,_MIX_COPY,0,0) = 
image.paint(img,0,0, , ) = 
image.width(img) = 
image.height(img) = 
image.size(img) = 
image.size(img,10,10) = 
image.clear(img) = 
image.getTrClr(img) = 
image.setTrClr(img,0) = 
image.setTrClr(img,false) = 
image.fromHICO(img,hicon) = 
image.fromHBMP(img,hbmp) = 
image.getDIB(img) = 
image.findColor(img,cl,x,y,x2,y2)
image = 图像库,参数中img变量为image实例对象
img:.bpp(1) = 设置位深度 1位(黑白)、4位(16色)、8位(256色)、24位(真彩色)
img:.bpp(0) = 返回位深度
img:.median(3) = 中值滤波
img:.repair( , ) = 修复图片,参数(半径，重复次数)
img:.mix(img2,_MIX_COPY,0,0) = 合并图片,参数(源图片,合并方式,x坐标,y坐标)
img:.paint(0,0, , ) = 显示图片,参数(左,上,宽,高)
img:.capture() = 快速抓屏,参数(hwnd窗口句柄,x坐标,y坐标,cx宽,cy高),\n所有参数都可省略
img:.captureX() = 普通抓屏,参数同capture()
img:.split( , ) = 拆分图像,参数(row行,col列),例:img1,img2 = img:split(1,2);
img:.split(0) = 自动拆分图像，参数指定杂点系数.
img:.split("RGB") = 分离
img:.split("CMYK") = 分离
img:.split("HSL") = 分离
img:.split("XYZ") = 分离
img:.split("YIQ") = 分离
img:.split("YUV") = 分离
img:.ok() =  检测图像是否有效
img:.Crop( , , , ) =  修剪图像,参数(左,上,右,下)
img:.getPos( , ) = 返回图像指定坐标的颜色数字值,参数(左,上);
img:.setPos( , , ) = 设置图像指定坐标的颜色,参数(左,上,颜色数字值);
img:.test(img2) = 比较图像 \n0 < 返回差异值 < (img面积 + img2面积) 
img:.testX(img2) = 比较图像 \n0 < 返回差异值 < 1
img:.testXX(img2) = 比较图像 \n0 < 返回差异值 < img面积 
img:.getURL("http://","") = 下载图像，参数(网址,格式反缀名)
img:.load("") = 读取图片文件
img:.save("") = 保存图片文件
img:.getClipBD() = 从剪贴板获取图像
img:.setClipBD() = 发送到剪贴板
img:.setBytes( ,"") =  从字符串(二进制)生成图像,第二个参数指定图片格式
img:.getBytes("") = 返回二进制的字符串,\n对返回值使用string.encode( ,"")进行base64编码可转换为标准文本
img:.getBits(1) = 返回图像指定行的二进制数据(string)
img:.setBits(1,str) = 设置图象指定行的二进制数据
img:.getDIB() = 获取DIB指针
img:.find(img2,0,0,0,0,5) = 查找图像,返回值(左,上,相似度) = 参数(屏幕图片,左,上,右,下,步进)
img:.width() = 宽
img:.height() = 高
img:.size() = 返回值(宽,高)
img:.size(10,10) = 设置图片大小
img:.getTrClr() = 取透明背景色
img:.setTrClr(0) = 设置透明背景色
img:.setTrClr(false) = 禁用透明
img:.clear() = 清空图像数据(像素置0)
img:.fromHICO(hicon) = ok,x,y=img:fromHICO(hicon,md)\nmd=0或省略读取图标\nmd=1读取外观图\nmd=2 读取掩码图
img:.fromHBMP(hbmp) = 从位图句柄创建，参数2指定bpp(可选)
img:.findColor(cl,x,y,x2,y2) = 在指定范围查找颜色
img2: = >img:
-------
web = 网络库
web.new() = 创建web窗体对象，例:local wb = web.new();
web.setDL( = 初始化web窗体下载规则\nimport("std")\nwb:setDL( _DLCTL_DLIMAGES | _DLCTL_VIDEOS )
web.new("http://") = 创建web窗体并打开网址，自动调用wb.wait(),例:\nwb=web.new("http://www.ecranesoft.com");\nwb:show();
web.new("about:blank") = 创建空的web窗体，可使用wb:write()写入HTML
web.del(wb) = 删除web窗体对象
web.go(wb,"http://","") = 参数(wb,网址，框架-可省略,HTTP头-可省略,post数据-可省略)
web.go(wb,-1) = 后退
web.go(wb,+1) = 前进
web.go(wb,0) = 刷新
web.show(wb,true) = 显示或隐藏窗体
web.location(wb) = 返回当前URL
web.encodeURL("") = 使用URLEncode编码
web.decodeURL("") = URLEncode解码
web.getURL("http://") = 从指定网址下载全部数据(与web窗体无关),\n返回string
web.getURL("http://","","",":\\") = 下载文件\n最后一个参数指定保存文件，\n返回文件长度
web.getURL = @getURL("http://","Content-Type:application/x-www-form-urlencoded"," = ",nil,"Mozilla/4.0","http://");\n--参数(网址,http头,post数据,下载路径,代理,引用网址)
web.loadProc = @loadProc = function(url,wb)  end; \n--回调函数，参数(网址,web窗体 )
web.callProc = @callProc = function(ele,wb)  end; \n--回调函数，参数(element对象,web窗体 )
web.msgProc = @msgProc = function(msg,wb) return 2; end; \n--[[回调函数,参数(对话框消息，web窗体)，返回值(自动点击的按钮ID)]]
web.doScript(wb,"") = 
web.write(wb,"",true) = 
web.getWindow(wb) = 
web.getCtrl(wb) = 
web.setRect(wb,0,0,0,0) = 
web.setData(wb,"") = 
web.getData(wb) = 
web.setScroll(wb,true) = 
web.setTitle(wb,true) = 
web.setMenu(wb,false) = 
web.setSilent(wb,true,true,true,true) = 
web.setOpen(wb,false) = 
web.setFont(2) = 
web.doModal(wb,"http://") = 
web.getEle(wb,"") = 
web.eleFromPos(wb, , ) = 
web.getBody(wb) = 
web.getHtml(wb) = 
web.eleLinks(wb) = 
web.eleLinks(wb) = 
web.eleForms(wb) = 
web.eleImages(wb) = 
web.eleAll(wb) = 
web.eleScripts(wb) = 
web.wait(wb,"") = 
web.wait(wb,-1) = 
web.wait(wb,"",15000) = 
web.wait(wb,"",15000,false) = 
web.exec(wb,"",) = 
web.exec("") = 
wb:.getWindow() =  返回web窗体句柄
wb:.getCtrl() = 返回浏览器控件句柄
wb:.setRect(0,0,0,0) = 设置窗体大小，参数(左,上,右,下)
wb:.setData("") = 设置userdata节点文本
wb:.getData() = 读取userdata节点文本
wb:.setDL(  = 设置下载、执行的规则)\n需要提前设置
wb:.setScroll(true) = 是否显示滚动条)\n需要提前设置
wb:.setTitle(true) = 设置默认标题栏
wb:.setSilent(true,true,true,true) = 开启对话框静默模式，参数(组件,消息,帮助,下载文件)\n需要提前设置
wb:.setOpen(false) = 禁止打开新窗口
wb:.setMenu(false) = 是否显示右键菜单
wb:.setFont(2) = 设置字体为中号(在显示网页以后设置)
wb:.doModal("http://") = 显示模态web窗体
wb:.go("http://") =  打开网址
wb:.go("","_self","","") = 打开网址，参数(网址,目标框架,HTTP头,post数据)
wb:.go(-1) = 后退
wb:.go(+1) = 前进
wb:.go(0) = 刷新
wb:.show(true) = 显示或隐藏窗体
wb:.location() = 返回当前URL
wb:.getEle("") = 指定id或name属性返回一个或多个HTML标签(element对象)/n如果指定空名称返回body标签
wb:.eleFromPos( , ) = 获取指定坐标的HTML标签
wb:.getBody() = 获取body源代码
wb:.getHtml() = 读取全部源代码
wb:.eleLinks() = 获取超链接element对象列表
wb:.eleForms() = 获取表单element对象列表
wb:.eleImages() = 获取图像element对象列表
wb:.eleAll() = 页面全部element对象列表
wb:.eleScripts() = 页面脚本element对象列表
wb:.doScript("","javascript")  = 执行客户端脚本，最后一个参数可忽略
wb:.write() = 关闭输出流
wb:.write("") = 追加内容
wb:.write( ,true) =  输出到页面,参数(写放代码,关闭输出流)
wb:.wait("") = 等待网页打开，参数(等待的网址-可忽略)
wb:.wait("",15000) = 参数(等待网址，自动刷新间隔 - 毫秒)
wb:.wait("",15000,false) = 参数(等待网址,等待时间,是否刷新),失败返回nil
wb:.wait(-1) = 等待web窗体关闭
wb:.exec("SaveAs",":\\" ) = 执行命令
wb:.exec("Copy") = 执行命令
wb2: = >wb:
element.del(ele) =  释放el对象
ele:.ok() = 是否有效的对象
ele:.getHtml() = 获取HTML标签全部源代码(outerHTML)
ele:.setHtml("") =  设置HTML标签全部源代码(outerHTML)
ele:.getHtmlin() = 获取HTML标签包含源代码(innerHTML)
ele:.setHtmlin("") = 设置HTML标签包含源代码(innerHTML)
ele:.getText() = 获取标签全部文本(outerText)
ele:.setText("") = 设置标签全部文本(outerText)
ele:.getTextin() = 获取标签包含文本(innerText)
ele:.setTextin("") = 设置标签包含文本(innerText)
ele:.click() = 点击标签触发click事件
ele:.submit() = 提交表单(ele必须是form节点或input节点)
ele:.form() = 读取当前form表单(适用于input节点)
ele:.getAttribute("") = 获取指定的属性
ele:.setAttribute("","") =  设置指定的属性
ele:.getRect() = 例: local x,y,cx,cy = ele:getRect()
ele:.parent() = 返回父标签
ele:.getWindow() = 返回窗体句柄
ele:.adjacentHtml("beforeBegin",) = 在指定位置插入HTML
ele:.adjacentHtml("afterEnd",) =  在指定位置插入HTML
ele:.adjacentText("afterBegin",) =  在指定位置插入文本
ele:.adjacentText("beforeEnd",) = 在指定位置插入文本
ele:.class() = 类名
ele:.tag() = 标签名
ele:.id() = id属性
ele:.exec("SaveAs",":\\" ) = 执行命令
ele:.exec("Copy") = 执行命令
ele:.childs() = 返回所有子节点为一组element对象
ele2: = >ele:
_set[""] = 自定义属性列表,table变量
stopPlay = 停止回调函数
common = 共享数据区
common.read("tmp") = 读取共享数据
common.write("tmp","") = 写入共享数据
common.clear() =  删除全部共享数据
regist.open("HKEY_LOCAL_MACHINE\\") = 打开注册表返回regist对象
regist.close(reg) = 关闭注册表
reg:.setValue(str,"REG_MULTI_SZ") = 写入复合字符串
reg:.setValue(str,"REG_BINARY") = 写入二进制字符串
reg:.setValue("","") = 写入字符串
reg:.setValue("",0) = 写入数值
reg:.getValue("") = 读取字符串或数值\nvar,varType = reg:getValue("")
reg:.delValue("") = 删除值
reg:.delKey("") = 删除键
reg:.enumKey(1) = 枚举子键
reg:.enumValue(1) = 枚举值项\nvarName,varType = reg:enumValue(1)
reg:.hkey() = 注册表注柄，供API函数使用
reg:.wait(true,true,true,true,true) = 等待注册表发生改变\n参数(包含子项,监视值,监视名称增删,监视键属性，监视安全设置)
reg2: = >reg:
regist = 注册表操作
urlparse.new("http://") = 创建url解析器
urlparse.del(url) = 删除url解析器
url:.location("http://") =  设置当前页面路径(据此自动转换相对路径为绝对径)
url:.split("http://") = 解析新的网址
url:.scheme() = 协议头
url:.host() = 主机
url:.port() = 端口(数值)
url:.path() = 路径
url:.user() = 用户名
url:.password() = 密码
url:.extra() = 附加参数等
urlparse = url分析
link.new( "","","","") = 创建快捷方式\nlnk=link.new(_FAPPATH,"组","程序","注释")
lnk:.toMenu() = 添加到开始菜单
lnk:.toDesktop() = 添加到桌面
lnk:.getMenu() = 
lnk:.getDesktop() = 
link=快捷方式
namespace("");  = 创建新的名称空间
namespace("",_G); = 继承自全局环境表
namespace("_G");  = 回到全局坏境表
-----libs
email.new("@","","") = 例:\nem=email.new("web@yhhe.net","nickname","title");
em:.addText("") = 添加文本
em:.addHtml("") = 添加html
em:.addFile(":\\") = 添加附件
em:.addMail("@") = 添加目标邮件地址
em:.send("smtp","","") = 例:\nok,errmsg=em:send("smtp.qq.com","10000","密码");
em2: = >em:
email = 导入email插件：import("email") 
bigint("") = 创建大数\nbn=bigint("0xAC")
bn:.tostring() = 
bn:.tohex() = 
bn:.len() = 
bn:.encode(str) = 字符串转换为大数
bn:.decode() =  还原为字符串
bn:.raskey(512) = n,e=d:raskey(512); 
bn:.rasencode(n,e) = ras加密
bn:.rasdecode(d,e) = ras解密
bn:.decode()
bn2: = >bn:
bigint = @import("bigint") 
md5(,16) = 
md5("") = 
md5.encode(str,"k","seed") = 加密
md5.decode(str,"k") = 解密
md5 = @import("md5") 
clean.IE(true,true) = 清IE(临时文件,cookies)
clean.IE(true,true,"www") = 清IE(临时文件,cookies,指定域名)
clean.regKey("HKEY_CURRENT_USER\\") = 清理注册表指定项
clean.file(":\\","*.*") = 
clean.dir(":\\","desktop.ini") = 强制删除desktop.ini
clean.dir(":\\") = 
clean = @import("clean") 
net.load_assembly("") = 引用.net程序集
net.import_type("") = 引用类
net.System.Windows.Forms = 
net = @import("net") 
comx.CreateObject("") = 创建com对象
comx.GetObject("") = 获取com对象
comx = @import("comx") 
pop3.new("") = 例:\np3,errmsg=pop3.new("mail.yhhe.net");
pop3.new("",110) = 参数(pop3服务器,端口号)
p3:.login("","") = ok,errmsg=p3:login("用户名","密码")
p3:.login("","",true) = APOP登录
p3:.list() = tab,errmsg=p3:list();
p3:.mail( = tab,errmsg=p3:mail(1);
p3:.remove( = ok,errmsg = p3:remove(1);
p3:.reset() = ok,errmsg = p3:reset();
pop3 = @import("pop3") 
-----libs
std.dump("") = 将LAS文件预编译为二进制
std.dofile("") = 查找并执行LAS文件
std.loadfile("") = 查找并载入LAS文件、返回函数对象
std.table.new(tab) = 以继承方式创建新的table
std.table.copy(tab) = 以复制方式创建新的table
std.string.getGUID() = 返回全球唯一标识(GUID)
std.string.random(10,"") = 参数(长度,字符串集合)
std.string.random(10) = 参数(随机字符串长度)
string.getGUID() = import("std");\nstr = string.getGUID();
string.random(10,"") = 参数(长度,字符串集合)\n需std库
string.random(10) = 参数(随机字符串长度)\n需std库
std.win.gfind  = 参考forw模板
win.gfind  = 参考forw模板
std.import2("","http") = 参数(要导入外部库，下载路径)
import2 = @std.import2("","http://www.ecranesoft.com/ape/import/")
std.class() = 创建新的类
class = @namespace("myclass",std.class);
std = @import("std") --载入Fairy_Ape\import\std.las脚本库
_S_OK = 需std库
_S_FALSE = 需std库
_DLCTL_DLIMAGES = 需std库
_DLCTL_VIDEOS = 需std库
_DLCTL_BGSOUNDS = 需std库
_DLCTL_NO_SCRIPTS = 需std库
_DLCTL_NO_JAVA = 需std库
_DLCTL_NO_RUNACTIVEXCTLS = 需std库
_DLCTL_NO_DLACTIVEXCTLS = 需std库
_DLCTL_DOWNLOADONLY = 需std库
_DLCTL_NO_FRAMEDOWNLOAD = 需std库
_DLCTL_RESYNCHRONIZE = 需std库
_DLCTL_PRAGMA_NO_CACHE = 需std库
_DLCTL_NO_BEHAVIORS = 需std库
_DLCTL_NO_METACHARSET = 需std库
_DLCTL_URL_ENCODING_DISABLE_UTF8= 
_DLCTL_URL_ENCODING_ENABLE_UTF8 = 需std库
_DLCTL_NOFRAMES = 需std库
_DLCTL_FORCEOFFLINE = 需std库
_DLCTL_NO_CLIENTPULL = 需std库
_DLCTL_SILENT = 需std库
_DLCTL_OFFLINEIFNOTCONNECTED = 需std库
_DLCTL_OFFLINE = 需std库
_MIX_COPY = 需std库
_MIX_MASK = 需std库
_MIX_DSTMASK = 需std库
_MIX_SRCMASK = 需std库
_MIX_SRCMASK2 = 需std库
_MIX_DSTBLEND = 需std库
_MIX_SCREEN = 需std库
_MIX_ADD = 需std库
_MIX_SUB = 需std库
_MIX_AND = 需std库
_MIX_XOR = 需std库
_MIX_OR = 需std库
_SW_HIDE = 需std库
_SW_NORMAL = 需std库
_SW_SHOWMINIMIZED = 需std库
_SW_MAXIMIZE = 需std库
_SW_SHOWNOACTIVATE = 需std库
_SW_SHOW = 需std库
_SW_MINIMIZE = 需std库
_SW_SHOWMINNOACTIVE= 需std库
_SW_SHOWNA = 需std库
_SW_RESTORE = 需std库
_SW_SHOWDEFAULT = 需std库
_SW_MAX = 需std库
_MEM_MAPPED = 需std库
_MEM_PRIVATE = 需std库
_MEM_MAPPED = 需std库
_PAGE_NOACCESS = 需std库
_PAGE_READONLY = 需std库
_PAGE_READWRITE = 需std库
_PAGE_WRITECOPY = 需std库
_PAGE_EXECUTE = 需std库
_PAGE_EXECUTE_READ= 需std库
_PAGE_EXECUTE_READWRITE = 需std库
_PAGE_EXECUTE_WRITECOPY = 需std库
_PAGE_GUARD = 需std库
_PAGE_NOCACHE = 需std库
_PAGE_WRITECOMBINE= 需std库
_CP_ACP = 需std库
_CP_OEMCP = 需std库
_CP_MACCP = 需std库
_CP_THREAD_ACP= 需std库
_CP_SYMBOL = 需std库
_CP_UTF7 = 需std库
_CP_UTF8 = 需std库
_CP_CHS = 需std库
_CP_CHT = 需std库
_FATTR_READONLY = 需std库
_FATTR_HIDDEN = 需std库
_FATTR_SYSTEM = 需std库
_FATTR_DIRECTORY = 需std库
_FATTR_ARCHIVE = 需std库
_FATTR_DEVICE = 需std库
_FATTR_NORMAL = 需std库
_FATTR_TEMPORARY = 需std库
_FATTR_SPARSE_FILE = 需std库
_FATTR_REPARSE_POINT = 需std库
_FATTR_COMPRESSED = 需std库
_FATTR_OFFLINE = 需std库
_FATTR_NOT_CONTENT_INDEXED = 需std库
_FATTR_ENCRYPTED = 需std库