百度点击快排源码(e语言拨号模拟点击)

cesc
                           

百度搜索打击点击快排,错误博客( cuowu.com )公布这些源码也是为了方便大家学习与交流。希望对大家有所帮助。

百度点击快排源码
百度点击快排源码

.版本 2
.支持库 iext
.支持库 RegEx
.支持库 shell

.程序集 窗口程序集_启动窗口
.程序集变量 开关_自动换IP, 整数型
.程序集变量 开关_过滤重复IP, 整数型
.程序集变量 开关_进站前随机刷新, 整数型
.程序集变量 开关_进站前随机点击, 整数型
.程序集变量 开关_进站后随机点击, 整数型
.程序集变量 开关_任务超时停止, 整数型
.程序集变量 开关_失败几次跳过, 整数型
.程序集变量 开关_开启时段点击, 整数型
.程序集变量 开关_随机任务顺序, 整数型
.程序集变量 开关_定时清理垃圾, 整数型
.程序集变量 开关_定时保存数据, 整数型
.程序集变量 开关_随机分辨率, 整数型
.程序集变量 开关_清理缓存, 整数型
.程序集变量 开关_随机浏览器UA, 整数型
.程序集变量 开关_随机浏览器指纹, 整数型
.程序集变量 开关_随机CPU信息, 整数型
.程序集变量 开关_随机Cookies, 整数型
.程序集变量 程序停止运行, 整数型
.程序集变量 连续失败次数, 整数型
.程序集变量 当前IP, 文本型
.程序集变量 点击成功次数, 整数型

.子程序 _获取chrome按钮_被单击
.局部变量 chrome路径, 文本型

chrome路径 = “C:\Users\Administrator\AppData\Local\Google\Chrome\Application\chrome.exe”
.如果 (文件是否存在 (chrome路径) = 真)
编辑框_chrome路径.内容 = chrome路径
.否则
信息框 (“没有检测到chrome路径,请确认安装后手动复制路径”, 0, , )
.如果结束

.子程序 _按钮6_被单击

保存配置列表到ini ()

.子程序 写设置
.参数 node, 文本型
.参数 name, 文本型
.参数 vaule, 文本型

.如果真 (vaule ≠ “”)
写配置项 (取运行目录 () + “\config.ini”, node, name, vaule)
.如果真结束

.子程序 读设置, 文本型
.参数 node, 文本型
.参数 name, 文本型
.局部变量 vaule, 文本型

vaule = 读配置项 (取运行目录 () + “\config.ini”, node, name, )

返回 (vaule)

.子程序 _按钮4_被单击

载入 (时段窗口, , 真)

.子程序 _任务列表框_右键单击表项

弹出菜单 (列表项右键, , )

.子程序 _运行当前序号开始_被选择

.如果真 (任务列表框.现行选中项 ≠ -1)
‘ 根据ID开始任务(id)
.如果真结束

.子程序 _添加任务_被选择

载入 (添加任务窗口, , 真)

.子程序 _导入文件_被选择
.局部变量 txt文件内容, 文本型
.局部变量 局_表项, 整数型
.局部变量 i, 整数型
.局部变量 文本数组, 文本型, , “0”
.局部变量 e, 整数型
.局部变量 文本数组2, 文本型, , “0”
.局部变量 行, 整数型

