• 982阅读
  • 1回复

POST实战演练 第9课:西祠胡同登录 [复制链接]

上一主题 下一主题
离线啊冲
 

只看楼主 倒序阅读 使用道具 楼主  发表于: 2016-08-30
.版本 2
.支持库 spec

.程序集 程序集1
.程序集变量 cookies, 文本型

.子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行

登录西祠 (“精易”, “742918299”, cookies)
返回 (0)

.子程序 登录西祠
.参数 帐号, 文本型
.参数 密码, 文本型
.参数 cookie, 文本型, 参考 可空
.局部变量 js, 脚本类

帐号 = 子文本替换 (U编码转换 (帐号, “to16on”), “\”, “%”, , , 真)
COOKIE合并更新 (cookie, “HostID=” + 取文本中间1 (HTTP读网页s (“http://www.xici.net/service/verify.asp”, , , cookie, ), “id=oHostId value=” + #引号, #引号 + “>”))
js.执行语句 (#H2)
密码 = js.运行 (“H2”, 密码, cookie)
调试输出 (HTTP读网页s (“http://www.xici.net/api.asp?method=xici.token.logon”, “POST”, “username=” + 帐号 + “&Usercode= ” + 密码, cookie))
善者 慈悲心常在 无怨无恨 以苦为乐
默认压缩密码www.hifyl.com
文件分享密码问题:http://www.hifyl.com/read-htm-tid-4444.html
离线啊冲

只看该作者 沙发  发表于: 2016-08-30
.版本 2
.支持库 iconv

.程序集 程序集1

.子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码

返回 (0)

.子程序 HTTP读网页, 字节集, 公开, 出错或超时将返回空,本命令支持多线程
.参数 网址, 文本型, , 完整的网页地址
.参数 访问方式, 文本型, 可空, "GET" or "POST",为空默认"GET"
.参数 提交信息, 文本型, 可空, "POST"专用
.参数 提交Cookies, 文本型, 参考 可空, 提交的Cookie 注:本参数传递变量时会自动回传返回的Cookie
.参数 返回Cookies, 文本型, 参考 可空, 返回的Cookie
.参数 附加协议头, 文本型, 可空, 一行一个请用换行符隔开
.参数 返回协议头, 文本型, 参考 可空, Location
.参数 禁止重定向, 逻辑型, 可空, 禁止网页进行重定向
.参数 代理地址, 文本型, 可空, 代理地址
.参数 用户名, 文本型, 可空, 代理用户名
.参数 密码, 文本型, 可空, 代理密码
.参数 超时, 整数型, 可空, 秒|默认为15秒,1为无限等待
.参数 完整协议头, 文本型, 参考 可空, 返回完整的协议头
.参数 字节集提交, 字节集, 可空, 提交字节集数据
.局部变量 局部_WinHttp, 对象
.局部变量 局部_返回Cookies, 文本型, , "0"
.局部变量 局部_计次, 整数型
.局部变量 局部_网页数据, 字节集
.局部变量 局部_发送协议头, 文本型, , "0"
.局部变量 局部_协议头处理, 文本型, , "0"
.局部变量 局部_变体提交, 变体型

CoInitialize (0)
.如果真 (局部_WinHttp.创建 (“WinHttp.WinHttpRequest.5.1”, ) = 假)
    .如果真 (局部_WinHttp.创建 (“MSXML2.ServerXMLHTTP.6.0”, ) = 假)
        .如果真 (局部_WinHttp.创建 (“MSXML2.ServerXMLHTTP.5.0”, ) = 假)
            返回 ({  })
        .如果真结束

    .如果真结束

.如果真结束
' 局部_WinHttp.查看 ()
访问方式 = 到大写 (访问方式)
.如果真 (访问方式 = “”)
    访问方式 = “GET”
.如果真结束

.如果真 (超时 ≠ 1)
    .如果 (超时 < 1)
        超时 = 15000
    .否则
        超时 = 超时 × 1000
    .如果结束
    局部_WinHttp.方法 (“SetTimeouts”, 超时, 超时, 超时, 超时)
.如果真结束

.如果真 (代理地址 ≠ “”)
    局部_WinHttp.方法 (“SetProxy”, 2, 代理地址)
    .如果真 (用户名 ≠ “”)
        局部_WinHttp.方法 (“SetProxyCredentials”, 用户名, 密码)
    .如果真结束

.如果真结束
局部_WinHttp.方法 (“Open”, 访问方式, 网址, 假)
.如果真 (禁止重定向)
    局部_WinHttp.写属性 (“Option”, 6, 0)
.如果真结束

.如果真 (附加协议头 = “”)
    附加协议头 = “Referer: ” + 网址 + #换行符 + #协议头_网页
.如果真结束

.如果真 (提交Cookies ≠ “”)
    局部_WinHttp.方法 (“SetRequestHeader”, “Cookie”, 提交Cookies)
.如果真结束

.判断开始 (寻找文本 (附加协议头, #换行符, , 假) > -1)
    局部_发送协议头 = 分割文本 (附加协议头, #换行符, )
    .计次循环首 (取数组成员数 (局部_发送协议头), 局部_计次)
        .如果真 (寻找文本 (局部_发送协议头 [局部_计次], “:”, , 假) > -1)
            清除数组 (局部_协议头处理)
            局部_协议头处理 = 分割文本 (局部_发送协议头 [局部_计次], “:”, )
            局部_计次 = 2
            .判断循环首 (真)
                局部_计次 = 局部_计次 + 1
                .如果真 (局部_计次 > 取数组成员数 (局部_协议头处理))
                    跳出循环 ()
                .如果真结束
                局部_协议头处理 [2] = 局部_协议头处理 [2] + “:” + 局部_协议头处理 [局部_计次]
            .判断循环尾 ()
            局部_WinHttp.方法 (“SetRequestHeader”, 局部_协议头处理 [1], 局部_协议头处理 [2])
        .如果真结束

    .计次循环尾 ()
.默认
    .如果真 (寻找文本 (附加协议头, “:”, , 假) > -1)
        局部_协议头处理 = 分割文本 (附加协议头, “:”, )
        局部_计次 = 2
        .判断循环首 (真)
            局部_计次 = 局部_计次 + 1
            .如果真 (局部_计次 > 取数组成员数 (局部_协议头处理))
                跳出循环 ()
            .如果真结束
            局部_协议头处理 [2] = 局部_协议头处理 [2] + “:” + 局部_协议头处理 [局部_计次]
        .判断循环尾 ()
        局部_WinHttp.方法 (“SetRequestHeader”, 局部_协议头处理 [1], 局部_协议头处理 [2])
    .如果真结束

.判断结束

.判断开始 (字节集提交 = {  })
    局部_WinHttp.方法 (“Send”, 提交信息)
.默认
    局部_变体提交.赋值 (字节集提交, )
    局部_WinHttp.方法 (“Send”, 局部_变体提交)
.判断结束
局部_网页数据 = 局部_WinHttp.读属性 (“ResponseBody”, ).取字节集 ()
完整协议头 = 局部_WinHttp.读文本属性 (“GetallResponseHeaders”, )
局部_返回Cookies = 分割文本 (完整协议头, #换行符, )
返回Cookies = “”
.计次循环首 (取数组成员数 (局部_返回Cookies), 局部_计次)
    .如果真 (寻找文本 (局部_返回Cookies [局部_计次], “Location:”, , 假) > -1)
        返回协议头 = 删首尾空 (子文本替换 (局部_返回Cookies [局部_计次], “Location:”, , , 1, 假))
    .如果真结束

    .如果真 (寻找文本 (局部_返回Cookies [局部_计次], “Set-Cookie”, , 假) > -1)
        返回Cookies = 返回Cookies + 删首尾空 (取文本中间1 (局部_返回Cookies [局部_计次], “Set-Cookie:”, “;”)) + “; ”
    .如果真结束

.计次循环尾 ()
COOKIE合并更新 (提交Cookies, 返回Cookies)
.如果真 (返回协议头 = “”)
    返回协议头 = 完整协议头
.如果真结束
CoUninitialize ()
返回 (局部_网页数据)

.子程序 HTTP读网页u, 文本型, 公开, 懒人专用,自动进行UTF8解码
.参数 网址, 文本型, , 完整的网页地址
.参数 访问方式, 文本型, 可空, "GET" or "POST",为空默认"GET"
.参数 提交信息, 文本型, 可空, "POST"专用
.参数 提交Cookies, 文本型, 参考 可空, 提交的Cookie 注:本参数传递变量时会自动回传返回的Cookie
.参数 返回Cookies, 文本型, 参考 可空, 返回的Cookie
.参数 附加协议头, 文本型, 可空, 一行一个请用换行符隔开
.参数 返回协议头, 文本型, 参考 可空, Location
.参数 禁止重定向, 逻辑型, 可空, 禁止网页进行重定向
.参数 代理地址, 文本型, 可空, 代理地址
.参数 用户名, 文本型, 可空, 代理用户名
.参数 密码, 文本型, 可空, 代理密码
.参数 超时, 整数型, 可空, 秒|默认为15秒,1为无限等待
.参数 完整协议头, 文本型, 参考 可空, 返回完整的协议头
.参数 字节集提交, 字节集, 可空, 提交字节集数据

返回 (到文本 (编码转换1 (HTTP读网页 (网址, 访问方式, 提交信息, 提交Cookies, 返回Cookies, 附加协议头, 返回协议头, 禁止重定向, 代理地址, 用户名, 密码, 超时, 完整协议头, 字节集提交), #编码_UTF_8, #编码_GBK)))

.子程序 HTTP读网页s, 文本型, 公开, 懒人专用,自动返回文本
.参数 网址, 文本型, , 完整的网页地址
.参数 访问方式, 文本型, 可空, "GET" or "POST",为空默认"GET"
.参数 提交信息, 文本型, 可空, "POST"专用
.参数 提交Cookies, 文本型, 参考 可空, 提交的Cookie 注:本参数传递变量时会自动回传返回的Cookie
.参数 返回Cookies, 文本型, 参考 可空, 返回的Cookie
.参数 附加协议头, 文本型, 可空, 一行一个请用换行符隔开
.参数 返回协议头, 文本型, 参考 可空, Location
.参数 禁止重定向, 逻辑型, 可空, 禁止网页进行重定向
.参数 代理地址, 文本型, 可空, 代理地址
.参数 用户名, 文本型, 可空, 代理用户名
.参数 密码, 文本型, 可空, 代理密码
.参数 超时, 整数型, 可空, 秒|默认为15秒,1为无限等待
.参数 完整协议头, 文本型, 参考 可空, 返回完整的协议头
.参数 字节集提交, 字节集, 可空, 提交字节集数据

返回 (到文本 (HTTP读网页 (网址, 访问方式, 提交信息, 提交Cookies, 返回Cookies, 附加协议头, 返回协议头, 禁止重定向, 代理地址, 用户名, 密码, 超时, 完整协议头, 字节集提交)))

.子程序 U编码转换, 文本型, 公开, 默认转换类型为to16un
.参数 要转的文本, 文本型
.参数 转换类型, 文本型, 可空, to16on to16un tohtmlon tohtmlun
.局部变量 js, 脚本类

.如果真 (是否为空 (转换类型))
    转换类型 = “to16un”
.如果真结束
js.执行语句 (#U码)
返回 (js.运行 (转换类型, 要转的文本))

.子程序 JS清晰化, 文本型, 公开
.参数 js代码, 文本型, , 需要加密\解密的源码
.参数 压缩模式, 整数型, 可空, 0为格式化代码,1为压缩代码. 注:如果为1,则第三参数无效
.参数 分割方法, 整数型, 可空, 0为经典js代码分割方法,1为微软标准js代码分割方法
.局部变量 js, 脚本类

js.执行语句 (#JS清晰化)
.如果真 (是否为空 (压缩模式))
    压缩模式 = 0
.如果真结束

.如果真 (是否为空 (分割方法))
    分割方法 = 1
.如果真结束
返回 (js.运行1 (“go”, js代码, 压缩模式, 分割方法))

.子程序 去除文本, 文本型, 公开
.参数 原文本, 文本型
.参数 去除1, 文本型
.参数 去除2, 文本型, 可空
.参数 去除3, 文本型, 可空
.参数 去除4, 文本型, 可空
.参数 去除5, 文本型, 可空
.参数 去除6, 文本型, 可空
.参数 去除7, 文本型, 可空
.参数 去除8, 文本型, 可空
.参数 去除9, 文本型, 可空
.参数 去除10, 文本型, 可空
.局部变量 文本, 文本型

文本 = 原文本
文本 = 子文本替换 (文本, 去除1, , , , 真)
文本 = 子文本替换 (文本, 去除2, , , , 真)
文本 = 子文本替换 (文本, 去除3, , , , 真)
文本 = 子文本替换 (文本, 去除4, , , , 真)
文本 = 子文本替换 (文本, 去除5, , , , 真)
文本 = 子文本替换 (文本, 去除6, , , , 真)
文本 = 子文本替换 (文本, 去除7, , , , 真)
文本 = 子文本替换 (文本, 去除8, , , , 真)
文本 = 子文本替换 (文本, 去除9, , , , 真)
文本 = 子文本替换 (文本, 去除10, , , , 真)
返回 (文本)

.子程序 GZIP压缩, 字节集, 公开
.参数 inData, 字节集
.局部变量 context, 整数型
.局部变量 inData2, 字节集
.局部变量 inLength, 整数型
.局部变量 buffer, 字节集
.局部变量 inUsed, 整数型
.局部变量 outUsed, 整数型
.局部变量 hResult, 整数型
.局部变量 retBytes, 字节集
.局部变量 upRetByts, 字节集
.局部变量 压缩位置, 整数型

buffer = 取空白字节集 (#MAX_BUF)
InitCompression ()
CreateCompression (context, #GZIP_LVL)
.循环判断首 ()
    inData2 = 取字节集中间 (inData, 压缩位置 + 1, #MAX_BUF)
    inLength = 取字节集长度 (inData2)
    hResult = Compress (context, inData2, inLength, buffer, #MAX_BUF, inUsed, outUsed, #GZIP_LVL)
    .如果真 (0 ≠ outUsed)
        upRetByts = upRetByts + 取字节集左边 (buffer, outUsed)
        压缩位置 = 压缩位置 + inUsed
    .如果真结束

.循环判断尾 (hResult = 0)
DestroyCompression (context)
返回 (upRetByts)

.子程序 GZIP解压, 字节集, 公开
.参数 inData, 字节集
.局部变量 context, 整数型
.局部变量 inData2, 字节集
.局部变量 inLength, 整数型
.局部变量 buffer, 字节集
.局部变量 inUsed, 整数型
.局部变量 outUsed, 整数型
.局部变量 hResult, 整数型
.局部变量 retBytes, 字节集
.局部变量 upRetByts, 字节集
.局部变量 解压位置, 整数型

buffer = 取空白字节集 (#MAX_BUF)
InitDecompression ()
CreateDecompression (context, #GZIP_LVL)
.循环判断首 ()
    inData2 = 取字节集中间 (inData, 解压位置 + 1, #MAX_BUF)
    inLength = 取字节集长度 (inData2)
    hResult = Decompress (context, inData2, inLength, buffer, #MAX_BUF, inUsed, outUsed)
    .如果真 (0 ≠ outUsed)
        upRetByts = upRetByts + 取字节集左边 (buffer, outUsed)
        解压位置 = 解压位置 + inUsed
    .如果真结束

.循环判断尾 (hResult = 0)
DestroyDecompression (context)
返回 (upRetByts)

.子程序 getTime, 文本型, 公开
.局部变量 js, 脚本类

js.执行语句 (“function g(){return new Date().getTime()}”)
返回 (js.运行 (“g”))

.子程序 random, 文本型, 公开, 返回介于 0 和 1 之间的伪随机数
.局部变量 js, 脚本类

js.执行语句 (“function g(){return Math.random()}”)
返回 (js.运行 (“g”))

.子程序 转换为GMT格式, 文本型, 公开, 将日期时间型数据转换为GMT格式
.参数 待转换时间, 日期时间型
.局部变量 整数容器, 整数型
.局部变量 GMT时间, 文本型

整数容器 = 取星期几 (待转换时间)
.判断开始 (整数容器 = 1)
    GMT时间 = “Sun, ”
.判断 (整数容器 = 2)
    GMT时间 = “Mon, ”
.判断 (整数容器 = 3)
    GMT时间 = “Tue, ”
.判断 (整数容器 = 4)
    GMT时间 = “Wen, ”
.判断 (整数容器 = 5)
    GMT时间 = “Thu, ”
.判断 (整数容器 = 6)
    GMT时间 = “Fri, ”
.判断 (整数容器 = 7)
    GMT时间 = “Sat, ”
.默认

.判断结束
GMT时间 = GMT时间 + 到文本 (取日 (待转换时间)) + “-”
整数容器 = 取月份 (待转换时间)
.判断开始 (整数容器 = 1)
    GMT时间 = GMT时间 + “Jan” + “-”
.判断 (整数容器 = 2)
    GMT时间 = GMT时间 + “Feb” + “-”
.判断 (整数容器 = 3)
    GMT时间 = GMT时间 + “Mar” + “-”
.判断 (整数容器 = 4)
    GMT时间 = GMT时间 + “Apr” + “-”
.判断 (整数容器 = 5)
    GMT时间 = GMT时间 + “Mar” + “-”
.判断 (整数容器 = 6)
    GMT时间 = GMT时间 + “Jun” + “-”
.判断 (整数容器 = 7)
    GMT时间 = GMT时间 + “Jul” + “-”
.判断 (整数容器 = 8)
    GMT时间 = GMT时间 + “Aug” + “-”
.判断 (整数容器 = 9)
    GMT时间 = GMT时间 + “Sep” + “-”
.判断 (整数容器 = 10)
    GMT时间 = GMT时间 + “Oct” + “-”
.判断 (整数容器 = 11)
    GMT时间 = GMT时间 + “Nov” + “-”
.判断 (整数容器 = 12)
    GMT时间 = GMT时间 + “Dec” + “-”
.默认

.判断结束
GMT时间 = GMT时间 + 到文本 (取年份 (待转换时间)) + “ ” + 到文本 (取小时 (待转换时间)) + “:” + 到文本 (取分钟 (待转换时间)) + “:” + 到文本 (取秒 (待转换时间)) + “ GMT”
返回 (GMT时间)

.子程序 取中间文本, 文本型, 公开
.参数 待取内容, 文本型
.参数 起始查找位置, 整数型, 参考
.参数 起始文本1, 文本型
.参数 起始文本2, 文本型, 可空
.参数 结束文本, 文本型
.参数 不区分大小写, 逻辑型, 可空, 默认真
.参数 是否包含起始文本, 逻辑型, 可空, 默认真
.局部变量 结束位置, 整数型
.局部变量 起始查找位置1, 整数型

.如果真 (是否为空 (不区分大小写))
    不区分大小写 = 真
.如果真结束
起始查找位置 = 寻找文本 (待取内容, 起始文本1, 起始查找位置, 不区分大小写)
.如果 (起始查找位置 < 0)
    返回 (“”)
.否则
    .如果 (是否为空 (起始文本2) = 假)
        起始查找位置1 = 寻找文本 (待取内容, 起始文本2, 起始查找位置, 不区分大小写)
    .否则
        起始查找位置1 = 起始查找位置
        起始文本2 = 起始文本1
    .如果结束

.如果结束
.如果真 (起始查找位置1 < 0)
    起始查找位置 = -1
    返回 (“”)
.如果真结束
结束位置 = 寻找文本 (待取内容, 结束文本, 起始查找位置1 + 取文本长度 (起始文本2), 不区分大小写)
.如果真 (结束位置 < 0)
    结束位置 = 取文本长度 (待取内容) + 1
.如果真结束
.如果真 (是否为空 (是否包含起始文本))
    是否包含起始文本 = 真
.如果真结束
.如果真 (是否包含起始文本 = 假)
    起始查找位置 = 起始查找位置1 + 取文本长度 (起始文本2)
.如果真结束
返回 (取文本中间 (待取内容, 起始查找位置, 结束位置 - 起始查找位置))

.子程序 COOKIE合并更新, 文本型, 公开, 返回更新后的COOKIE
.参数 原COOKIE, 文本型, 参考
.参数 本次COOKIE, 文本型
.局部变量 COOKIE分组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 COOKIE变量, 文本型
.局部变量 位置, 整数型

原COOKIE = 删首尾空 (原COOKIE)
本次COOKIE = 删首尾空 (本次COOKIE)
.如果真 (取文本右边 (原COOKIE, 1) ≠ “;” 且 原COOKIE ≠ “”)
    原COOKIE = 原COOKIE + “;”
.如果真结束

.如果真 (取文本右边 (本次COOKIE, 1) ≠ “;” 且 本次COOKIE ≠ “”)
    本次COOKIE = 本次COOKIE + “;”
.如果真结束
COOKIE分组 = 分割文本 (本次COOKIE, “;”, )
.计次循环首 (取数组成员数 (COOKIE分组), i)
    .如果真 (寻找文本 (COOKIE分组 , “=”, , 真) > -1)
        COOKIE变量 = 取文本左边 (COOKIE分组 , 寻找文本 (COOKIE分组 , “=”, , 真) - 1)
        位置 = 寻找文本 (原COOKIE, COOKIE变量, , 真)
        .如果 (位置 > 0)
            位置 = 0
            原COOKIE = 子文本替换 (原COOKIE, 取中间文本 (原COOKIE, 位置, COOKIE变量, , “;”, 真, 真), COOKIE分组 , , , 假)
        .否则
            原COOKIE = 原COOKIE + COOKIE分组 + “;”
        .如果结束

    .如果真结束

.计次循环尾 ()
COOKIE分组 = 分割文本 (原COOKIE, “;”, )
原COOKIE = “”
.计次循环首 (取数组成员数 (COOKIE分组), i)
    .如果真 (取文本右边 (COOKIE分组 , 1) ≠ “=”)
        原COOKIE = 原COOKIE + 删首尾空 (COOKIE分组 ) + “; ”
    .如果真结束

.计次循环尾 ()
原COOKIE = 删首尾空 (原COOKIE)
返回 (原COOKIE)

.子程序 设COOKIE, , 公开, 设定前,请先清除
.参数 网址, 文本型
.参数 COOKIE内容, 文本型
.局部变量 域名, 文本型
.局部变量 计次, 整数型
.局部变量 cookies, 文本型, , "0"
.局部变量 名称, 文本型, , "2"
.局部变量 HTTPS, 逻辑型

HTTPS = 到小写 (取文本左边 (网址, 8)) = “https://”
域名 = 取域名 (网址)
cookies = 分割文本 (COOKIE内容, “;”, )
.计次循环首 (取数组成员数 (cookies), 计次)
    .如果真 (寻找文本 (cookies [计次], “=”, , 假) > -1)
        名称 = 分割文本 (cookies [计次], “=”, )
        .如果 (HTTPS)
            InternetSetCookieA (“https://” + 域名, 名称 [1], 名称 [2])
        .否则
            InternetSetCookieA (“http://” + 域名, 名称 [1], 名称 [2])
        .如果结束

    .如果真结束

.计次循环尾 ()

.子程序 取COOKIE, 文本型, 公开
.参数 网址, 文本型
.参数 COOKIE名称, 文本型, 可空, 为空返回全部COOKIE
.局部变量 域名, 文本型
.局部变量 读取内容, 文本型
.局部变量 整数容器1, 整数型
.局部变量 整数容器2, 整数型
.局部变量 HTTPS, 逻辑型

HTTPS = 到小写 (取文本左边 (网址, 8)) = “https://”
域名 = 取域名 (网址)
读取内容 = 取空白文本 (1024)
.如果 (选择 (HTTPS, InternetGetCookieA (“https://” + 域名, “”, 读取内容, 1024), InternetGetCookieA (“http://” + 域名, “”, 读取内容, 1024)))
    .如果真 (COOKIE名称 ≠ “”)
        整数容器1 = 寻找文本 (读取内容, COOKIE名称, 1, 真)
        .如果真 (整数容器1 = -1)
            返回 (“”)
        .如果真结束
        整数容器2 = 寻找文本 (读取内容, “;”, 整数容器1, 真)
        .如果 (整数容器2 > 0)
            读取内容 = 取文本中间 (读取内容, 整数容器1 + 取文本长度 (COOKIE名称) + 1, 整数容器2 - 整数容器1 - 取文本长度 (COOKIE名称) - 1)
        .否则
            读取内容 = 取文本右边 (读取内容, 取文本长度 (读取内容) - 整数容器1 - 取文本长度 (COOKIE名称))
        .如果结束

    .如果真结束

    返回 (读取内容)
.否则
    返回 (“”)
.如果结束


.子程序 取域名, 文本型, 公开
.参数 网址, 文本型
.参数 不过滤端口, 逻辑型, 可空
.局部变量 dwNumber, 整数型
.局部变量 dwLast, 整数型
.局部变量 szServerName, 文本型
.局部变量 临时文本, 文本型
.局部变量 网址头, 整数型

szServerName = 网址
' dwNumber = 选择 (寻找文本 (szServerName, “http://”, , 假) = -1, 1, 寻找文本 (szServerName, “http://”, , 假) + 7)
dwNumber = 选择 (寻找文本 (szServerName, “http://”, , 假) = -1, 选择 (寻找文本 (szServerName, “https://”, , 假) = -1, 1, 寻找文本 (szServerName, “https://”, , 假) + 8), 寻找文本 (szServerName, “http://”, , 假) + 7)
' 输出调试文本 (寻找文本 (szServerName, “http://”, , 假))
szServerName = 取文本中间 (szServerName, dwNumber, 选择 (寻找文本 (szServerName, “/”, dwNumber, 假) = -1, 取文本长度 (szServerName), 寻找文本 (szServerName, “/”, dwNumber, 假) - dwNumber))  ' 这段代码是过滤掉前http://和后/
.如果真 (取反 (不过滤端口))
    dwNumber = 寻找文本 (szServerName, “:”, , 假)
    .如果真 (dwNumber ≠ -1)
        szServerName = 取文本左边 (szServerName, dwNumber - 1)
    .如果真结束

.如果真结束
返回 (到小写 (szServerName))

.子程序 清除COOKIE文件, 逻辑型, 公开
.参数 关键字, 文本型, 可空, 输入cookie文件的关键字即可,空则清除全部
.参数 COOKIE路径, 文本型, 参考 可空, 传递COOKIE路径
.局部变量 文件名, 文本型
.局部变量 已删除, 逻辑型

COOKIE路径 = 取文本注册项 (3, “Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders\cookies”, )
文件名 = 寻找文件 (COOKIE路径 + “\*.txt”, )
.判断循环首 (文件名 ≠ “”)
    .如果真 (寻找文本 (文件名, 关键字, 1, 假) ≠ -1 或 关键字 = “”)
        .如果真 (删除文件 (COOKIE路径 + “\” + 文件名))
            已删除 = 真
        .如果真结束

    .如果真结束
    文件名 = 寻找文件 (, )
.判断循环尾 ()
返回 (已删除)

.子程序 编码转换1, 字节集, 公开
.参数 待转换数据, 字节集
.参数 转换前编码, 文本型, , utf-8;unicode;GBK 等
.参数 转换后编码, 文本型, , utf-8;unicode;GBK 等
.参数 转换后数据开始位置, 整数型, 可空, 位置从0开始。unicode编码标识占2个字节,utf-8编码标识占3个字节
.局部变量 ret, 字节集

CoInitialize (0)
.如果 (是否为空 (转换后数据开始位置))
    ret = bmzh (待转换数据, 转换前编码, 转换后编码)
.否则
    ret = bmzh (待转换数据, 转换前编码, 转换后编码, 转换后数据开始位置)
.如果结束
CoUninitialize ()
返回 (ret)

.子程序 bmzh, 字节集
.参数 待转换数据, 字节集
.参数 转换前编码, 文本型
.参数 转换后编码, 文本型, , utf-8;unicode;GBK 等
.参数 转换后数据开始位置, 整数型, 可空, 位置从0开始。unicode编码标识占2个字节,utf-8编码标识占3个字节
.局部变量 对象, 对象
.局部变量 文本, 文本型
.局部变量 字节集, 字节集
.局部变量 变体型, 变体型

对象.创建 (“Adodb.Stream”, )
对象.写属性 (“Type”, 1)  ' 流类型为字节集
对象.方法 (“Open”, )
变体型.置类型 (7)
变体型.创建数组 (1, 取字节集长度 (待转换数据))
变体型.赋值 (待转换数据, )
对象.方法 (“Write”, 变体型)
对象.写属性 (“Position”, 0)
对象.写属性 (“Type”, 2)  ' 流类型为文本
对象.写属性 (“Charset”, 转换前编码)
文本 = 对象.文本方法 (“ReadText”, )
对象.方法 (“Close”, )
对象.方法 (“Open”, )
对象.写属性 (“Charset”, 转换后编码)
对象.方法 (“WriteText”, 文本)
对象.写属性 (“Position”, 0)
对象.写属性 (“Type”, 1)  ' 流类型为字节集
.如果真 (是否为空 (转换后数据开始位置) = 假)
    对象.写属性 (“Position”, 转换后数据开始位置)
.如果真结束
字节集 = 对象.通用方法 (“Read”, ).取字节集 ()
返回 (字节集)

.子程序 URL编码, 文本型, 公开
.参数 URL, 文本型
.局部变量 局部_数据, 字节集
.局部变量 i, 整数型
.局部变量 ii, 文本型

局部_数据 = 到字节集 (URL)
.计次循环首 (取字节集长度 (局部_数据), i)
    .如果 (到整数 (局部_数据 ) ≥ 48 且 到整数 (局部_数据 ) ≤ 57 或 到整数 (局部_数据 ) ≥ 65 且 到整数 (局部_数据 ) ≤ 90 或 到整数 (局部_数据 ) ≥ 65 且 到整数 (局部_数据 ) ≤ 90 或 到整数 (局部_数据 ) ≥ 97 且 到整数 (局部_数据 ) ≤ 122)
        ii = ii + 字符 (局部_数据 )
    .否则
        ii = ii + “%” + 取十六进制文本 (局部_数据 )
    .如果结束

.计次循环尾 ()
返回 (ii)

.子程序 URL解码, 文本型, 公开
.参数 URL, 文本型
.局部变量 循环容器, 整数型
.局部变量 Len, 整数型
.局部变量 HEX, 文本型
.局部变量 目标, 文本型
.局部变量 H, 整数型
.局部变量 L, 整数型

Len = 取文本长度 (URL)
循环容器 = 1
HEX = “0123456789ABCDEF”
.判断循环首 (循环容器 ≤ Len)
    .判断开始 (取文本中间 (URL, 循环容器, 1) ≠ “%”)
        目标 = 目标 + 取文本中间 (URL, 循环容器, 1)
    .默认
        循环容器 = 循环容器 + 1
        H = 寻找文本 (HEX, 到大写 (取文本中间 (URL, 循环容器, 1)), , 假) - 1
        循环容器 = 循环容器 + 1
        L = 寻找文本 (HEX, 到大写 (取文本中间 (URL, 循环容器, 1)), , 假) - 1
        目标 = 目标 + 字符 (H × 16 + L)
    .判断结束
    循环容器 = 循环容器 + 1
.判断循环尾 ()
返回 (目标)

.子程序 高级截取文本, 文本型, 公开
.参数 完整内容, 文本型
.参数 左边文本, 文本型
.参数 右边文本, 文本型
.参数 开始位置, 整数型, 可空, 可指定开始寻找的位置,为空则不指定
.参数 文本长度, 整数型, 参考 可空, 用一个变量来接收找到的文本长度
.参数 最大长度, 整数型, 可空, 指定返回的文本的最大长度。为空则返回全部
.参数 出现位置, 整数型, 参考 可空, 用一个变量来接收找到的位置
.参数 长度限制, 逻辑型, 可空, 是否只返回 长度不超过 最大长度 的文本,如果超出则返回空文本?
.局部变量 临时位置_左边, 整数型
.局部变量 临时位置_右边, 整数型
.局部变量 临时文本, 文本型

.如果 (是否为空 (开始位置))
    临时位置_左边 = 寻找文本 (完整内容, 左边文本, , 假)
.否则
    临时位置_左边 = 寻找文本 (完整内容, 左边文本, 开始位置, 假)
.如果结束
.如果真 (临时位置_左边 = -1)
    返回 (“”)
.如果真结束
临时位置_左边 = 临时位置_左边 + 取文本长度 (左边文本)
出现位置 = 临时位置_左边
临时位置_右边 = 寻找文本 (完整内容, 右边文本, 临时位置_左边, 假)
.如果真 (临时位置_右边 = -1 或 临时位置_左边 > 临时位置_右边)
    返回 (“”)
.如果真结束
文本长度 = 临时位置_右边 - 临时位置_左边
.如果真 (长度限制 且 文本长度 > 最大长度)
    返回 (“”)
.如果真结束
临时文本 = 取文本中间 (完整内容, 临时位置_左边, 文本长度)
.如果真 (是否为空 (最大长度) = 假)
    临时文本 = 取文本左边 (临时文本, 最大长度)
.如果真结束
返回 (临时文本)

.子程序 取文本中间1, 文本型, 公开
.参数 文本, 文本型
.参数 左边的文本, 文本型
.参数 右边的文本, 文本型
.参数 起始位置, 整数型, 可空
.局部变量 开始, 整数型
.局部变量 结束, 整数型
.局部变量 长度, 整数型
.局部变量 内容, 文本型

开始 = 寻找文本 (文本, 左边的文本, 起始位置, 真) + 取文本长度 (左边的文本)
.如果真 (开始 = -1 + 取文本长度 (左边的文本))
    返回 (“”)
.如果真结束
结束 = 寻找文本 (文本, 右边的文本, 开始, 真)
.如果真 (结束 = -1)
    返回 (“”)
.如果真结束
长度 = 结束 - 开始
内容 = 取文本中间 (文本, 开始, 长度)
返回 (内容)
善者 慈悲心常在 无怨无恨 以苦为乐
默认压缩密码www.hifyl.com
文件分享密码问题:http://www.hifyl.com/read-htm-tid-4444.html
快速回复
限100 字节
如果您在写长篇帖子又不马上发表,建议存为草稿
 
上一个 下一个