'易语言所有进制转换源码
’--------------------------------------------------------
'十六到字节集文本(原创)
'字节集文本到十六(原创)
'十六进制到字节集(原创)
'字节集到十六进制(原创)
'*************************************
.版本 2
.程序集 进制转换
.子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
_临时子程序 () ' 在初始化代码执行完毕后调用测试代码
返回 (0) ' 可以根据您的需要返回任意数值
.子程序 _临时子程序
' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
.子程序 十六到字节集文本, 文本型, 公开, 把转换后字节集用文本形式表现出来，可以复制到文本里。
.参数 十六进制文本, 文本型
.局部变量 局部_纯文本, 文本型
.局部变量 局部_字节, 整数型
.局部变量 局部_计次, 整数型
.局部变量 局部_字节集文本, 文本型
局部_纯文本 ＝ 删全部空 (十六进制文本)
.变量循环首 (1, 取文本长度 (局部_纯文本), 2, 局部_计次)
局部_字节 ＝ 十六到十 (取文本中间 (局部_纯文本, 局部_计次, 2))
局部_字节集文本 ＝ 局部_字节集文本 ＋ 到文本 (局部_字节) ＋ “,”
.变量循环尾 ()
局部_字节集文本 ＝ 取文本左边 (局部_字节集文本, 取文本长度 (局部_字节集文本) － 1)
返回 (“{” ＋ 局部_字节集文本 ＋ “}”)
.子程序 字节集文本到十六, 文本型, 公开, 把字节集以文本形式表现出来的数据转换到十六进制
.参数 字节集文本, 文本型
.局部变量 局部_十六进制, 文本型
.局部变量 局部_计次, 整数型
.局部变量 局部_临时字节集文本, 文本型
.局部变量 局部_定位字节位置, 整数型
.判断开始 (寻找文本 (字节集文本, “{”, 1, 假) ≠ -1)
局部_临时字节集文本 ＝ 取文本中间 (字节集文本, 2, 取文本长度 (字节集文本) － 2)
.默认
局部_临时字节集文本 ＝ 字节集文本
.判断结束
.计次循环首 (取文本长度 (局部_临时字节集文本), 局部_计次)
局部_定位字节位置 ＝ 1
.如果真 (寻找文本 (局部_临时字节集文本, “,”, 局部_定位字节位置, 假) ≠ -1)
局部_定位字节位置 ＝ 寻找文本 (局部_临时字节集文本, “,”, 1, 假)
局部_十六进制 ＝ 局部_十六进制 ＋ 到十六进制 (到数值 (取文本左边 (局部_临时字节集文本, 局部_定位字节位置)))
局部_临时字节集文本 ＝ 取文本右边 (局部_临时字节集文本, 取文本长度 (局部_临时字节集文
本) － 局部_定位字节位置)
.如果真结束
.计次循环尾 ()
局部_十六进制 ＝ 局部_十六进制 ＋ 到十六进制 (到数值 (局部_临时字节集文本))
返回 (局部_十六进制)
.子程序 十六进制到字节集, 字节集, 公开, 十六进制文本转换为字节集
.参数 十六进制文本, 文本型, , 十六进制文本
.局部变量 局部_纯文本, 文本型
.局部变量 局部_字节, 整数型
.局部变量 局部_计次, 整数型
.局部变量 局部_字节集, 字节集
局部_纯文本 ＝ 删全部空 (十六进制文本)
.变量循环首 (1, 取文本长度 (局部_纯文本), 2, 局部_计次)
局部_字节 ＝ 十六到十 (取文本中间 (局部_纯文本, 局部_计次, 2))
局部_字节集 ＝ 局部_字节集 ＋ 取字节集左边 (到字节集 (局部_字节), 1)
.变量循环尾 ()
返回 (局部_字节集)
.子程序 字节集到十六进制, 文本型, 公开, 把字节集数据转换为十六进制
.参数 字节集数据, 字节集
.局部变量 局部_计次, 整数型
.局部变量 局部_临时文本, 文本型
' 子程序的参数（形参）如果设置为参考，那么当调用此子程序的实参的数据也会发生同样的变化，实际上就是用指针把形参的数据传给了实参。
' ~~为了节约系统消耗已经取消了参考的参数~~~
.计次循环首 (取字节集长度 (字节集数据), 局部_计次)
.判断开始 (字节集数据 [局部_计次] ＜ 16)
.判断开始 (字节集数据 [局部_计次] ＝ 0)
局部_临时文本 ＝ 局部_临时文本 ＋ “00”
.默认
局部_临时文本 ＝ 局部_临时文本 ＋ “0” ＋ 十到十六 (字节集数据 [局部_计次], 假) ' 此处如果小于16的字节转换后前面不加文本（0）会出错的哦。
.判断结束
.默认
局部_临时文本 ＝ 局部_临时文本 ＋ 十到十六 (字节集数据 [局部_计次], 假)
.判断结束
.计次循环尾 ()
返回 (局部_临时文本)
.子程序 到十进制, 整数型, 公开, 将2,8,16进制文件转换到10进制数值(返回十进制数)
.参数 文本, 文本型, , 2,8,16进制文件
.参数 进制, 整数型, 可空, 默认为十六进制 2为二进制，8为八进制，16为16进制
.局部变量 局部_计次, 整数型
.局部变量 局部_文本, 文本型
.局部变量 局部_结果, 整数型
.如果真 (进制 ＝ 0)
进制 ＝ 16
.如果真结束
局部_文本 ＝ “0123456789ABCDEF”
.计次循环首 (取文本长度 (文本), 局部_计次)
局部_结果 ＝ 局部_结果 × 进制 ＋ 寻找文本 (局部_文本, 取文本中间 (到大写 (文本), 局部_计次, 1), , 假) － 1
.计次循环尾 ()
返回 (局部_结果)
.子程序 到十进制_之二, 长整数型, 公开, 成功返回转换后的十进制数值数据，失败返回 -1
.参数 十六文本,
文本型, , 传入十六进制文本型数据，支持大小写文本
.局部变量 局部_十进制, 长整数型, , , 转换后的十进制数值。
StrToInt64ExA (“0x” ＋ 十六文本, 1, 局部_十进制)
返回 (局部_十进制)
.子程序 十六到十, 整数型, 公开, 将十六进制转换成十进制(返回十进制文本)
.参数 十六进制文本, 文本型, , 待转换的十六进制文本
.参数 返回结果, 文本型, 参考 可空, 返回文本结果(如十进制数超出整数范围,可通过返回结果获得十进制文本)
.局部变量 局部_中间文本, 文本型
.局部变量 局部_结果, 长整数型
.局部变量 局部_容器, 整数型
返回结果 ＝ “”
.变量循环首 (1, 取文本长度 (十六进制文本), 1, 局部_容器)
局部_中间文本 ＝ 取文本中间 (十六进制文本, 局部_容器, 1)
局部_结果 ＝ (寻找文本 (“0123456789ABCDEF”, 局部_中间文本, , 真) － 1) × 求次方 (16, 取文本长度 (十六进制文本) － 局部_容器) ＋ 局部_结果
.变量循环尾 ()
.如果真 (是否为空 (返回结果) ＝ 假)
返回结果 ＝ 到文本 (局部_结果)
.如果真结束
返回 (局部_结果)
.子程序 到十六进制, 文本型, 公开, 返回转换后的十六进制文本
.参数 十进制数据, 整数型, , 传入十进制整型数据
.局部变量 局部_结果, 文本型
局部_结果 ＝ 取十六进制文本 (十进制数据)
.如果真 (取文本长度 (局部_结果) ％ 2 ＝ 1)
返回 (“0” ＋ 局部_结果)
.如果真结束
返回 (局部_结果)
.子程序 十到十六, 文本型, 公开, 将十进制转换成十六进制(返回十六进制文本)
.参数 十进制数, 长整数型, , 待转换的十进制数
.参数 是否不去零, 逻辑型, 可空, 默认为假:去0 真:不去0
.局部变量 局部_余数, 文本型, , "0"
.局部变量 局部_十六进制文本, 文本型
.局部变量 局部_计次, 整数型
.局部变量 局部_字母数组, 文本型, , "6"
.局部变量 局部_字节集, 字节集
.如果真 (是否不去零)
局部_字节集 ＝ 到字节集 (十进制数)
.计次循环首 ((取字节集长度 (局部_字节集) ＋ 2) ＼ 3, 局部_计次)
局部_十六进制文本 ＝ 到十六进制文本 (局部_字节集 [局部_计次]) ＋ 局部_十六进制文本
.计次循环尾 ()
返回 (局部_十六进制文本)
.如果真结束
局部_字母数组 ＝ { “A”, “B”, “C”, “D”, “E”, “F” }
.循环判断首 ()
.判断开始 (十进制数 ％ 16 ＜ 10)
加入成员 (局部_余数, 到文本 (十进制数 ％ 16))
.默认
加入成员 (局部_余数, 局部_字母数组 [十进制数 ％ 16 － 9])
.判断结束
十进制数 ＝ 十进制数 ÷ 16
.如果真 (十进制数 ＜ 16)
.判断开始 (十进制数 ＜ 10)
加入成员 (局
部_余数, 到文本 (取整 (十进制数)))
.默认
加入成员 (局部_余数, 局部_字母数组 [十进制数 － 9])
.判断结束
跳出循环 ()
.如果真结束
.循环判断尾 (真)
.计次循环首 (取数组成员数 (局部_余数), 局部_计次)
局部_十六进制文本 ＝ 局部_十六进制文本 ＋ 到文本 (局部_余数 [取数组成员数 (局部_余数) － 局部_计次 ＋ 1])
.计次循环尾 ()
.如果真 (取文本左边 (局部_十六进制文本, 1) ＝ “0”)
局部_十六进制文本 ＝ 去除首部零 (局部_十六进制文本)
.如果真结束
返回 (局部_十六进制文本)
.子程序 到十六进制文本, 文本型, 公开, 这个取十六进制文本没有去0
.参数 数值, 整数型, , 只能是255以内的数
' 取出十六进制文本，用易语言的函数会丢掉0，所以重新做了一个
返回 (多项选择 (右移 (数值, 4) ＋ 1, “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “A”, “B”, “C”, “D”, “E”, “F”) ＋ 多项选择 (位与 (数值, 15) ＋ 1, “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “A”, “B”, “C”, “D”, “E”, “F”))
.子程序 到十进制数, 整数型, 公开
.参数 十六进制, 文本型, , 只能是 FF 以内的数
.局部变量 局部_文本一, 文本型
.局部变量 局部_文本二, 文本型
局部_文本一 ＝ 取文本中间 (十六进制, 2, 1)
.如果 (局部_文本一 ＝ “”)
局部_文本一 ＝ 取文本左边 (十六进制, 1)
.否则
局部_文本二 ＝ 取文本左边 (十六进制, 1)
.如果结束
返回 ((寻找文本 (“0123456789ABCDEF”, 局部_文本二, , 真) － 1) × 16 ＋ 寻找文本 (“0123456789ABCDEF”, 局部_文本一, , 真) － 1)
.子程序 十到二, 文本型, 公开, 将十进制转换成二进制(返回二进制文本)
.参数 十进制数, 整数型, , 欲转换的十进制
.局部变量 局部_文本, 文本型
.局部变量 局部_返回文本, 文本型
.判断循环首 (十进制数 ＞ 0)
局部_文本 ＝ 局部_文本 ＋ 字符 (取代码 (“0”, ) ＋ 十进制数 ％ 2)
十进制数 ＝ 十进制数 ÷ 2
.判断循环尾 ()
.计次循环首 (取文本长度 (局部_文本), 十进制数)
局部_返回文本 ＝ 局部_返回文本 ＋ 取文本中间 (局部_文本, 取文本长度 (局部_文本) － 十进制数 ＋ 1, 1)
.计次循环尾 ()
返回 (局部_返回文本)
.子程序 二到十, 整数型, 公开, 将二进制转换成十进制(返回十进制整数)
.参数 二进制文本, 文本型, , 欲转换的二进制
.局部变量 局部_计次, 整数型
.局部变量 局部_结果, 整数型
.计次循环首 (取文本长度 (二进制文本), 局部_计次)
.判断开始 (到数值 (取文本中间 (二进制文本, 局
部_计次, 1)) ＜ 10)
局部_结果 ＝ 局部_结果 ＋ 到数值 (取文本中间 (二进制文本, 局部_计次, 1)) × 求次方 (2, 取文本长度 (二进制文本) － 局部_计次)
.默认
.判断结束
.计次循环尾 ()
返回 (局部_结果)
.子程序 十到八, 文本型, 公开, 将十进制转换成八进制(返回八进制文本)
.参数 十进制数, 长整数型, , 欲转换的十进制数
.局部变量 局部_余数, 长整数型, , "0"
.局部变量 局部_八进制文本, 文本型
.局部变量 局部_计次, 整数型
.循环判断首 ()
加入成员 (局部_余数, 十进制数 ％ 8)
十进制数 ＝ 十进制数 ÷ 8
.如果真 (十进制数 ＜ 8)
加入成员 (局部_余数, 取整 (十进制数))
跳出循环 ()
.如果真结束
.循环判断尾 (真)
.计次循环首 (取数组成员数 (局部_余数), 局部_计次)
局部_八进制文本 ＝ 局部_八进制文本 ＋ 到文本 (局部_余数 [取数组成员数 (局部_余数) － 局部_计次 ＋ 1])
.计次循环尾 ()
.如果真 (取文本左边 (局部_八进制文本, 1) ＝ “0”)
局部_八进制文本 ＝ 去除首部零 (局部_八进制文本)
.如果真结束
返回 (局部_八进制文本)
.子程序 去除首部零, 文本型
.参数 文本, 文本型
.局部变量 局部_计次, 整数型
.计次循环首 (取文本长度 (文本), 局部_计次)
.如果真 (取文本中间 (文本, 局部_计次, 1) ≠ “0”)
跳出循环 ()
.如果真结束
.计次循环尾 ()
返回 (取文本右边 (文本, 取文本长度 (文本) － 局部_计次 ＋ 1))
.子程序 八到十, 整数型, 公开, 将八进制转换成十进制(返回十进制整数)
.参数 八进制文本, 文本型, , 欲转换的八进制文本
.局部变量 局部_计次, 整数型
.局部变量 局部_结果, 整数型
.计次循环首 (取文本长度 (八进制文本), 局部_计次)
局部_结果 ＝ 局部_结果 ＋ 到数值 (取文本中间 (八进制文本, 局部_计次, 1)) × 求次方 (8, 取文本长度 (八进制文本) － 局部_计次)
.计次循环尾 ()
返回 (局部_结果)