字节集与逻辑型数组互转第二版，数组成员数不必再是8的倍数

CNWTEPRG

第一版:1字节有8个位，可以存放8个位成员，必须是8的倍数才可以转换，1个位成员等于1个逻辑型数组的成员。
第二版:开头前4字节标注有几个位成员，后面的是位的字节集数据，因此成员数可以是任意值。

转换过程
数组最后1成员如果为假则一直删除，遇到真为止，再往尾部填充假，到总成员数8的倍数为止。
处理后的逻辑型数组转换为字节集并在开头加上4字节转换前的位成员数即可。

还原过程
取开头前4字节数据，作为位成员数，第5字节到最后的数据为主要数据。
将主要数据还原成逻辑型数组，此时成员数还是8的倍数。
将成员数重定义成前4字节指定的位成员数并保留原有数据，多了用假填充，少了就删除。

1. 
   
2. .版本 2
   
3. .支持库 spec
   
4. 
   
5. .程序集 字节集与逻辑型数组互转
   
6. 
   
7. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
   
8. 
   
9. 
   
10. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
    
11. 返回 (0)  ' 可以根据您的需要返回任意数值
    
12. 
    
13. .子程序 _临时子程序
    
14. .局部变量 A, 逻辑型, , "0"
    
15. .局部变量 字节集, 字节集
    
16. .局部变量 B, 逻辑型, , "0"
    
17. 
    
18. ' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
    
19. A ＝ { 真, 真, 假, 假, 真, 假, 真, 真, 假, 假, 假 }
    
20. 
    
21. 字节集 ＝ 逻辑型数组到字节集2 (A)
    
22. 
    
23. 字节集到逻辑型数组2 (字节集, B)
    
24. 
    
25. 调试输出 (字节集, B)
    
26. 
    
27. 
    
28. .子程序 逻辑型数组转换前处理
    
29. .参数 逻辑型数组, 逻辑型, 参考 数组
    
30. .局部变量 计数, 整数型
    
31. .局部变量 填充数, 整数型
    
32. 
    
33. .变量循环首 (取数组成员数 (逻辑型数组), 1, -1, 计数)
    
34.     .如果 (逻辑型数组 [计数])
    
35.         跳出循环 ()
    
36.     .否则
    
37.         删除成员 (逻辑型数组, 计数, 1)
    
38.     .如果结束
    
39. 
    
40. .变量循环尾 ()
    
41. 重定义数组 (逻辑型数组, 真, 取数组成员数 (逻辑型数组) ＋ 8 － 取数组成员数 (逻辑型数组) ％ 8)
    
42. 
    
43. .子程序 逻辑型数组到字节集2, 字节集, 公开
    
44. .参数 逻辑型数组, 逻辑型, 数组
    
45. .局部变量 数组副本, 逻辑型, , "0"
    
46. .局部变量 位数, 整数型
    
47. 
    
48. 位数 ＝ 取数组成员数 (逻辑型数组)
    
49. 数组副本 ＝ 逻辑型数组
    
50. 逻辑型数组转换前处理 (数组副本)
    
51. 
    
52. 返回 (到字节集 (位数) ＋ 逻辑型数组到字节集 (数组副本))
    
53. 
    
54. 
    
55. .子程序 字节集到逻辑型数组2, , 公开
    
56. .参数 字节集数据, 字节集
    
57. .参数 逻辑型数组, 逻辑型, 参考 数组
    
58. .局部变量 位数, 整数型
    
59. 
    
60. 位数 ＝ 取字节集数据 (字节集数据, 3, 1)
    
61. 字节集到逻辑型数组 (取字节集右边 (字节集数据, 取字节集长度 (字节集数据) － 4), 逻辑型数组)
    
62. 重定义数组 (逻辑型数组, 真, 位数)
    
63. 
    
64. 
    
65. .子程序 字节集到逻辑型数组, , 公开
    
66. .参数 字节集数据, 字节集
    
67. .参数 逻辑型数组, 逻辑型, 参考 数组
    
68. .参数 高到低位, 逻辑型, 可空
    
69. .局部变量 字节集长度, 整数型
    
70. .局部变量 字节集计数, 整数型
    
71. .局部变量 移位位数计数, 整数型
    
72. .局部变量 移位后的值, 字节型
    
73. .局部变量 逻辑数组计数, 整数型
    
74. .局部变量 循环数组, 整数型, , "0"
    
75. 
    
76. 字节集长度 ＝ 取字节集长度 (字节集数据)
    
77. 重定义数组 (逻辑型数组, 假, 字节集长度 × 8)
    
78. .如果 (高到低位)
    
79.     循环数组 ＝ { 7, 0, -1 }
    
80. .否则
    
81.     循环数组 ＝ { 0, 7, 1 }
    
82. .如果结束
    
83. .计次循环首 (字节集长度, 字节集计数)
    
84.     .变量循环首 (循环数组 [1], 循环数组 [2], 循环数组 [3], 移位位数计数)
    
85.         逻辑数组计数 ＝ 逻辑数组计数 ＋ 1
    
86.         移位后的值 ＝ 左移 (1, 移位位数计数)
    
87.         逻辑型数组 [逻辑数组计数] ＝ 位与 (字节集数据 [字节集计数], 移位后的值) ＝ 移位后的值
    
88.     .变量循环尾 ()
    
89. .计次循环尾 ()
    
90. 
    
91. 
    
92. .子程序 逻辑型数组到字节集, 字节集, 公开
    
93. .参数 逻辑型数组, 逻辑型, 数组
    
94. .参数 高到低位, 逻辑型, 可空
    
95. .局部变量 逻辑组长度, 整数型
    
96. .局部变量 字节集数据, 字节集
    
97. .局部变量 字节集长度, 整数型
    
98. .局部变量 计数, 整数型
    
99. .局部变量 移位计数, 整数型
    
100. .局部变量 逻辑计数, 整数型
     
101. .局部变量 循环数组, 整数型, , "0"
     
102. 
     
103. 逻辑组长度 ＝ 取数组成员数 (逻辑型数组)
     
104. .如果真 (逻辑组长度 ％ 8 ≠ 0)
     
105.     输出调试文本 (“数组成员数必须是8的倍数才可以导出字节集数据。”)
     
106.     返回 ({  })
     
107. .如果真结束
     
108. 字节集数据 ＝ 取空白字节集 (逻辑组长度 ÷ 8)
     
109. 字节集长度 ＝ 取字节集长度 (字节集数据)
     
110. .如果 (高到低位)
     
111.     循环数组 ＝ { 7, 0, -1 }
     
112. .否则
     
113.     循环数组 ＝ { 0, 7, 1 }
     
114. .如果结束
     
115. .计次循环首 (字节集长度, 计数)
     
116.     .变量循环首 (循环数组 [1], 循环数组 [2], 循环数组 [3], 移位计数)
     
117.         .如果真 (逻辑型数组 [逻辑计数 ＋ 1])
     
118.             字节集数据 [计数] ＝ 位或 (左移 (1, 移位计数), 字节集数据 [计数])
     
119.         .如果真结束
     
120.         逻辑计数 ＝ 逻辑计数 ＋ 1
     
121.     .变量循环尾 ()
     
122. .计次循环尾 ()
     
123. 返回 (字节集数据)
     
124. 
     

复制代码

1心1亿

谢谢分享，正好需要。

520

这操作666