通用对话框_导入.初始目录 = 取运行目录 ()
通用对话框_导入.打开 ()
txt文件内容 = 到文本 (读入文件 (通用对话框_导入.文件名))
.如果真 (txt文件内容 ≠ “”)
文本数组 = 分割文本 (txt文件内容, #换行符, )
行 = 任务列表框.取表项数 () + 1

.计次循环首 (取数组成员数 (文本数组), i)
文本数组2 = 分割文本 (文本数组 [i], “|”, )
局_表项 = _启动窗口.任务列表框.插入表项 (, 到文本 (e), , , , )
_启动窗口.任务列表框.置标题 (局_表项, 0, 到文本 (行))

.计次循环首 (取数组成员数 (文本数组2), e)

.如果真 (取数组成员数 (文本数组2) = 2)
_启动窗口.任务列表框.置标题 (局_表项, 1, 文本数组2 [1])
_启动窗口.任务列表框.置标题 (局_表项, 2, 文本数组2 [1])
_启动窗口.任务列表框.置标题 (局_表项, 3, 文本数组2 [2])
_启动窗口.任务列表框.置标题 (局_表项, 5, “999”)
.如果真结束
.如果真 (取数组成员数 (文本数组2) = 3)
_启动窗口.任务列表框.置标题 (局_表项, 1, 文本数组2 [1])
_启动窗口.任务列表框.置标题 (局_表项, 2, 文本数组2 [1])
_启动窗口.任务列表框.置标题 (局_表项, 3, 文本数组2 [2])
_启动窗口.任务列表框.置标题 (局_表项, 5, 文本数组2 [3])
.如果真结束
.如果真 (取数组成员数 (文本数组2) ≥ 4)
_启动窗口.任务列表框.置标题 (局_表项, 1, 文本数组2 [1])
_启动窗口.任务列表框.置标题 (局_表项, 2, 文本数组2 [2])
_启动窗口.任务列表框.置标题 (局_表项, 3, 文本数组2 [3])
_启动窗口.任务列表框.置标题 (局_表项, 5, 文本数组2 [4])
.如果真结束

.计次循环尾 ()

行 = 行 + 1
.计次循环尾 ()
.如果真结束

.子程序 _导入剪辑板_被选择
.局部变量 txt文件内容, 文本型

txt文件内容 = 取剪辑板文本 ()

.子程序 _删除任务_被选择

.如果真 (任务列表框.现行选中项 ≠ -1)
任务列表框.删除表项 (任务列表框.现行选中项)
.如果真结束

.子程序 _清空任务_被选择

任务列表框.全部删除 ()

.子程序 _导出文件_被选择
.局部变量 行, 整数型
.局部变量 txt文件内容, 文本型

.计次循环首 (任务列表框.取表项数 (), 行)
txt文件内容 = txt文件内容 + 任务列表框.取标题 (行 - 1, 1) + “|” + 任务列表框.取标题 (行 - 1, 2) + “|” + 任务列表框.取标题 (行 - 1, 3) + “|” + 任务列表框.取标题 (行 - 1, 5) + #换行符
.计次循环尾 ()

通用对话框_写出.初始目录 = 取运行目录 ()
通用对话框_写出.文件名 = “任务数据:” + 到文本 (取年份 (取现行时间 ())) + “-” + 到文本 (取月份 (取现行时间 ())) + “-” + 到文本 (取日 (取现行时间 ()))
.如果真 (通用对话框_写出.打开 ())
写到文件 (通用对话框_写出.文件名, 到字节集 (txt文件内容))
.如果真结束

.子程序 生成随机数, 文本型, , 此代码段来自精易模块,有小小的改动
.参数 随机数长度, 整数型, 可空
.局部变量 返回的文本, 文本型

.如果 (随机数长度 = 0)
随机数长度 = 1 ‘ 随机数长度,为空则默认是 1
.计次循环首 (随机数长度, )
返回的文本 = 返回的文本 + 到文本 (多项选择 (取随机数 (1, 9), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)) ‘ 这里不做解释,单行调试,自己体会
.计次循环尾 ()

.否则

.计次循环首 (随机数长度, )
返回的文本 = 返回的文本 + 到文本 (多项选择 (取随机数 (1, 9), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9))
.计次循环尾 ()
.如果结束
返回 (返回的文本)

.子程序 _修改任务_被选择
.局部变量 行, 整数型
.局部变量 txt文件内容, 文本型

行 = 任务列表框.现行选中项

.如果真 (行 ≠ -1)
txt文件内容 = 任务列表框.取标题 (行, 1) + “|” + 任务列表框.取标题 (行, 2) + “|” + 任务列表框.取标题 (行, 3) + “|” + 任务列表框.取标题 (行, 5)
.如果真 (txt文件内容 ≠ “”)
‘ 全局变量
待编辑任务行 = 行
待编辑任务内容 = txt文件内容

载入 (添加任务窗口, , 真)
.如果真结束
‘ 调试输出 (txt文件内容)
‘ 调试输出 (到文本 (待编辑任务行))

.如果真结束

.子程序 保存任务列表到dat
.局部变量 行, 整数型
.局部变量 txt文件内容, 文本型
.局部变量 行内容, 文本型

.计次循环首 (任务列表框.取表项数 (), 行)
行内容 = 任务列表框.取标题 (行 - 1, 0) + “|” + 任务列表框.取标题 (行 - 1, 1) + “|” + 任务列表框.取标题 (行 - 1, 2) + “|” + 任务列表框.取标题 (行 - 1, 3) + “|” + 任务列表框.取标题 (行 - 1, 4) + “|” + 任务列表框.取标题 (行 - 1, 5) + “|” + 任务列表框.取标题 (行 - 1, 6) + #换行符
txt文件内容 = txt文件内容 + 行内容

.计次循环尾 ()
.如果真 (txt文件内容 ≠ “”)
写到文件 (取运行目录 () + “\list.dat”, 到字节集 (txt文件内容))
.如果真结束

.子程序 保存配置列表到ini

写设置 (“编辑框”, “编辑框_chrome路径”, 编辑框_chrome路径.内容)
写设置 (“编辑框”, “编辑框_宽带名称”, 编辑框_宽带名称.内容)
写设置 (“编辑框”, “编辑框_宽带账号”, 编辑框_宽带账号.内容)
写设置 (“编辑框”, “编辑框_宽带密码”, 编辑框_宽带密码.内容)
写设置 (“编辑框”, “编辑框_拨号间隔”, 编辑框_拨号间隔.内容)
写设置 (“编辑框”, “编辑框_站外停留延迟1”, 编辑框_站外停留延迟1.内容)
写设置 (“编辑框”, “编辑框_站外停留延迟2”, 编辑框_站外停留延迟2.内容)
写设置 (“编辑框”, “编辑框_站内停留延迟1”, 编辑框_站内停留延迟1.内容)
写设置 (“编辑框”, “编辑框_站内停留延迟2”, 编辑框_站内停留延迟2.内容)
写设置 (“编辑框”, “编辑框_最大搜索页数”, 编辑框_最大搜索页数.内容)
写设置 (“编辑框”, “编辑框_进站前随机刷新1”, 编辑框_进站前随机刷新1.内容)
写设置 (“编辑框”, “编辑框_进站前随机刷新2”, 编辑框_进站前随机刷新2.内容)
写设置 (“编辑框”, “编辑框_进站前随机点击1”, 编辑框_进站前随机点击1.内容)
写设置 (“编辑框”, “编辑框_进站前随机点击2”, 编辑框_进站前随机点击2.内容)
写设置 (“编辑框”, “编辑框_进站后随机点击1”, 编辑框_进站后随机点击1.内容)
写设置 (“编辑框”, “编辑框_进站后随机点击2”, 编辑框_进站后随机点击2.内容)
写设置 (“编辑框”, “编辑框_任务超时停止”, 编辑框_任务超时停止.内容)
写设置 (“编辑框”, “编辑框_失败几次跳过”, 编辑框_失败几次跳过.内容)
写设置 (“编辑框”, “编辑框_定时清理垃圾”, 编辑框_定时清理垃圾.内容)
写设置 (“编辑框”, “编辑框_定时保存数据”, 编辑框_定时保存数据.内容)

.如果 (选择框_自动换IP.选中 = 真)
写设置 (“选择框”, “选择框_自动换IP”, “1”)
.否则
写设置 (“选择框”, “选择框_自动换IP”, “0”)
.如果结束

.如果 (选择框_过滤重复IP.选中 = 真)
写设置 (“选择框”, “选择框_过滤重复IP”, “1”)
.否则
写设置 (“选择框”, “选择框_过滤重复IP”, “0”)
.如果结束

.如果 (选择框_进站前随机刷新.选中 = 真)
写设置 (“选择框”, “选择框_进站前随机刷新”, “1”)
.否则
写设置 (“选择框”, “选择框_进站前随机刷新”, “0”)
.如果结束

.如果 (选择框_进站前随机点击.选中 = 真)
写设置 (“选择框”, “选择框_进站前随机点击”, “1”)
.否则
写设置 (“选择框”, “选择框_进站前随机点击”, “0”)
.如果结束

.如果 (选择框_进站后随机点击.选中 = 真)
写设置 (“选择框”, “选择框_进站后随机点击”, “1”)
.否则
写设置 (“选择框”, “选择框_进站后随机点击”, “0”)
.如果结束

.如果 (选择框_任务超时停止.选中 = 真)
写设置 (“选择框”, “选择框_任务超时停止”, “1”)
.否则
写设置 (“选择框”, “选择框_任务超时停止”, “0”)
.如果结束

.如果 (选择框_失败几次跳过.选中 = 真)
写设置 (“选择框”, “选择框_失败几次跳过”, “1”)
.否则
写设置 (“选择框”, “选择框_失败几次跳过”, “0”)
.如果结束

.如果 (选择框_开启时段点击.选中 = 真)
写设置 (“选择框”, “选择框_开启时段点击”, “1”)
.否则
写设置 (“选择框”, “选择框_开启时段点击”, “0”)
.如果结束

.如果 (选择框_随机任务顺序.选中 = 真)
写设置 (“选择框”, “选择框_随机任务顺序”, “1”)
.否则
写设置 (“选择框”, “选择框_随机任务顺序”, “0”)
.如果结束

.如果 (选择框_定时清理垃圾.选中 = 真)
写设置 (“选择框”, “选择框_定时清理垃圾”, “1”)
.否则
写设置 (“选择框”, “选择框_定时清理垃圾”, “0”)
.如果结束

.如果 (选择框_定时保存数据.选中 = 真)
写设置 (“选择框”, “选择框_定时保存数据”, “1”)
.否则
写设置 (“选择框”, “选择框_定时保存数据”, “0”)
.如果结束

.如果 (选择框_随机分辨率.选中 = 真)
写设置 (“选择框”, “选择框_随机分辨率”, “1”)
.否则
写设置 (“选择框”, “选择框_随机分辨率”, “0”)
.如果结束

.如果 (选择框_清理缓存.选中 = 真)
写设置 (“选择框”, “选择框_清理缓存”, “1”)
.否则
写设置 (“选择框”, “选择框_清理缓存”, “0”)
.如果结束

.如果 (选择框_随机浏览器UA.选中 = 真)
写设置 (“选择框”, “选择框_随机浏览器UA”, “1”)
.否则
写设置 (“选择框”, “选择框_随机浏览器UA”, “0”)
.如果结束

.如果 (选择框_随机浏览器指纹.选中 = 真)
写设置 (“选择框”, “选择框_随机浏览器指纹”, “1”)
.否则
写设置 (“选择框”, “选择框_随机浏览器指纹”, “0”)
.如果结束

.如果 (选择框_随机CPU信息.选中 = 真)
写设置 (“选择框”, “选择框_随机CPU信息”, “1”)
.否则
写设置 (“选择框”, “选择框_随机CPU信息”, “0”)
.如果结束

.如果 (选择框_随机Cookies.选中 = 真)
写设置 (“选择框”, “选择框_随机Cookies”, “1”)
.否则
写设置 (“选择框”, “选择框_随机Cookies”, “0”)
.如果结束

.子程序 __启动窗口_创建完毕
.局部变量 任务文件内容, 文本型
.局部变量 任务文件路径, 文本型
.局部变量 文本数组, 文本型, , “0”
.局部变量 i, 整数型
.局部变量 文本数组2, 文本型, , “0”
.局部变量 局_表项, 整数型
.局部变量 行, 整数型
.局部变量 e, 整数型
.局部变量 配置文件路径, 文本型
.局部变量 宽带名称, 文本型
.局部变量 宽带账号, 文本型
.局部变量 宽带密码, 文本型
.局部变量 chrome路径, 文本型
.局部变量 拨号间隔, 文本型
.局部变量 站外停留延迟1, 文本型
.局部变量 站外停留延迟2, 文本型
.局部变量 站内停留延迟1, 文本型
.局部变量 最大搜索页数, 文本型
.局部变量 进站前随机刷新1, 文本型
.局部变量 进站前随机刷新2, 文本型
.局部变量 进站前随机点击1, 文本型
.局部变量 进站前随机点击2, 文本型
.局部变量 进站后随机点击1, 文本型
.局部变量 进站后随机点击2, 文本型
.局部变量 任务超时停止时间, 文本型
.局部变量 失败几次跳过时间, 文本型
.局部变量 定时清理垃圾时间, 文本型
.局部变量 定时保存数据时间, 文本型
.局部变量 站内停留延迟2, 文本型

‘ 载入配置文件
配置文件路径 = 取运行目录 () + “\config.ini”
.如果真 (文件是否存在 (配置文件路径) = 真)
‘ 载入编辑框设置
宽带名称 = 读设置 (“编辑框”, “编辑框_宽带名称”)
.如果真 (宽带名称 ≠ “”)
编辑框_宽带名称.内容 = 宽带名称
.如果真结束

宽带账号 = 读设置 (“编辑框”, “编辑框_宽带账号”)
.如果真 (宽带账号 ≠ “”)
编辑框_宽带账号.内容 = 宽带账号
.如果真结束

宽带密码 = 读设置 (“编辑框”, “编辑框_宽带密码”)
.如果真 (宽带密码 ≠ “”)
编辑框_宽带密码.内容 = 宽带密码
.如果真结束

chrome路径 = 读设置 (“编辑框”, “编辑框_chrome路径”)
.如果真 (chrome路径 ≠ “”)
编辑框_chrome路径.内容 = chrome路径
.如果真结束
拨号间隔 = 读设置 (“编辑框”, “编辑框_拨号间隔”)

.如果真 (拨号间隔 ≠ “”)
编辑框_拨号间隔.内容 = 拨号间隔
.如果真结束

站外停留延迟1 = 读设置 (“编辑框”, “编辑框_站外停留延迟1”)
.如果真 (站外停留延迟1 ≠ “”)
编辑框_站外停留延迟1.内容 = 站外停留延迟1
.如果真结束

站外停留延迟2 = 读设置 (“编辑框”, “编辑框_站外停留延迟2”)
.如果真 (站外停留延迟2 ≠ “”)
编辑框_站外停留延迟2.内容 = 站外停留延迟2
.如果真结束

站内停留延迟1 = 读设置 (“编辑框”, “编辑框_站内停留延迟1”)
.如果真 (站内停留延迟1 ≠ “”)
编辑框_站内停留延迟1.内容 = 站内停留延迟1
.如果真结束
站内停留延迟2 = 读设置 (“编辑框”, “编辑框_站内停留延迟2”)

.如果真 (站内停留延迟2 ≠ “”)
编辑框_站内停留延迟2.内容 = 站内停留延迟2
.如果真结束

最大搜索页数 = 读设置 (“编辑框”, “编辑框_最大搜索页数”)
.如果真 (最大搜索页数 ≠ “”)
编辑框_最大搜索页数.内容 = 最大搜索页数
.如果真结束

进站前随机刷新1 = 读设置 (“编辑框”, “编辑框_进站前随机刷新1”)
.如果真 (进站前随机刷新1 ≠ “”)
编辑框_进站前随机刷新1.内容 = 进站前随机刷新1
.如果真结束

进站前随机刷新2 = 读设置 (“编辑框”, “编辑框_进站前随机刷新2”)
.如果真 (进站前随机刷新2 ≠ “”)
编辑框_进站前随机刷新2.内容 = 进站前随机刷新2
.如果真结束

进站前随机点击1 = 读设置 (“编辑框”, “编辑框_进站前随机点击1”)
.如果真 (进站前随机点击1 ≠ “”)
编辑框_进站前随机点击1.内容 = 进站前随机点击1
.如果真结束

进站前随机点击2 = 读设置 (“编辑框”, “编辑框_进站前随机点击2”)
.如果真 (进站前随机点击2 ≠ “”)
编辑框_进站前随机点击2.内容 = 进站前随机点击2
.如果真结束

进站后随机点击1 = 读设置 (“编辑框”, “编辑框_进站后随机点击1”)
.如果真 (进站后随机点击1 ≠ “”)
编辑框_进站后随机点击1.内容 = 进站后随机点击1
.如果真结束

进站后随机点击2 = 读设置 (“编辑框”, “编辑框_进站后随机点击2”)
.如果真 (进站后随机点击2 ≠ “”)
编辑框_进站后随机点击2.内容 = 进站后随机点击2
.如果真结束

任务超时停止时间 = 读设置 (“编辑框”, “编辑框_任务超时停止”)
.如果真 (任务超时停止时间 ≠ “”)
编辑框_任务超时停止.内容 = 任务超时停止时间
.如果真结束

失败几次跳过时间 = 读设置 (“编辑框”, “编辑框_失败几次跳过”)
.如果真 (失败几次跳过时间 ≠ “”)
编辑框_失败几次跳过.内容 = 失败几次跳过时间
.如果真结束

定时清理垃圾时间 = 读设置 (“编辑框”, “编辑框_定时清理垃圾”)
.如果真 (定时清理垃圾时间 ≠ “”)
编辑框_定时清理垃圾.内容 = 定时清理垃圾时间
.如果真结束

定时保存数据时间 = 读设置 (“编辑框”, “编辑框_定时保存数据”)
.如果真 (定时保存数据时间 ≠ “”)
编辑框_定时保存数据.内容 = 定时保存数据时间
.如果真结束

‘ 载入开关配置
开关_自动换IP = 到数值 (读设置 (“选择框”, “选择框_自动换IP”))
.如果 (开关_自动换IP = 1)
选择框_自动换IP.选中 = 真
.否则
选择框_自动换IP.选中 = 假
.如果结束

开关_过滤重复IP = 到数值 (读设置 (“选择框”, “选择框_过滤重复IP”))
.如果 (开关_过滤重复IP = 1)
选择框_过滤重复IP.选中 = 真
.否则
选择框_过滤重复IP.选中 = 假
.如果结束

开关_进站前随机刷新 = 到数值 (读设置 (“选择框”, “选择框_进站前随机刷新”))
.如果 (开关_进站前随机刷新 = 1)
选择框_进站前随机刷新.选中 = 真
.否则
选择框_进站前随机刷新.选中 = 假
.如果结束

开关_进站前随机点击 = 到数值 (读设置 (“选择框”, “选择框_进站前随机点击”))
.如果 (开关_进站前随机点击 = 1)
选择框_进站前随机点击.选中 = 真
.否则
选择框_进站前随机点击.选中 = 假
.如果结束

开关_进站后随机点击 = 到数值 (读设置 (“选择框”, “选择框_进站后随机点击”))
.如果 (开关_进站后随机点击 = 1)
选择框_进站后随机点击.选中 = 真
.否则
选择框_进站后随机点击.选中 = 假
.如果结束

开关_任务超时停止 = 到数值 (读设置 (“选择框”, “选择框_任务超时停止”))
.如果 (开关_任务超时停止 = 1)
选择框_任务超时停止.选中 = 真
.否则
选择框_任务超时停止.选中 = 假
.如果结束

开关_失败几次跳过 = 到数值 (读设置 (“选择框”, “选择框_失败几次跳过”))
.如果 (开关_失败几次跳过 = 1)
选择框_失败几次跳过.选中 = 真
.否则
选择框_失败几次跳过.选中 = 假
.如果结束

开关_开启时段点击 = 到数值 (读设置 (“选择框”, “选择框_开启时段点击”))
.如果 (开关_开启时段点击 = 1)
选择框_开启时段点击.选中 = 真
.否则
选择框_开启时段点击.选中 = 假
.如果结束

开关_随机任务顺序 = 到数值 (读设置 (“选择框”, “选择框_随机任务顺序”))
.如果 (开关_随机任务顺序 = 1)
选择框_随机任务顺序.选中 = 真
.否则
选择框_随机任务顺序.选中 = 假
.如果结束

开关_定时清理垃圾 = 到数值 (读设置 (“选择框”, “选择框_定时清理垃圾”))
.如果 (开关_定时清理垃圾 = 1)
选择框_定时清理垃圾.选中 = 真
.否则
选择框_定时清理垃圾.选中 = 假
.如果结束

开关_定时保存数据 = 到数值 (读设置 (“选择框”, “选择框_定时保存数据”))
.如果 (开关_定时保存数据 = 1)
选择框_定时保存数据.选中 = 真
.否则
选择框_定时保存数据.选中 = 假
.如果结束

开关_随机分辨率 = 到数值 (读设置 (“选择框”, “选择框_随机分辨率”))
.如果 (开关_随机分辨率 = 1)
选择框_随机分辨率.选中 = 真
.否则
选择框_随机分辨率.选中 = 假
.如果结束

开关_清理缓存 = 到数值 (读设置 (“选择框”, “选择框_清理缓存”))
.如果 (开关_清理缓存 = 1)
选择框_清理缓存.选中 = 真
.否则
选择框_清理缓存.选中 = 假
.如果结束

开关_随机浏览器UA = 到数值 (读设置 (“选择框”, “选择框_随机浏览器UA”))
.如果 (开关_随机浏览器UA = 1)
选择框_随机浏览器UA.选中 = 真
.否则
选择框_随机浏览器UA.选中 = 假
.如果结束

开关_随机浏览器指纹 = 到数值 (读设置 (“选择框”, “选择框_随机浏览器指纹”))
.如果 (开关_随机浏览器指纹 = 1)
选择框_随机浏览器指纹.选中 = 真
.否则
选择框_随机浏览器指纹.选中 = 假
.如果结束

开关_随机CPU信息 = 到数值 (读设置 (“选择框”, “选择框_随机CPU信息”))
.如果 (开关_随机CPU信息 = 1)
选择框_随机CPU信息.选中 = 真
.否则
选择框_随机CPU信息.选中 = 假
.如果结束

开关_随机Cookies = 到数值 (读设置 (“选择框”, “选择框_随机Cookies”))
.如果 (开关_随机Cookies = 1)
选择框_随机Cookies.选中 = 真
.否则
选择框_随机Cookies.选中 = 假
.如果结束

.如果真结束

‘ 载入任务列表
任务文件路径 = 取运行目录 () + “\list.dat”
.如果真 (文件是否存在 (任务文件路径) = 真)
任务文件内容 = 到文本 (读入文件 (任务文件路径))
.如果真 (任务文件内容 ≠ “”)
文本数组 = 分割文本 (任务文件内容, #换行符, )

.计次循环首 (取数组成员数 (文本数组), i)

局_表项 = _启动窗口.任务列表框.插入表项 (, 到文本 (i), , , , )

文本数组2 = 分割文本 (文本数组 [i], “|”, )
.计次循环首 (取数组成员数 (文本数组2), e)
任务列表框.置标题 (局_表项, e - 1, 文本数组2 [e])
.计次循环尾 ()
.计次循环尾 ()
.如果真结束

.如果真结束
.如果真 (开关_定时保存数据 = 1)
数据保存_时钟.时钟周期 = 到数值 (编辑框_定时保存数据.内容) × 60 × 1000

.如果真结束
.如果真 (开关_定时清理垃圾 = 1)
垃圾清理_时钟.时钟周期 = 到数值 (编辑框_定时清理垃圾.内容) × 60 × 1000

.如果真结束

.子程序 _按钮1_被单击, , , 获取宽带账号信息
.局部变量 连接名称, 文本型
.局部变量 宽带用户名, 文本型
.局部变量 宽带密码, 文本型

系统_取宽带用户名密码 (连接名称, 宽带用户名, 宽带密码)
.如果 (系统_取宽带用户名密码 (连接名称, 宽带用户名, 宽带密码) = 真)
编辑框_宽带名称.内容 = 连接名称
编辑框_宽带账号.内容 = 宽带用户名
编辑框_宽带密码.内容 = 宽带密码

.否则
信息框 (“没有获取到宽带账号密码,请手工填写”, 0, , )
.如果结束

.子程序 _按钮2_被单击

ADSL重拨 ()

.子程序 ADSL重拨, 逻辑型
.局部变量 ip, 文本型
.局部变量 r, 逻辑型

.如果真 (编辑框_拨号间隔.内容 ≠ “”)
程序_延时 (到数值 (编辑框_拨号间隔.内容) × 1000)
.如果真结束

.循环判断首 ()
ip = 重拨 ()
.如果 (开关_过滤重复IP = 1)
.如果 (寻找文本 (编辑框IP.内容, ip, , 假) = -1)
r = 假
编辑框IP.加入文本 (ip + #换行符)
.否则
r = 真
调试输出_新 (“当前IP出现重复,软件重新拨号…”)
.如果结束

.否则
编辑框IP.加入文本 (ip + #换行符)
r = 假
.如果结束

.循环判断尾 (r = 真)
.如果真 (ip = “0.0.0.0”)
调试输出_新 (“软件重新拨号…”)
重拨 ()
.如果真结束
返回 (真)

.子程序 重拨, 文本型
.局部变量 延迟秒数, 整数型
.局部变量 ADSL, ADSL拨号类
.局部变量 重试次数, 整数型
.局部变量 最多重试次数, 整数型
.局部变量 ip, 文本型

ADSL.断开 ()
延迟秒数 = 3
最多重试次数 = 3

调试输出_新 (“断开宽带”)
程序_延时 (延迟秒数 × 1000)
调试输出_新 (“软件延迟” + 到文本 (延迟秒数) + “秒开始换Ip”)
ADSL.拨号_cmd (编辑框_宽带名称.内容, 编辑框_宽带账号.内容, 编辑框_宽带密码.内容)

调试输出_新 (“开始拨号换Ip”)
程序_延时 (3000)
ip = 网页_取外网IP ()
程序_延时 (3000)
.如果真 (ip = “”)
.循环判断首 ()
调试输出_新 (“断开宽带”)
ADSL.断开 ()
程序_延时 (延迟秒数 × 1000)
调试输出_新 (“软件延迟” + 到文本 (延迟秒数) + “S后开始换Ip”)
ADSL.拨号_cmd (编辑框_宽带名称.内容, 编辑框_宽带账号.内容, 编辑框_宽带密码.内容)

调试输出_新 (“开始拨号换Ip”)
ip = 网页_取外网IP ()
程序_延时 (6000)
处理事件 ()
重试次数 = 重试次数 + 1
.如果真 (重试次数 = 最多重试次数)
调试输出_新 (“多次重拨失败,任务结束,请检查!”)
程序关闭 ()
返回 (“0.0.0.0”)
.如果真结束

.循环判断尾 (ip = “”)

.如果真结束

调试输出_新 (“vps拨号成功,IP地址:” + ip)

返回 (ip)

.子程序 _按钮3_被单击

写设置 (“编辑框”, “编辑框_宽带名称”, 编辑框_宽带名称.内容)
写设置 (“编辑框”, “编辑框_宽带账号”, 编辑框_宽带账号.内容)
写设置 (“编辑框”, “编辑框_宽带密码”, 编辑框_宽带密码.内容)

.子程序 _选择框_自动换IP_被单击

.如果 (选择框_自动换IP.选中)
开关_自动换IP = 1
.否则
开关_自动换IP = 0
.如果结束

.子程序 _选择框_过滤重复IP_被单击

.如果 (选择框_过滤重复IP.选中)
开关_过滤重复IP = 1
.否则
开关_过滤重复IP = 0
.如果结束

.子程序 _选择框_进站前随机刷新_被单击

.如果 (选择框_进站前随机刷新.选中)
开关_进站前随机刷新 = 1
.否则
开关_进站前随机刷新 = 0
.如果结束

.子程序 _选择框_进站前随机点击_被单击

.如果 (选择框_进站前随机点击.选中)
开关_进站前随机点击 = 1
.否则
开关_进站前随机点击 = 0
.如果结束

.子程序 _选择框_进站后随机点击_被单击

.如果 (选择框_进站后随机点击.选中)
开关_进站后随机点击 = 1
.否则
开关_进站后随机点击 = 0
.如果结束

.子程序 _选择框_任务超时停止_被单击

.如果 (选择框_任务超时停止.选中)
开关_任务超时停止 = 1
.否则
开关_任务超时停止 = 0
.如果结束

.子程序 _选择框_失败几次跳过_被单击

.如果 (选择框_失败几次跳过.选中)
开关_失败几次跳过 = 1
.否则
开关_失败几次跳过 = 0
.如果结束

.子程序 _选择框_开启时段点击_被单击

.如果 (选择框_开启时段点击.选中)
开关_开启时段点击 = 1
.否则
开关_开启时段点击 = 0
.如果结束

.子程序 _选择框_随机任务顺序_被单击

.如果 (选择框_随机任务顺序.选中)
开关_随机任务顺序 = 1
.否则
开关_随机任务顺序 = 0
.如果结束

.子程序 _选择框_定时清理垃圾_被单击

.如果 (选择框_定时清理垃圾.选中)
开关_定时清理垃圾 = 1
.否则
开关_定时清理垃圾 = 0
.如果结束

.子程序 _选择框_定时保存数据_被单击

.如果 (选择框_定时保存数据.选中)
开关_定时保存数据 = 1
.否则
开关_定时保存数据 = 0
.如果结束

.子程序 _选择框_随机分辨率_被单击

.如果 (选择框_随机分辨率.选中)
开关_随机分辨率 = 1
.否则
开关_随机分辨率 = 0
.如果结束

.子程序 _选择框_清理缓存_被单击

.如果 (选择框_清理缓存.选中)
开关_清理缓存 = 1
.否则
开关_清理缓存 = 0
.如果结束

.子程序 _选择框_随机浏览器UA_被单击

.如果 (选择框_随机浏览器UA.选中)
开关_随机浏览器UA = 1
.否则
开关_随机浏览器UA = 0
.如果结束

.子程序 _选择框_随机浏览器指纹_被单击

.如果 (选择框_随机浏览器指纹.选中)
开关_随机浏览器指纹 = 1
.否则
开关_随机浏览器指纹 = 0
.如果结束

.子程序 _选择框_随机CPU信息_被单击

.如果 (选择框_随机CPU信息.选中)
开关_随机CPU信息 = 1
.否则
开关_随机CPU信息 = 0
.如果结束

.子程序 _选择框_随机Cookies_被单击

.如果 (选择框_随机Cookies.选中)
开关_随机Cookies = 1
.否则
开关_随机Cookies = 0
.如果结束

.子程序 _开始按钮_被单击

.如果 (开始按钮.选中 = 真)
调试输出_新 (“软件使用教程: http://www.baidu.com/archives/66”)
调试输出_新 (“官方交流Q群:12345678”)
.如果真 (开关_定时清理垃圾 = 1)
调试输出_新 (“启动定时清理垃圾!定时间隔:” + 编辑框_定时清理垃圾.内容 + “分钟”)
.如果真结束
程序启动 ()
.否则
程序关闭 ()
.如果结束

 

.子程序 程序启动
.局部变量 行, 整数型
.局部变量 执行行, 整数型

程序停止运行 = 0
点击成功次数 = 0

‘ 取任务关键词
.如果真 (任务列表框.取表项数 () < 1)
信息框 (“请先导入任务”, 0, , )
返回 ()
.如果真结束

.如果真 (程序停止运行 = 1)
程序关闭 ()
返回 ()
.如果真结束

.如果 (开关_随机任务顺序 = 1)
置随机数种子 ()
执行行 = 取随机数 (1, 任务列表框.取表项数 ())
.如果 (程序停止运行 = 1)
程序关闭 ()
返回 ()
.否则
.如果真 (连续失败次数 < 3)
选择任务行执行 (执行行)
.如果真结束

.如果结束

.否则
.计次循环首 (任务列表框.取表项数 (), 行)
.如果 (程序停止运行 = 1)
跳出循环 ()
.否则
选择任务行执行 (行)
.如果结束

.计次循环尾 ()
.如果 (程序停止运行 = 1)
程序关闭 ()
.否则
程序启动 () ‘ 没有手动停止的情况下,自动循环
.如果结束

返回 ()
.如果结束

.子程序 选择任务行执行
.参数 执行行, 整数型
.局部变量 行, 整数型
.局部变量 总量, 文本型
.局部变量 已执行数量, 文本型
.局部变量 二次搜索关键词, 文本型
.局部变量 识别关键词, 文本型
.局部变量 一次搜索关键词, 文本型
.局部变量 关键词排名, 整数型
.局部变量 局_表项, 整数型

任务列表框.选择表项 (执行行 - 1)
一次搜索关键词 = 任务列表框.取标题 (执行行 - 1, 1)
二次搜索关键词 = 任务列表框.取标题 (执行行 - 1, 2)
识别关键词 = 任务列表框.取标题 (执行行 - 1, 3)
总量 = 任务列表框.取标题 (执行行 - 1, 5)
已执行数量 = 任务列表框.取标题 (执行行 - 1, 6)
调试输出_新 (“执行行[” + 到文本 (执行行) + “]:” + 一次搜索关键词)
处理事件 ()
.如果 (到数值 (已执行数量) < 到数值 (总量))
关键词排名 = 执行任务 (一次搜索关键词, 二次搜索关键词, 识别关键词)
‘ 更新任务的关键词排名.
局_表项 = 任务列表框.现行选中项
任务列表框.置标题 (局_表项, 4, 到文本 (关键词排名))
任务列表框.置标题 (局_表项, 6, 到文本 (到数值 (已执行数量) + 1))
保存任务列表到dat ()
连续失败次数 = 0 ‘ 清空连续失败次数
.否则
调试输出_新 (“本任务已经达到执行数量,跳过”)
连续失败次数 = 连续失败次数 + 1

返回 ()
.如果结束

.子程序 执行任务, 整数型, , 执行搜索和点击任务,返回当前识别关键词在当前关键词搜索结果中的排名,返回100是没有排名,返回0是没有执行成功
.参数 一次搜索关键词, 文本型
.参数 二次搜索关键词, 文本型
.参数 识别关键词, 文本型
.局部变量 chrome路径, 文本型
.局部变量 标签组, IChromeLink, , “0”
.局部变量 主框架, CHROME_框架资源
.局部变量 browser, IChromeAccessor
.局部变量 url, 文本型
.局部变量 Chrome高级封装类, Chrome高级封装类
.局部变量 浏览器标签ID, 文本型
.局部变量 站外_停留_延迟, 整数型
.局部变量 分辨率, 文本型
.局部变量 分辨率_宽, 整数型
.局部变量 分辨率数组, 文本型, , “0”
.局部变量 分辨率_高, 整数型
.局部变量 网页源码, 文本型
.局部变量 找到, 整数型
.局部变量 bd, , , , <!!!>
.局部变量 i, 整数型
.局部变量 rect, 矩形范围
.局部变量 rect2, 矩形范围
.局部变量 rect_ad, 矩形范围
.局部变量 rect_ad_a, 矩形范围
.局部变量 rect_h3a, 矩形范围
.局部变量 rect_h3a2, 矩形范围
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 ad_x, 整数型
.局部变量 ad_y, 整数型
.局部变量 下一页页码, 整数型
.局部变量 divid, 整数型
.局部变量 随机刷新页面次数, 整数型
.局部变量 e, 整数型
.局部变量 搜索结果页数, 整数型
.局部变量 关键词排名, 整数型
.局部变量 rect_zna, 矩形范围
.局部变量 进站后随机点击次数, 整数型
.局部变量 f, 整数型
.局部变量 最大搜索页数, 整数型
.局部变量 数组W, 文本型, , “0”
.局部变量 m, 整数型
.局部变量 随机UA, 文本型

‘ 自动换IP开启
.如果真 (开关_自动换IP = 1)
.如果真 (ADSL重拨 () = 假)
信息框 (“自动换IP开启,但是拨号不成功,程序暂停”, 0, , )
程序停止运行 = 1

返回 (-1)
.如果真结束

.如果真结束

‘ 过滤重复IP开启
.如果真 (开关_过滤重复IP = 1)
‘ 从数据库判断IP=1 -功能尚未开发
‘ ADSL重拨 ()

.如果真结束

‘ 任务超时开启
.如果真 (开关_任务超时停止 = 1 且 编辑框_任务超时停止.内容 ≠ “0” 且 编辑框_任务超时停止.内容 ≠ “”)
任务时钟.时钟周期 = 到数值 (编辑框_任务超时停止.内容) × 1000

.如果真结束
chrome路径 = 编辑框_chrome路径.内容

.如果真 (chrome路径 = “”)
信息框 (“请输入chrome浏览器地址”, 0, , )
程序关闭 ()
.如果真结束

‘ 删除目录 (取运行目录 () + “\Childtemp(9222)”)
‘ 创建目录 (取运行目录 () + “\Childtemp(9222)”)
调试输出_新 (“获取chrome路径成功!”)
调试输出_新 (“正在执行任务[” + 任务列表框.取标题 (任务列表框.现行选中项, 0) + “]一次搜索词[” + 一次搜索关键词 + “]…”)
.如果真 (程序停止运行 = 1)
返回 (-1)
.如果真结束
浏览器标签ID = “abc”
调试输出_新 (“开始启动浏览器…”)
Chrome高级封装类.浏览器_启动 (chrome路径, url, 浏览器标签ID, 9222, , 假)
url = 取随机入口 () ‘ 取随机入口

调试输出_新 (“浏览器标签ID:” + 浏览器标签ID)
‘ 清理缓存
.如果真 (开关_清理缓存 = 1)
Chrome高级封装类.浏览器_清除缓存 (浏览器标签ID)
调试输出_新 (“清除缓存”)
.如果真结束
‘ 取随机UA
.如果真 (开关_随机浏览器UA = 1)
随机UA = #UA_谷歌
Chrome高级封装类.浏览器_置UA (浏览器标签ID, 随机UA)
调试输出_新 (“伪装浏览器ua:” + 随机UA)
.如果真结束
‘ 取随机分辨率
.如果真 (开关_随机分辨率 = 1)
分辨率 = 取随机分辨率 ()
分辨率数组 = 分割文本 (分辨率, “x”, )
分辨率_宽 = 到数值 (分辨率数组 [1])
分辨率_高 = 到数值 (分辨率数组 [2])

Chrome高级封装类.浏览器_设置屏幕 (浏览器标签ID, 分辨率_宽, 分辨率_高, 0, 假, 0, 0, 0, 0, 0, 真, “portraitPrimary”, 0)
调试输出_新 (“修改分辨率:” + 到文本 (分辨率_宽) + “x” + 到文本 (分辨率_高) + “..”)

.如果真结束

‘ 取随机浏览器指纹
‘ 取随机CPU信息
‘ 取随机cookies
Chrome高级封装类.浏览器_跳转 (浏览器标签ID, url)
调试输出_新 (“打开搜索入口…”)
.如果真 (程序停止运行 = 1)
返回 (-1)
.如果真结束

‘ 延迟2-5秒开始搜索
程序_延时 (取随机数 (2, 5) × 1000)
调试输出_新 (“搜索第一关键词开始…”)
.判断循环首 (Chrome高级封装类.浏览器_是否已就绪 (浏览器标签ID) = 假)
程序_延时 (取随机数 (1, 5) × 1000)
.判断循环尾 ()

‘ 开始输入关键词
Chrome高级封装类.浏览器_填表_元素置焦点 (浏览器标签ID, “.s_ipt”, 真, 假)
.如果真 (程序停止运行 = 1)
返回 (-1)
.如果真结束
程序_延时 (取随机数 (1, 3) × 1000)
Chrome高级封装类.浏览器_填表_元素置焦点 (浏览器标签ID, “.s_ipt”, 真, 假)
.如果真 (程序停止运行 = 1)
返回 (-1)
.如果真结束

Chrome高级封装类.浏览器_键鼠_发送文本 (浏览器标签ID, 一次搜索关键词, , 500, 3000)
.如果真 (程序停止运行 = 1)
返回 (-1)
.如果真结束

Chrome高级封装类.浏览器_填表_事件 (浏览器标签ID, “.s_btn”, “click”)
调试输出_新 (“一次搜索结束”)
.判断循环首 (Chrome高级封装类.浏览器_是否已就绪 (浏览器标签ID) = 假)
程序_延时 (取随机数 (1, 3) × 1000)
.判断循环尾 ()
程序_延时 (3 × 1000)
‘ 第二次搜索
.如果真 (一次搜索关键词 ≠ 二次搜索关键词)
调试输出_新 (“搜索第二关键词开始…”)
Chrome高级封装类.浏览器_填表_元素置焦点 (浏览器标签ID, “.s_ipt”, 真, 假)
程序_延时 (1000)
.如果真 (程序停止运行 = 1)
返回 (-1)
.如果真结束

Chrome高级封装类.浏览器_填表_元素置焦点 (浏览器标签ID, “.s_ipt”, 真, 假)
Chrome高级封装类.浏览器_键鼠_发送按键 (浏览器标签ID, 65, #键盘_按下, #键盘_功能键_CTRL, , )
程序_延时 (1000)
Chrome高级封装类.浏览器_键鼠_发送按键 (浏览器标签ID, 8, #键盘_按下, , , )
.如果真 (程序停止运行 = 1)
返回 (-1)
.如果真结束

Chrome高级封装类.浏览器_键鼠_发送文本 (浏览器标签ID, 二次搜索关键词, , 1000, 5000)
程序_延时 (1000)
Chrome高级封装类.浏览器_填表_事件 (浏览器标签ID, “.s_btn”, “click”)

.如果真结束
调试输出_新 (“开始站外搜索…”)
网页源码 = Chrome高级封装类.浏览器_取网页源代码 (浏览器标签ID)
.判断循环首 (Chrome高级封装类.浏览器_是否已就绪 (浏览器标签ID) = 假)
程序_延时 (取随机数 (1, 5) × 1000)
.判断循环尾 ()
程序_延时 (3 × 1000)
找到 = 寻找文本 (网页源码, 识别关键词, , 假)
调试输出_新 (“正在检索第1页结果…”)
.如果 (找到 ≥ 1) ‘ 第一页如果找到直接返回
调试输出_新 (“第1页找到识别词” + #换行符)
搜索结果页数 = 1

.否则
调试输出_新 (“开始翻页”)
.如果真 (编辑框_最大搜索页数.内容 ≠ “” 且 到数值 (编辑框_最大搜索页数.内容) < 11)
调试输出_新 (“正在检索第” + 到文本 (i + 1) + “页结果…”)
最大搜索页数 = 到数值 (编辑框_最大搜索页数.内容)
.计次循环首 (最大搜索页数 - 1, i)
程序_延时 (取随机数 (1000, 5000))
.判断循环首 (Chrome高级封装类.浏览器_是否已就绪 (浏览器标签ID) = 假)
程序_延时 (取随机数 (1000, 5000))
.判断循环尾 ()

.如果真 (Chrome高级封装类.浏览器_是否已就绪 (浏览器标签ID) = 真)
Chrome高级封装类.浏览器_填表_元素定位 (浏览器标签ID, “.page-inner”, rect, , )
Chrome高级封装类.浏览器_置滚动条 (浏览器标签ID, 0, rect.顶边, )
调试输出_新 (“滚动到页面最下”)
.如果 (i = 1)
下一页页码 = i + 1

.否则
下一页页码 = i + 2

.如果结束
程序_延时 (取随机数 (1000, 5000))
Chrome高级封装类.浏览器_填表_事件 (浏览器标签ID, “.page-inner a:nth-child(” + 到文本 (下一页页码) + “)”, “click”)
调试输出_新 (“翻页到第” + 到文本 (i + 1) + “页”)
处理事件 ()
程序_延时 (取随机数 (1000, 5000))
.如果真 (Chrome高级封装类.浏览器_是否已就绪 (浏览器标签ID) = 真)
网页源码 = Chrome高级封装类.浏览器_取网页源代码 (浏览器标签ID)
.如果真结束
找到 = 寻找文本 (网页源码, 识别关键词, , 假)
.如果真 (找到 ≥ 1)

搜索结果页数 = i + 1
调试输出_新 (“第” + 到文本 (搜索结果页数) + “页找到特征词” + #换行符)
跳出循环 ()
.如果真结束

.如果真 (i = 最大搜索页数 - 1) ‘ 到最后一页还没找到,更新任务排名
调试输出_新 (“前” + 到文本 (最大搜索页数) + “页未找到,跳过本任务”)
返回 (100)
.如果真结束
.如果真 (程序停止运行 = 1)
返回 (0)
.如果真结束

.如果真结束

.计次循环尾 ()

.如果真结束

.如果结束
调试输出_新 (“搜索结果页数:” + 到文本 (搜索结果页数))
.如果真 (程序停止运行 = 1)
返回 (0)
.如果真结束
处理事件 ()

‘ 正则匹配搜索结果所在div的id
divid = 到数值 (匹配搜索结果的id (网页源码, 识别关键词))
.如果 (divid = 0)
调试输出_新 (“定位ID失败,请检查规则”)
返回 (0)
.否则
关键词排名 = divid

.如果结束
调试输出_新 (“发现点击目标,当前排名[” + 到文本 (关键词排名) + “]…”)

‘ 进站前随机点击
.如果真 (开关_进站前随机点击 = 1)
调试输出_新 (“开关_进站前随机点击”)
置随机数种子 ()

数组W = { “” }

加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 1))
加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 2))
加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 3))
加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 4))
加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 5))
加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 6))
加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 7))
加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 8))
加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 9))
加入成员 (数组W, 到文本 (搜索结果页数 × 10 - 10 + 10))
.计次循环首 (取随机数 (1, 取数组成员数 (数组W)), m)

调试输出_新 (“开始站外随机点击”)
.如果真 (Chrome高级封装类.浏览器_填表_元素是否存在 (浏览器标签ID, “#content_left div[id=” + #引号 + 数组W [m] + #引号 + “]”, ) = 真)
Chrome高级封装类.浏览器_填表_元素定位 (浏览器标签ID, “#content_left div[id=” + #引号 + 数组W [m] + #引号 + “] h3 a”, rect_ad_a, , 真, 真)
Chrome高级封装类.浏览器_置滚动条 (浏览器标签ID, 0, rect_ad_a.顶边, )
程序_延时 (2000)
处理事件 ()
Chrome高级封装类.浏览器_键鼠_发送鼠标触点 (浏览器标签ID, #鼠标_单击, rect_ad_a.中心点x, rect_ad_a.中心点y, #鼠标_按键_左键, , , )

‘ Chrome高级封装类.浏览器_填表_事件 (浏览器标签ID, “#content_left div[id=” + #引号 + 数组W [m] + #引号 + “] h3 a”, “click”)
.如果 (Chrome高级封装类.自定义衍生标签ID (浏览器标签ID, “ad_” + 数组W [m]) = 真)
Chrome高级封装类.浏览器_激活标签页 (“ad_” + 到文本 (f))
程序_延时 (取随机数 (1000, 3000))
‘ 点击后关闭标签
Chrome高级封装类.浏览器_关闭标签页 (“ad_” + 到文本 (f))

.否则
‘ 如果关闭操作实现不了,激活主页面
Chrome高级封装类.浏览器_激活标签页 (浏览器标签ID)
调试输出_新 (“关闭操作实现不了,激活主页面”)
.如果结束

Chrome高级封装类.浏览器_激活标签页 (浏览器标签ID)
.如果真结束

.计次循环尾 ()

 

.如果真结束
调试输出_新 (“开关_进站前随机刷新”)
‘ 进站前随机刷新,得放在随机点击后面,不然刷新后可能没有了广告位
.如果真 (开关_进站前随机刷新 = 1 且 编辑框_进站前随机刷新1.内容 ≠ “” 且 编辑框_进站前随机刷新2.内容 ≠ “”)
置随机数种子 ()
随机刷新页面次数 = 取随机数 (到数值 (编辑框_进站前随机刷新1.内容), 到数值 (编辑框_进站前随机刷新2.内容))
.如果真 (随机刷新页面次数 ≠ 0)
.计次循环首 (随机刷新页面次数, e)
程序_延时 (取随机数 (1000, 3000))
处理事件 ()
Chrome高级封装类.浏览器_重载 (浏览器标签ID)
.计次循环尾 ()

.如果真结束

.如果真结束
.如果真 (程序停止运行 = 1)
返回 (0)
.如果真结束

调试输出_新 (“站外页面停留延迟”)
‘ 站外页面停留延迟
.如果真 (编辑框_站外停留延迟1.内容 ≠ “0”)
站外_停留_延迟 = 取随机数 (到数值 (编辑框_站外停留延迟1.内容), 到数值 (编辑框_站外停留延迟2.内容))
程序_延时 (站外_停留_延迟 × 1000)

.如果真结束
处理事件 ()
调试输出_新 (“点击定位到的矩形内超链接”)
‘ 点击定位到的矩形内超链接
.如果真 (Chrome高级封装类.浏览器_填表_元素是否存在 (浏览器标签ID, “#content_left div[id=” + #引号 + 到文本 (divid) + #引号 + “]”, ) = 真)
‘ 定位到搜索结果矩形 #content_left div[id=”1″]
Chrome高级封装类.浏览器_填表_元素定位 (浏览器标签ID, “#content_left div[id=” + #引号 + 到文本 (divid) + #引号 + “]”, rect2, , 真, 真)
Chrome高级封装类.浏览器_置滚动条 (浏览器标签ID, 0, rect2.顶边, )

.如果真结束
处理事件 ()
‘ 鼠标点击超链接,不弹窗,弹新标签页
Chrome高级封装类.浏览器_填表_元素定位 (浏览器标签ID, “#content_left div[id=” + #引号 + 到文本 (divid) + #引号 + “] h3 a”, rect_h3a, , , )
Chrome高级封装类.浏览器_置滚动条 (浏览器标签ID, 0, rect_h3a.顶边, )
‘ 重新获取矩形坐标
Chrome高级封装类.浏览器_填表_元素定位 (浏览器标签ID, “#content_left div[id=” + #引号 + 到文本 (divid) + #引号 + “] h3 a”, rect_h3a2, , , )
x = 取随机数 (rect_h3a2.左边, rect_h3a2.右边)
y = 取随机数 (rect_h3a2.顶边, rect_h3a2.底边)
程序_延时 (2000)
Chrome高级封装类.浏览器_键鼠_发送鼠标触点 (浏览器标签ID, #鼠标_单击, x, y, #鼠标_按键_左键, , , )
点击成功次数 = 点击成功次数 + 1
‘ 这种方式会弹出新窗口—-Chrome高级封装类.浏览器_填表_事件 (浏览器标签ID, “ #content_left div[id=” + #引号 + 到文本 (divid) + #引号 + “] h3 a”, “click”)
.如果真 (开关_进站后随机点击 = 1 且 编辑框_进站后随机点击1.内容 ≠ “” 且 编辑框_进站后随机点击2.内容 ≠ “”)
‘ [href*= “+#引号+ zhilvlv.com+ #引号 +”]
进站后随机点击次数 = 取随机数 (到数值 (编辑框_进站后随机点击1.内容), 到数值 (编辑框_进站后随机点击2.内容))
调试输出_新 (“准备随机站内链接:” + 到文本 (进站后随机点击次数) + “次”)
.如果真 (编辑框_站内停留延迟1.内容 ≠ “” 且 编辑框_站内停留延迟2.内容 ≠ “”)

程序_延时 (取随机数 (到数值 (编辑框_站内停留延迟1.内容) × 1000, 到数值 (编辑框_站内停留延迟2.内容) × 1000))

.如果真结束
.如果真 (进站后随机点击次数 ≠ 0)
.计次循环首 (进站后随机点击次数, f)
.如果 (Chrome高级封装类.自定义衍生标签ID (浏览器标签ID, “new_” + 到文本 (f)) = 真)
Chrome高级封装类.浏览器_激活标签页 (“new_” + 到文本 (f))
程序_延时 (2000)
Chrome高级封装类.浏览器_填表_事件 (“new_” + 到文本 (f), “ a” + “” + “:nth-child(” + 到文本 (取随机数 (1, 10)) + “)”, “click”)
调试输出_新 (“第” + 到文本 (f) + “次点击”)
.如果真 (编辑框_站内停留延迟1.内容 ≠ “” 且 编辑框_站内停留延迟2.内容 ≠ “”)
程序_延时 (取随机数 (到数值 (编辑框_站内停留延迟1.内容) × 1000, 到数值 (编辑框_站内停留延迟2.内容) × 1000))
.如果真结束
Chrome高级封装类.浏览器_关闭标签页 (“new_” + 到文本 (进站后随机点击次数))

.否则
‘ 如果关闭操作实现不了,激活主页面,等待相应时间
Chrome高级封装类.浏览器_激活标签页 (浏览器标签ID)

.如果结束

.计次循环尾 ()

.如果真结束

 

.如果真结束
调试输出_新 (“点击任务完成,本次关键词排名:” + 到文本 (关键词排名))
调试输出_新 (“★★★本次任务结束”)
返回 (关键词排名)

.子程序 匹配搜索结果的id, 整数型, , 返回存在于当前页面div的id
.参数 网页文本内容, 文本型
.参数 识别关键词, 文本型
.局部变量 url数组, 文本型, , “0”
.局部变量 百度正则, 正则表达式
.局部变量 百度搜索结果, 搜索结果, , “0”
.局部变量 结果了, 文本型
.局部变量 百度搜索结果数量, 整数型
.局部变量 找到, 整数型
.局部变量 e, 整数型
.局部变量 搜索结果数量, 整数型
.局部变量 i, 整数型
.局部变量 随机数, 整数型
.局部变量 随机数2, 整数型
.局部变量 divid, 整数型

‘ result c-container new-pmd 是普通快照div样式
‘ resultop c-container new-pmd * 是特殊快照
‘ M_QabY CKqoEp bNK_zr c-container new-pmd 是广告样式
‘ M_QabY CKqoEp bNK_zr c-container new-pmd
‘ M_QabY CKqoEp bNK_zr c-container new-pmd
‘ cVDLiU oVspSA iLsWwn c-container new-pmd
‘ cVDLiU oVspSA iLsWwn c-container new-pmd
url数组 = 分割文本 (网页文本内容, “<div class=” + #引号 + “result c-container new-pmd”, )
置随机数种子 ()
随机数 = 取随机数 (3, 5)
随机数2 = 取随机数 (2, 7)

搜索结果数量 = 取数组成员数 (url数组)
调试输出_新 (“网页源码里检索特征词:” + 识别关键词)

.如果真 (搜索结果数量 < 1)
标签4.标题 = “首页没有搜索到结果”
调试输出_新 (“首页没有搜索到含有特征词的结果”)
返回 (0)

.如果真结束
调试输出_新 (“首页搜索到含有特征词的结果,共有:” + 到文本 (搜索结果数量) + “个”)
.计次循环首 (搜索结果数量, i)
找到 = 寻找文本 (url数组 [i], 识别关键词, , 假)

.如果 (找到 > 1 且 i ≠ 1)
‘ 进入含有目标url的区块
‘ 分析目标区块的html元素
divid = 到数值 (文本_取出中间文本 (url数组 [i], “id=” + #引号, #引号))
.如果 (divid ≥ 1)

返回 (divid)
.否则
调试输出_新 (“未匹配到div-ID,继续匹配”)

.如果结束

.否则
divid = 0

.如果结束

 

.计次循环尾 ()
返回 (divid) ‘ 返回的ID直接就是百度排名

.子程序 匹配搜索结果页广告id列表, 文本型
.参数 网页源码, 文本型
.局部变量 url数组, 文本型, , “0”
.局部变量 搜索结果数量, 整数型
.局部变量 找到, 整数型
.局部变量 i, 整数型
.局部变量 m, 整数型
.局部变量 数组, 文本型, , “0”
.局部变量 文本, 文本型

url数组 = 分割文本 (网页源码, “<!– pc jieou new –>”, )
搜索结果数量 = 取数组成员数 (url数组)
m = 1
.计次循环首 (搜索结果数量, i)
找到 = 寻找文本 (url数组 [i], “广告”, , 假)
.如果真 (找到 > 1)

文本 = 文本 + 文本_取出中间文本 (url数组 [i], “<div id=” + #引号, #引号 + “ cmatchid=”) + “|”
m = m + 1
.如果真结束

.计次循环尾 ()
返回 (文本)

.子程序 _程序时钟_周期事件

程序_延时 (到数值 (编辑框_拨号间隔) × 1000)
处理事件 ()
‘ 宽带拨号
.如果真 (开关_过滤重复IP = 1)
‘ 过滤操作
.如果真结束
‘ 执行任务 ()

 

.子程序 取随机入口, 文本型
.局部变量 入口数组, 文本型, , “0”
.局部变量 i, 整数型

入口数组 = { “http://www.baidu.com”, “https://www.baidu.com” }
i = 取随机数 (1, 取数组成员数 (入口数组))
返回 (入口数组 [i])

.子程序 取随机分辨率, 文本型
.局部变量 分辨率数组, 文本型, , “0”
.局部变量 i, 整数型

分辨率数组 = { “1024×540”, “2048×1080”, “4090×2160”, “1440×900”, “1600×900”, “1600×1200”, “1920×1080”, “1680×1050”, “1920×1080”, “1920×1200”, “1920×1080”, “1920×1200”, “1920×1080”, “1920×1200”, “2560×1440”, “1024×600”, “1920×1200”, “1680×1050”, “1280×1024”, “1280×800”, “1366×768”, “1920×1080”, “1600×900” }
i = 取随机数 (1, 取数组成员数 (分辨率数组))
返回 (分辨率数组 [i])

.子程序 _任务时钟_周期事件
.局部变量 Chrome高级封装类, Chrome高级封装类

‘ 达到任务超时结束时间,强制关闭
Chrome高级封装类.浏览器_结束 ()
调试输出_新 (“本次任务执行超时”)

任务时钟.时钟周期 = 0

.子程序 _数据保存_时钟_周期事件

保存配置列表到ini ()
保存任务列表到dat ()

.子程序 _垃圾清理_时钟_周期事件

垃圾清理 ()

.子程序 垃圾清理
.局部变量 Chrome高级封装类, Chrome高级封装类
.局部变量 标签信息组, 标签信息, , “0”
.局部变量 i, 整数型

Chrome高级封装类.浏览器_取内部标签列表 (标签信息组)
.计次循环首 (取数组成员数 (标签信息组), i)
Chrome高级封装类.浏览器_清除缓存 (标签信息组 [i].自定义ID)
.计次循环尾 ()
自动释放内存 (1)

.子程序 自动释放内存, , , 0 释放自身 非0 所有进程
.参数 方式, 整数型
.局部变量 系统目录, 文本型
.局部变量 进程句柄, 整数型
.局部变量 进程快照, 整数型
.局部变量 进程信息, PROCESSENTRY32

系统目录 = 取特定目录 (#Windows系统目录)
进程快照 = CreateToolhelp32Snapshot (15, 0)
.如果真 (进程快照 = 0)
返回 ()
.如果真结束
进程信息.dwSize = 296 ‘ = len (uProcess)
进程句柄 = Process32First (进程快照, 进程信息)
.判断循环首 (进程句柄 ≠ 0)
.判断开始 (方式 = 0 且 到文本 (进程信息.szExeFile) = 取执行文件名 ())

运行 (系统目录 + “empty.exe ” + 到文本 (进程信息.th32ProcessID), 真, #隐藏窗口)
跳出循环 ()

.默认
.如果真 (方式 ≠ 0)

运行 (系统目录 + “empty.exe ” + 到文本 (进程信息.th32ProcessID), 假, #隐藏窗口)
.如果真结束

.判断结束
进程句柄 = Process32Next (进程快照, 进程信息)
.判断循环尾 ()
CloseHandle (进程快照)

.子程序 _按钮5_被单击

调试输出_新 (“准备停止任务···”)
程序关闭 ()

.子程序 调试输出_新
.参数 文本, 文本型

编辑框1.加入文本 (到文本 (取年份 (取现行时间 ())) + “/” + 到文本 (取月份 (取现行时间 ())) + “/” + 到文本 (取日 (取现行时间 ())) + “ ” + 到文本 (取小时 (取现行时间 ())) + “:” + 到文本 (取分钟 (取现行时间 ())) + “:” + 到文本 (取秒 (取现行时间 ())) + “ ” + “” + 文本 + #换行符)

.子程序 程序关闭

开始按钮.选中 = 假 ‘ 程序结束
调试输出_新 (“程序停止运行”)
写设置 (“运行数据”, “点击成功次数”, 到文本 (点击成功次数))

程序停止运行 = 1
返回 ()

本文《百度点击快排源码(e语言拨号模拟点击)》由错误博客(cuowu.com)整理或原创,感谢您的阅读。

随机文章

滨城网(有机亚麻籽油的八大功效)
美团要给外卖送餐员参加社会保险引估价暴跌
凡尔赛什么梗什么意思
小小课堂:1.3 HTML文字与段落__HTML视频教程
HTML大字
地推教程
232 信服-阎川魔鬼游戏
337 宝箱里的东西-阎川魔鬼游戏

百度搜索“错误博客”即可找到本站,微信搜索“小小课堂网”关注小小课堂网公众号。错误博客( cuowu.com )欢迎用户投稿,发布者:中二少年,文章版权归作者所有,投稿文章不代表错误博客立场,中二少年发布为错误博客原创文章,转载请注明出处:https://cuowu.com/3391.html

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注