萍乡市王勇 2016:※§同创梦想☆◇

 

易语言常用词汇
如果
如果真
判断
判断循环首
判断循环尾
循环判断首
循环判断尾
计次循环首
计次循环尾
变量循环首
变量循环尾
到循环尾
跳出循环
返回
结束
相乘
相除
整除
求余数
相加
相减
负
取符号
取绝对值
取整
绝对取整
四舍五入
求次方
求平方根
求正弦
求余弦
求正切
求反正切
求自然对数
求反对数
是否运算正确
置随机数种子
取随机数
等于
不等于
小于
大于
小于或等于
大于或等于
近似等于
并且
或者
取反
位取反
位与
位或
位异或
左移
右移
合并整数
合并短整数
赋值
连续赋值
重定义数组
取数组成员数
取数组下标
复制数组
加入成员
插入成员
删除成员
清除数组
数组排序
数组清零
取命令行
取运行目录
取执行文件名
读环境变量
写环境变量
取所有发音
取发音数目
取拼音
取声母
取韵母
发音比较
输入字比较
取文本长度
取文本左边
取文本右边
取文本中间
字符
取代码
寻找文本
倒找文本
到大写
到小写
到全角
到半角
到文本
删首空
删尾空
删首尾空
删全部空
文本替换
子文本替换
取空白文本
取重复文本
文本比较
分割文本
指针到文本
到时间
增减时间
取时间间隔
取某月天数
时间到文本
取时间部分
取年份
取月份
取日
取星期几
取小时
取分钟
取秒
指定时间
取现行时间
置现行时间
取日期
取时间
到数值
数值到大写
数值到金额
数值到格式文本
取十六进制文本
取八进制文本
到字节
到短整数
到整数
到长整数
到小数
取字节集长度
到字节集
取字节集数据
取字节集左边
取字节集右边
取字节集中间
寻找字节集
倒找字节集
字节集替换
子字节集替换
取空白字节集
取重复字节集
分割字节集
指针到字节集
取磁盘总空间
取磁盘剩余空间
取磁盘卷标
置磁盘卷标
改变驱动器
改变目录
取当前目录
创建目录
删除目录
复制文件
移动文件
删除文件
文件更名
文件是否存在
寻找文件
取文件时间
取文件尺寸
取文件属性
置文件属性
取临时文件名
读入文件
写到文件
打开文件
打开内存文件
关闭文件
关闭所有文件
锁住文件
解锁文件
移动读写位置
移到文件首
移到文件尾
读入字节集
写出字节集
读入文本
写出文本
读入一行
写文本行
读入数据
写出数据
是否在文件尾
取读写位置
取文件长度
插入字节集
插入文本
插入文本行
删除数据
打开加密文件
运行
取剪辑板文本
置剪辑板文本
剪辑板中可有文本
清除剪辑板
取屏幕宽度
取屏幕高度
取鼠标水平位置
取鼠标垂直位置
取颜色数
输入框
信息框
鸣叫
取启动时间
置等待鼠标
恢复鼠标
延时
取文本注册项
取数值注册项
取字节集注册项
写注册项
删除注册项
注册项是否存在
取默认底色
快照
读配置项
写配置项
取配置节名
取操作系统类别
多文件对话框
播放音乐
停止播放
播放MID
播放MP3
同步播放MP3
暂停播放MP3
继续播放MP3
取MP3播放状态
输出调试文本
暂停
检查
是否为调试版
载入
选择
多项选择
是否为空
是否已创建
取数据类型尺寸
取颜色值
取事件组件
事件转移
复制窗口组件
处理事件
载入图片
卸载图片
取硬盘特征字
取系统语言
写到内存
DLL命令调用转向
置错误提示管理
置DLL装载目录
是否支持多用户
取错误码
取错误信息
创建
打开
替换打开
置当前库
取当前库
关闭
全部关闭
取库文件名
是否已打开
取记录数
取创建时间
取字段数
取字段名
改字段名
取字段类型
取字段尺寸
新建索引
置当前索引
取当前索引
更新索引
取索引数
取索引名
取索引字段
置加锁重试时间
锁住数据库
解锁数据库
锁住增删
解增删锁
锁住记录
解锁记录
全部解锁
取平均值
求和
取最大值
取最小值
取最大时间
取最小时间
计算数目
复制结构
复制记录
计算排序
排序
分类计算
添加
加记录
加空记录
替换
修改
删除
是否已删除
恢复删除
彻底删除
清空
读
写
读字段
写字段
附加字节集
附加备注
索引查找
查找
到首记录
到尾记录
跳过
取记录号
跳到
取标签
记录是否存在
标签跳转
首记录前
尾记录后
写出缓存
写出所有缓存
编辑
是否已加密
置数据库密码
密码输入框
复制密码
取主机名
通信测试
转换为主机名
转换为IP地址
标准输出
标准输入
取窗口句柄
销毁
获取焦点
可有焦点
取用户区宽度
取用户区高度
禁止重画
允许重画
重画
部分重画
取消重画
刷新显示
移动
调整层次
弹出菜单
发送信息
投递信息
取标记组件
置外形图片
激活
置托盘图标
弹出托盘菜单
置父窗口
加入文本
取设备句柄
清除
取点
画点
画直线
画椭圆
画弧线
画弦
画饼
画矩形
画渐变矩形
填充矩形
画圆角矩形
翻转矩形区
画多边形
置写出位置
写文本行
滚动写行
写出
定位写出
取宽度
取高度
画图片
取图片宽度
取图片高度
复制
取图片
单位转换
调用反馈事件
取顶端可见项目
置顶端可见项目
取项目数
取项目数值
置项目数值
取项目文本
置项目文本
加入项目
插入项目
删除项目
清空
选择
取顶端可见项目
置顶端可见项目
取项目数
取项目数值
置项目数值
取项目文本
置项目文本
取已选择项目数
取所有被选择项目
是否被选择
选择项目
取焦点项目
置焦点项目
加入项目
插入项目
删除项目
清空
选择
取顶端可见项目
置顶端可见项目
取项目数
取项目数值
置项目数值
取项目文本
置项目文本
加入项目
插入项目
删除项目
清空
选择
是否被选中
选中项目
是否被允许
允许
取子夹数目
取子夹名称
置子夹名称
跳转
打开
取设备句柄
开始打印
结束打印
取消打印
换页
开始下一份
画点
画直线
画椭圆
画弧线
画弦
画饼
画矩形
画渐变矩形
填充矩形
画圆角矩形
画多边形
置写出位置
写文本行
写出
定位写出
取宽度
取高度
画图片
取图片宽度
取图片高度
置自定义纸张类型
删除自定义纸张类型
取自定义纸张大小
取所有纸张类型
单位转换
发送数据
取回数据
连接
断开连接
发送数据
取回数据
取回数据
取回客户
发送数据
断开客户
启动
停止
发送数据
信号操作
置光标
选择
全部选择
取光标行号
取光标列号
取选择行数
取选择列数
等宽缩放
全部复制
复制
粘贴到光标处
粘贴
打印
打印预览
到首记录
到尾记录
跳过
跳到
取记录号
取表头行数
置表头行数
取表头列数
置表头列数
取行高
置行高
取列宽
置列宽
取类型
置类型
取文本色
置文本色
取背景色
置背景色
取字体名
置字体名
取字体尺寸
置字体尺寸
取字体属性
置字体属性
取边距
置边距
取文本输入格式
置文本输入格式
取对齐方式
置对齐方式
取密码方式
置密码方式
取文本
置文本
取数据
置数据
合并
分解
是否被合并
加线条
删线条
是否有线条
清除
置初始属性
初始尺寸
取行数
取列数
插入行
添加行
删除行
插入列
删除列
添加
存到字节集
从字节集读
存到文件
从文件读
单元格到字节集
字节集到单元格
单元格到文件
文件到单元格
刷新
保存更改
打印设置
〈打印设置信息 取打印设置
置打印设置
取打印页宽
取打印页高
取只读方式
置只读方式
打开
关闭
取连接文本
启动事务
回滚事务
提交事务
查询
重新查询
关闭记录集
首记录前
尾记录后
到首记录
到尾记录
到前一记录
到后一记录
读
执行
打开MDB数据库
打开SQL数据库
创建
获取
清除
是否为空
是否相等
读文本属性
读数值属性
读逻辑属性
读日期属性
读对象型属性
读属性
写属性
方法
通用方法
文本方法
数值方法
逻辑方法
日期方法
对象型方法
创建图片对象
创建字体对象
取回图片
取回字体
取错误
查看
取接口
清除
取类型
取数组成员数
取文本
取数值
取逻辑值
取日期
取对象
取变体型
赋值
创建
置类型
取字节集

• 评论(已有0条)
• 查看全文

学习易语言失败的十种现象2009-12-10 14:35

分享

1、与易语言擦肩而过，不去细致了解易语言，而是粗粗看过就下结论，如易语言输入中文慢啦，易语言不能写操作系统啦。还有的人是纠缠于无关紧要的地方，如是否是全编译，是否先将中文转换为英文进行的编译。

易语言通过首拼输入已完全解决了中文输入慢的问题,而面向快速应用开发而不是用于写操作系统的,再说你写操作系统要多少人年算过帐吗?
易语言将中文转换为英文再进行编译有这个必要吗？多一道手续不会慢吗，既然是全中文的，就以中文的语法分析+词法分析，最后直接生成CPU指令不是更方便吗，为何要多加一道手续呢。

2、初有了解，但了解还不够。受到一点小小的打击就承受不了。
于是乎自己很满足，学习一段时间后,可以写个小程序了,到论坛上发个小贴子，结果给骂得一无是处，于是生气不玩了。这样做是否是太小孩脾气了呢？

3、不能坚持学习。成功总是给那些有准备的人。
不能坚持学习下去，遇到困难总是埋怨易语言不好，然后发一通唠，只有坚持不懈的人才会到达成功的彼岸．

有困难一般有人能够帮助你，如在论坛搜索一下有没有以前别人写过的例程，如果没有可以发贴求助，

4、墙头草，两边倒，总拿易语言与别的语言对比。
易语言先与VB比，易语言现在比VB强一点了，又与DELPHI比，总之，举棋不定，在学与不学上伤脑筋。这是猴子掰玉米的作风呀！

5、发现程序不能运行，不先自己找原因，而总是说易语言有BUG，发贴大叫求助，等问题解决了，还是自己的错。
易语言有强大的调试功能，如果您能正确应用，一般的问题都能自己查出来的。

6、团队的无效无发。
自己的项目太大，不能完成，于是从网上组织团队开发，组织不够严密，团队开发失败！效益不能回收，谁还有积极性呢？

7、将别人的软件改改界面就发布，一点也没有改进和集成，盗版别人的软件，于是乎，这种人根本没有学到东西。

8、已是易语言老用户了，总是发一些批评易语言的贴子，以此来发泻编程中的压力。跟风的人也不少，反正论坛是自由的，却不知，你的贴子会影响别人的学习热情。

9、死追版主的贴子，版主一发言，都有不对的地方，尽力打击，不让版主发言。帮助过自己的版主都是特别好，未帮过自己的都一无是处。

10、违反国家法律，什么写病毒，写外挂，写农行验证码破解。总有一天未得回报，先得一手拷。
以上是易友们总结的，要好好学习！加强编程水平！！

• 评论(已有0条)
• 查看全文

第十三课.常用算法2009-12-09 14:52

分享

概括地说，“算法”是指解题方案的准确而完整的描述。
对于一个问题，如果可以通过一个计算机程序，在有限的存储空间内进行有限长的时间而得到正确的结果，则称该问题是算法可解的。但算法不等于程序，也不等于计算方法。程序可以作为算法的一种描述，但程序通常还需考虑很多与方法和分析无关的细节问题，这是因为在编写程序时要受到计算机系统运行环境的限制。通常，程序设计的质量不可能优于算法的设计。
通常求解一个问题可能会有多种算法可供选择，选择的主要标准是算法的正确性和可靠性，简单性和易理解性。其次是算法所需要的存储空间少和执行更快等。
算法设计是一件非常困难的工作，经常采用的算法设计技术主要有列举法、递推法、贪婪法、回溯法、分治法、动态规划法等等。另外，为了更简洁的形式设计和藐视算法，在算法设计时又常常采用递归技术，用递归描述算法。


8.1列举(穷举、枚举)法

列举法的基本思想是根据提出的问题，列举所有可能情况，并用问题中提出的条件检验哪些是需要的，哪些是不需要的。因此，列举法常用于解决“是否存在”或“有多少种可能”等类型的问题。例如，求解不定方程的问题可以采用列举法。
列举法的特点是算法比较简单，但当列举的可能情况较多时，执行列举算法的工作量将会很大。因此，在用列举法设计算法时，应该重点注意使方案优化，尽量减少运算工作量。通常，只要对实际问题作详细的分析，将与问题有关的知识条理化、完备化、系统化，从中找出规律，或对所有可能的情况进行分类，引出一些有用的信息，列举量是可以减少的。
先介绍“列举法”在易语言中实现的方法。
列举法，顾名思义是列举出所有可能的情况，并用问题的条件来一一检验，并从中找出符合要求的解。特点比较简单，但是在写列举算法时尽量过滤掉一些不必要的情况，优化算法。下面举一个例子，在易语言中编写代码实现，来说明列举法的基本思想，以及如何减少列举量。
大家都知道百鸡的问题吧！母鸡每只3元，公鸡每只2元，小鸡每只0.5元，计算一下如何100块钱买100只鸡。
计算中，只有以下两个条件成立，才输出结果。


母鸡数量+公鸡数量+小鸡数量=100只
3×母鸡数量+2×公鸡数量+0.5×小鸡数量=100元




可以看到，各层循环均需循环101次，因此总循环次数为1013 ，列举量太大。但只对问题稍加分析，很容易发现这个算法还可以改进，减少不必要的循环次数。
首先，考虑到母鸡为3元一只，因此，最多只能买33只母鸡，即算法中的外循环只需要从0到33就可以了，没有必要从0 到100。
其次，考虑到公鸡为2 元一只，因此，最多只能买50只公鸡。又考虑到对公鸡的列举是在算法的第二层循环中，因此，在第一层循环中已确定买母鸡数量的情况下，公鸡最多只能买50-母鸡数量，即第二层中对“公鸡”只需要从0到50-母鸡数量就可以了。
最后，考虑到总共买100只鸡，因此，在第一层循环中已确定买母鸡的数量，且第二层已确定买公鸡的情况下，买小鸡的数量只能是100-母鸡数量-公鸡数量，即第三层的循环已没有必要了。并且，在这种情况下，条件：母鸡数量+公鸡数量+小鸡数量=100只自然已经满足。




列举所有可能情形，最直观的是联系循环的算法。但，循环层数的改变，就影响了这一问题的解，即没有一般性。例如：有多种鸡，而每种鸡的价格又不同，每次根据一个固定的金额购买某几种鸡。
8.2递推法

 
所谓递推，是指从已知的初始条件出发，逐次推出所要求的各中间结果和最后结果。其中初始条件或是问题本身已经给定，或是通过对问题的分析与化简后确定。递推本质上也属于归纳法。许多递推公式，实际上是通过对实际问题的分析与归纳而得到的，因此，递推是归纳的结果。
也就是利用问题本身所具有的一种递推关系求问题解的一种方法。设要求问题规模为N的解，当N=1时，解或者已知，或者能非常方便地得到解。能采用递推法构造算法的问题有重要的递推性质，即当得到问题规模为i-1的解后，由问题的递推性质，能从已求得的规模为1，2，…，i-1的一系列解，构造出问题规模为I的解。这样，程序可从i=0或i=1出发，重复地，由已知至i-1规模的解，通过递推，获得规模为i的解，直至得到规模为N的解。
递推法中最具代表的就是阶乘法,下面采用分段乘法进行大数求阶乘。

在计算阶乘的时候，随着数字的增加，计算的结果会以极快的速度激增。当使用整数型数据储存结果时，当超过12时，计算结果将溢出；当使用长整数型数据储存结果时，当超过20时，计算结果将溢出。
为了能够计算较大的整数的阶乘并得到准确的结果，必须考虑适当的算法，分段乘法是其中的一种，将每一步的中间结果使用数组分段储存，数组的一个成员储存一段数据，由于我们经常使用的是10进制，因此以10的n次方为标准进行分段是可行的。同时需要考虑分组相乘时，每组是否会出现溢出，因此数组的类型采用长整数型。
这里采用该算法写了一个模块，循环和数组配合，虽然能计算出正确的结果，但速度较慢，计算10000的阶乘需要50秒（最快的在1秒左右，大家可以使用Windows的计算器试试），计算50000的阶乘，耗时24分钟，估计不会有人尝试计算更大的数值。
分段相乘完毕后还要考虑每组的数值是否超过分段的标准，如果超过要进位。 代码参见例程。
 
8.3递归算法



描述递归定义的函数或求解递归问题的过程称为递归算法。一个递归算法，本质上是将较复杂的处理归结为较简单的处理，直到最简单的处理。因此，递归的基础也是归纳。
下面学习易语言中递归算法的运用。
    在易语言中许多地方可以用到递归算法，典型特征是自己调用自己。逐步到达条件边界，直到目的完成，如：“寻找文件（）”等，递归算法结构比较简练，清晰易读，但，缺点是执行效率比较抵。
下面来练习寻找的的写法。
首先需要作一个单独的寻找子程序，如：名字取为“寻找”，参数为“寻找路径” 文本型。
由于“寻找文件（）”命令很特殊，好多初学者不好理解，因为寻找文件每次只返回一个匹配对象，所以一定要用循环才可以找到所有的匹配条件者，而第一次使用寻找到一个匹配条件者，再继续寻找其他文件就不需要指定寻找文件条件了。
代码可分为三部分，
第二部分是关键代码，首先调用
文件名 ＝ 寻找文件 (寻找路径 ＋ “*.tmp”, )

因为只返回一个文本，所以用一个判断循环，判断“文件名”是否为空 ，如果不空 继续寻找，否者……
这部分只寻找一个目录里所有匹配者，不会寻找里面文件夹里的匹配者，当然不能放过它们，


第三部分是递归算法，等于子程序调用自己
寻找 (寻找路径 ＋ 文件名)
就是这句，你也许会问
如果真 (取文本左边 (文件名, 1) ≠ “.”)

是什么意思，其实就是判断文件名是不是文件夹，再XP命令提示符输入“dir”,一看就知道了。“.”是本级目录，“..”是上一级目录。
一定不要忘了在这个子程序里面加上
处理事件 ()

否则运行后机器会假死。
下面是另一个运用递归算法求最大公约数的例程，核心部分只用了6行代码，


注意：％ 是求余数的运算符，不是除号，也不是百分号。
此例中求最大公约数，没有使用常用的短除算法，使用辗转相除法更便于编程。


8.4查找运算

顺序表上的查找运算有很多种。如顺序查找法、二分法、分块查找法等。
我们先来介绍顺序查找法。顺序查找法，就是在表中顺序对比节点和欲查找数据的值，相同则返回相应的位置值。其过程，就是对表的顺序扫描。这是一种方法简单，但效率不高的查找方式。




8.5对分（二分）查找

对分查找又称折半查找，它是一种效率高的查找方法。
对分查找的基本思想是：
1.首先确定该区的中点位置；
2.然后将待查的值与中间值进行比较，若相等，则查找成功并返回此位置，否则须确定新的查找区间，继续二分查找，具体方法如下：
（1）若中间值大于待查的值，则由表的有序性可知，中间值右表中的值均大于待查值，因此若表中存在等于待查值的值，则该值必定是在中间值左边的子表中，故新的查找区是左子表。
（2）类似地，若中间值小于待查值，则要查找的值必在中间值的右子表中，即新的查找区间是右子表。下一次查找是针对新的查找区间进行的。
因此，从初始的查找区间开始，每经过一次与当前查找区间的中点位置上的节点的比较，就确定是否成功，不成功则当前的查找区间就缩小一半。这一过程重复直至找到中间值的值，或者直至当前的查找区间为空（即查找失败）时为止。
数据越多越能体现对分查找法的好处。
其实，每次插入都是比较大小安排插入位置，为了插到大于和小于数值的中间。如4、6、8、50、55、59，如果给一个56，当然知道插入到55后面，以前的代码是从4开始一一比较，而我们可以直接把数组对分，比一下是比前一部分大，还是比后一部分大，再在剩余结果对分比较，再对分……。逐一比较平面需要比较5次，对分只需要比较2次，数据越多，越能体现。








8.6冒泡排序

    冒泡排序是最简单也是最经典的。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮（相反，较大的元素比较重，从而要往下沉）。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并同时注意两个相邻的元素的须序是否正确。如果发现两个相邻元素的须序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置（或最重的元素沉到最低位置）；处理两遍之后，“次轻”的元素就浮到了次高位置。在第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不需检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序了。
    关键在于每循环一遍都记录交换的次数，避免下次不必要的比较，还要记住最后交换的位置，这个位置以后的数据下次可以在之前比较。
比如现在有一组数据，第一次先比较所有的数据，而后记下最后比较位，而每次如果有数据交换，就继续循环比较。而比较的最后位置则是循环的最大值。









8.7 直接插值排序
直接插入排序的基本思想是：每次把一个待排序的节点，按其关键字的大小插入到前面已排序好节点中，直到全部节点插入完毕。
两个重要概念。有序区：是指顺序表中已排序好的部分。无序区：即表中未进行排序的区域。例如，一维数组[2，5，6，2，9，5，47]  有序区的范围是：【1，3】（从1到3节点），无序区是：【4，7】（从4到7节点）。对于任何一个节点为n（n>1)的顺序表,其初始有序区的范围是【1，1】无序区的范围是【2，n】。插入排序的基本思想就是不断增大有序区，减小无序。直到无序区消失。
直接插入排序的原理：每次将无序区的第一个节点插入到有序区中。
例如，无序数组[8，5，6，4，3，9，4]，其初始有序区【1，1】,无序区【2，7】。第一次插入运算，将无序区第一个节点“5”插到前面的有序区中。运算后数组为[5,8,6,4,3,9,4],有序区为【1，2】无序区为【3，7】。第二次插入运算，将无序区的第一个节点“6”插入到前面的有序区中，运算后的数组为[5,6,8,4,3,9,4],其有序区为【1，3】，无序区减小成【4，7】。
如此重复，经过6次插入运算，有序区成为【1，7】，无序区消失。此数组成为有序数组。代码如下：


本段代码用到了查找算法和插入算法。
直接插入排序法的代码在执行过程中，大部分时间是消耗在查找插入点位置和移动节点上。节点的移动是必须的，此类算法是无法减少移动次数的，除非是用新的算法。而每次都从无序区首（即表的第一个节点）开始寻找插入点的过程是完全没有必要的，可以用我们讲过的二分查找法优化此过程。以下是实现代码。


上面对直接插入排序进行了优化，我们暂且把优化算法称为二分直接插入排序，这种算法仅仅是对寻找插入点的过程做了优化。如果我们能找到另一种方法，可同时减少寻找插入点的次数和移动节点的次数，就可显著的提高排序的运算速度。
以下介绍的希尔排序算法是直接插入排序法的一种变种，它能有效的减少这两个方面的运算量，从而显著的提高排序操作的运算速度。
原理： 先取一个小于节点数的整数k作为分组单位，把表上的所有相距k的节点逻辑上看成一组。在个组内进行直接插入排序；减小k的取值，把表上的所有相距k的节点逻辑上看成一组。在个组内进行直接插入排序；重复以上步骤；最后一次k取1，即对整个表做直接插入排序。
其中k称为增量，增量的取值集合称为增量表。
例，无序数组[4,5,8,2,6,8,9,2,4,5,1,6,1,5,4,2]  增量表我们取成“5，3，1”（k的取值集合）。
(1) 当k＝5时，表上的逻辑分组情况为：【1，6，11。16】【2，7，12】【3，8，13】【4，9。14】【5，10，15】（【 】内均是数组的下标值）。k＝5时组内进行直接插入排序过程为：
第一组：数组成员分别为“4”，“8”，“1”，“2”。排序后的数组[1,5,8,2,6,2,9,2,4,5,4,6,1,5,4,8]
第二组：数组成员分别为“5”，“9”，“6”。      排序后的数组[1,5,8,2,6,2,6,2,4,5,4,9,1,5,4,8]
第三组：数组成员分别为“8”，“2”，“1”。      排序后的数组[1,5,1,2,6,2,6,2,4,5,4,9,8,5,4,8]
第四组：数组成员分别为“2”，“4”，“5”。      排序后的数组[1,5,1,2,6,2,6,2,4,5,4,9,8,5,4,8]
第五组：数组成员分别为“6”，“5”，“4”。      排序后的数组[1,5,1,2,4,2,6,2,4,5,4,9,8,5,6,8]
此次运算后数组为[1,5,1,2,4,2,6,2,4,5,4,9,8,5,6,8]


(2) 当k＝3时，表上的逻辑分组情况为：【1，4，7，10，13，16】【2，5，8，11，14】【3，6，9，12，15】（【  】内均是数组的下标值）。k＝3时组内进行直接插入排序过程为：
第一组：数组成员分别为“1”，“2”，“6”，“5”，“8”，“8”
        排序后的数组[1,5,1,2,4,2,5,2,4,6,4,9,8,5,6,8]
第二组：数组成员分别为“5”，“4”，“2”，“4”，“6”     
        排序后的数组[1,2,1,2,4,2,5,4,4,6,5,9,8,6,6,8]
第三组：数组成员分别为“1”，“2”，“4”，“9”，“6”
        排序后的数组[1,2,1,2,6,2,6,2,4,5,4,6,8,5,9,8]
此次运算后数组为[1,2,1,2,6,2,6,2,4,5,4,6,8,5,9,8]


(3) 当k＝1时，表上的逻辑分组情况为：【1，2，3，4，5，6，7，8，9，10，11，12，13，14，15，16】（【  】内均是数组的下标值）。即整个表分为一个组，此时对整个表做直接插入表排序，可以发现此次运算时节点移动是非常少的。此次运算后数组为有序数组。
通过以上详细的运算过程描述，我们可以发现：当k值很大时，组很小，查找和移动量都很小，随着k值增大，组虽然增大，查找运算量增大了，但最耗时间的移动节点运算量却在减小。总的排序运算耗时是显著的减小，效率成倍提高。代码如下：




8.8 线表插值排序

在易语言中，一维数组上插入一个数据可以直接调用 “插入成员(欲插入成员的数组变量，欲插入的位置，欲插入的成员数据）”系统命令。我们来研究它是怎么实现的。
原理很简单，当向一维数组的第i个位置插入一个数据时，第i个位置及它以后的数据依次都向后移动，将第i个位置腾出来后，把所要插入的数据写入该位置。
具体的实现步骤如下：
(1) 首先增加数组的长度。在易语言中可以用“加入成员（）”和“重定义数组（）”两种方法。前者可能更快些。
(2) 移动数据。不破坏数据，当然是从数组的最后位置向前移动了。可设一个位置变量“数据位置”指向最后位置。“数组” 是定义的一维数组。“数组[数据位置]”,就是我们插入数组尾部的空数据。
数组[数据位置]=数组[数据位置-1]
把数组的倒数第二个数据移到尾部。然后
数据位置＝数据位置-1
“数据位置”指向数组的倒数第二个数据，
数组[数据位置]=数据[数据位置-1]
把数组的倒数第三个数据移到数组的倒数第二个位置上，......依次移动，最后把数组的第i个位置上的数据移到i+1的位置上。
(3) 把需要插入的数据插入到“数组”。
代码如下：




8.9 数组插值排序

随机生成数字或文本。按从大到小或从小到大排序。
现在我们用数组排序。如果是数值可以用数组的“数组排序 (, )”。代码如下：


上面的代码比较简短，但是在某些时候，比如多项排序，就不好控制了，多位数组动态加入会自动变成单维的。下面是排序的标准写法，当然只是个框架，代码如下：


上面只是数值排序，大家可以练习一下文本、时间、逻辑。
8.10删除运算
在易语言中，一维数组中数据（节点）在逻辑上是顺序相连的，并且它们在计算机中内存中也是顺序存储的，我们一般称顺序存储的线性表为顺序表。注意，顺序表是从存储方式上来描述表结构的；线性表则是从逻辑上描述表结构的。表结构从逻辑上可分为线性表和非线性表。线性表和非线性表都可以用两种方式存储，即顺序存储（如数组），和链式存储。表的链式存储方式需要指针。
在易语言中顺序表是建立在一维数组基础上的表结构。本节讲述顺序表上的删除运算：
删除运算也是通过移动节点来完成的。删除i节点时，我们只要把i后面的节点依次向前移动。在一维数组中把欲删除的位置后面的数据依次前移，把最后位置的数组成员删除，便完成了此运算。只有删除最后位置上的数据时不需要移动数据，直接删除该成员。

• 评论(已有0条)
• 查看全文

第十二课.程序调试2009-12-09 14:51

分享

几乎每一个稍微复杂一点的程序都必须经过反复的调试、修改，才能最终完成。很显然，只有正确找出错误的地方才可以将其改正。出错以后怎样找出错误的地方就变得很重要了，下面就谈一些查错的方法。






7.1调试工具



1．易语言内部侦错
输入程序代码时有明显的语法错误存在，易语言会提示错误原因，而且当使用Ctrl+Enter键编译当前行时，错误代码无法通过编译。当用户写完一段代码后，试运行程序，易语言会对所有可能执行到的语句进行初步编译，当编译时发现明显的格式或语法错误时，易语言会将光标自动移动到错误行，并提示错误原因，用户可以根据光标提示和错误原因很快改正错误。如图1所示。



虽然易语言提供的内部侦错功能十分强大，但也只能指出输入上的格式错误，如数据类型不匹配、指定的变量或组件未找到等。而对于那些程序员编程时，逻辑上的错误，易语言就无能为力了。这就需要其他调试方法和调试命令的配合使用，快速而准确的找到错误代码。
2．跟踪调试方法解释





各调试项目在易语言状态条中的解释如下：
①在程序现行运行位置单步执行一行程序，如果此程序行调用了子程序，则跟踪进入子程序。

②在程序现行运行位置单步执行一行程序，如果此程序行调用了子程序，系统不会跟踪到该子程序中去。

③在上级子程序调用现行子程序的语句后中断。

在被调用子程序中设置断点，断点行被跟踪后，跳出当前子程序，系统跟踪至上级程序调用当前子程序语句的下一行代码。注意：被调用子程序断点后的代码被执行。
④运行易程序，在当前光标处程序行处中断。

⑤设置或清除当前程序行处的断点。

⑥清除掉程序中的所有断点。

⑦跳到现行即将被执行语句的位置。

3．跟踪法
编写一个比较简单的程序，看看程序是如何调试的。例程“调试程序.e”代码如下：


该程序是输出300以内同时能被2，3，5整除的整数。 现在开始调试。调试有多种方法，先介绍一种不需要设置断点就可以调试程序的方法。
首先选中要被调试的程序代码行。然后选择“执行到光标处”子菜单项目。



    按“F5”键运行程序，当程序执行到被选中代码时，系统便将程序挂起，并用黄色箭头指示代码执行位置。


通常用“F8”键就可以实现把程序每一步执行的情况都反映出来的功能。此方法就是模拟计算机一步步执行程序的过程。
当前程序已经被运行，不断按“F8”就可以使程序一步一步执行，直到最后一行代码被执行完毕。

为了更直观的了解程序的运行过程，在跟踪程序的同时打开易语言的“查改变量”面板。选中“局部计次变量”

不断按“F8”的同时，“局部计次变量”的值也不断的改变。
下面介绍图4中标题为“写入”按钮的使用方法。

此按钮的作用是改写被选中变量的值，使被调试程序直接运行符合此变量被写入值的代码行处。
首先选中变量值，输入将被写入的值，按“写入”按钮。然后使程序设计界面获得焦点，再按“F8”键跟踪程序。

例程“调试程序1.e”，使用改写逻辑变量的值可以更直观的看到程序的运行效果。
例程“调试程序2.e”，按照前面的步骤，在“_启动窗口_创建完毕”事件子程序和“子程序1”中选中代码行进行跟踪，比较各个跟踪方法。
4．断点法
在前面已经学习了基本的程序调试方法。但也有一个缺点，就是在遇到循环次数比较多或者语句比较多的时候，用起来比较费时，下面用一种新的也是常用的调试方法：断点法。
所谓断点法，就是在程序执行到某一行的时候，调试器自动“中断”程序运行，并保留这时各变量的状态，方便检查、校对。还用“程序调试2.e”为例，具体操作如下：
选中被调试程序代码，按下“F9”键，这时发现，该行首部加入红点，这表明该行已经被设置成断点行，当每次运行到此行的时候，程序都会自动停下来供编程人员调试。如下所示：



请记住，计算机是执行到断点行之前的一行，断点行并没有执行，所以这时“逻辑变量2 = 真”这一句并没有执行，其值还是为假。

    “调用表”面板显示当前被执行代码所在程序集。
断点除了有以上用处之外，还有另外一个重要用处：它方便大家判断某个语句有没有执行或者是不是在正确的时刻执行，因为有时程序由于人为的疏忽，可能在循环或者递归时出现无法预料的混乱，这时候通过断点法，就能够判断程序是不是依照预期的顺序执行。





7.2调试输出命令



1．“输出调试文本（）”

仅在易程序的调试版本中被执行，在发布版本中将被直接跳过；使用本命令可以在易语言调试系统的“输出”面板中输出指定的文本行以帮助调试，该文本之前被自动加上一个星号（*），之后被自动加上回车换行符。

如果觉得“改写变量”面板只能显示当前被调试程序变量的一个值，无法与前面或后面程序运行时变量的值进行对比，十分的不方便。就可以用“输出调试文本（）”命令实现这个功能。在“__启动窗口_创建完毕”事件子程序中添加“输出调试文本（）”命令如下：



注意提供的参数数据类型必须为文本型。


按“F5”键运行程序，在“输出”面板中显示，

如果调试时使用到多个“输出调试文本（）”命令，就必须提供被显示变量值的变量名或变量值的解释文本。在“子程序”中的最后一个如果真语句中添加“输出调试文本（）”

    可以很清楚的看到，只有“局部计次变量”的值为“30”时程序才会执行到最后一个如果真语句中，并使“逻辑变量3”的值为真。

2．“暂停（）”
仅在易程序的调试版本中被执行，在发布版本中将被直接跳过；可以在子程序中的任何地方放置此命令，使用此命令，就相当于在程序代码中设置断点。
3．“检查（）”

仅在易程序的调试版本中被执行，在发布版本中将被直接跳过；执行本命令时，如果给定参数的条件值被计算后结果为假，易程序的执行将被暂停且警示。可以在子程序中的任何地方放置此命令，使用此命令，就相当于在程序代码中设置条件断点。

为方便了解“检查（）”命令的作用，用“输出调试文本（）”命令配合使用。首先将前面添加的两个“输出调试文本（）”命令置为草稿。新添加调试命令代码如下：



按“F5”键运行程序，当“检查（）”命令中的条件不成立时，程序被暂停。提示如下图所示。



分析提示文本，
当“局部计次变量”为“1”时，程序无法进入“子程序1”中的第一个如果真条件语句中执行，所以“逻辑变量1”的值保持不变，为假，“检查（）”命令没有被执行。而“输出调试文本（）”命令正常输出文本（“局部计次变量”的值和“---------”）。当“局部计次变量”为“2”时，符合“子程序1”中第一个如果真条件语句，其中的代码被执行，“逻辑变量1”的值为真，“检查（）”命令的条件不成立，“检查（）”命令被执行并输出提示。
4．“是否为调试版（）”

如果当前 EXE 易程序执行文件为易语言编辑环境调试运行程序时编译出来的调试版本，返回真。否则表明为发布版本，返回假。

    5．“信息框（）”

在对话框中显示信息，等待用户单击按钮，并返回一个整数告诉用户单击哪一个按钮。

“信息框（）”是软件中必不可少的组成部分，是用户与软件之间的一种通信通道。

但在程序的调试过程中也被经常使用到，而且可以达到多种调试方法的功能。如：断点、暂停（）、输出调试文本（）等方法和命令。将程序中的调试命令全部置为草稿，添加“信息框（）”，




按“F5”运行程序，信息框提示“局部计次变量”为“30”，信息框被第一次执行，程序被暂停。

使用“信息框（）”显示数据不需要考虑是文本、数值、逻辑值或日期时间。如果同时显示不同数据类型变量和数据值，必须先转换到文本型。

注意：“信息框（）”不适合在“时钟周期”事件中和循环次数比较多的代码中使用。




7.2调试总结



程序中出现的错误通常分为“语法错误”和“逻辑错误”。
所谓“语法错误”是指程序代码不符合易语言语法。这种错误最容易发现和修改：首先在代码输入的时候，系统就会检查并发现一部分语法错误；其次在程序运行的时候，系统执行到有语法错误的代码行，也会发现并指出错误原因。由此可见，系统会帮助找出所有的语法错误，只要按照其提示信息进行相应的修改即可。
所谓“逻辑错误”是指程序流程上、处理上的错误。含有“逻辑错误”的程序能够正常执行，只是执行结果不正确。这类错误系统是不可能发现的，只有靠编程者自己去寻找。
实际应用中，通常是将“断点”“单步跟踪”“查改变量”（以及调试输出）等调试方式结合起来使用。
一般的程序调试步骤是这样的：
1．运行程序，执行所有的程序功能，从而找出并修改所有“语法错误”；
2．通过分析判断，找到可能有“逻辑错误”的代码段；
3．在“有逻辑错误的代码段”前面设置“断点”；
4．运行程序，待程序在“断点”处中断后，使用“单步跟踪[Shift+F8]”“单步跟踪进入[F8]”“跟踪返回[Ctrl+Shift+F8]”“执行到光标处[Ctrl+F8]”等调试命令跟踪程序的运行。跟踪过程中，随时观察各变量值的变化（通过状态夹中的“查改变量”，可看到所有全局和局部变量），必要时使用调试输出命令将变量值输出。通过跟踪，一般能发现程序出错的原因。
5．终止程序运行，修改代码，继续调试。

• 评论(已有0条)
• 查看全文

第十一课.数组2009-12-09 14:50

分享

到现在为止，我们在前几章中所用到的各种变量，都有一个特点，就是在程序运行的任何时刻，每个变量名都能代表一个数据。这种变量名，我们叫做简单变量。
用简单变量固然可以编写出各种各样的程序。但是如果在程序中有成组地出现的数据时，程序的编写与处理，将是十分麻烦的。
假定我们要处理200个学生的考试成绩，每人考6门课，共有1200个分数。这1200个分数如果要反复使用，最好的办法是把这1200个数一次读入1200个变量，否则每次使用得从头读一遍。1200个变量在内存中，随时可以使用，这当然很方便，然而这是不可能的。而对于一个数组中的多个不同元素，只需取多个不同的下标即可。而且下标又可以通过程序的运行予以改变，这就给编写程序提供了较大的方便。
数组变量可以存放一组数据，数组的成员数可以自行定义，并且在程序运行后还可以动态改变，赋值方法也多种多样。即可以动态的管理数组变量。所以数组变量是使用非常灵活、应用非常广泛的一种变量。
数组变量又分为“单维数组变量”和“多维数组变量”。
单维数组变量，成员的表示形式为：
数组变量名［数组成员下标］
如：变量［2］，表示该数组中的第2个成员。注意，易语言中的数组下标是从1开始的，根本不存在“变量[0]”这个数组成员。
多维数组变量，可以看作是一个特殊的单维数组，它的成员也可以看作是多个单维数组。多维数组成员的表示形式为：
多维数组变量名[数组成员下标][数组成员下标]
如：变量［1］［2］，意思是一个二维变量中的第二个成员。


6.1数组变量的定义及赋值



1．数组变量的定义方法
在欲定义变量的数组属性上输入要定义的成员数。例如，要将“变量”定义为有3个成员的数组变量，就在“变量”的数组属性上输入3，定义后的“变量”就有变量[1]、变量[2]和变量[3]这三个数组成员。如下图所示。



定义数组变量


2．多维数组变量的定义方法
在欲定义的“变量”的数组属性上输入：成员数，成员数，…。例如，要定义一个2维数组变量，每个维有3个成员，就在“变量”的数组属性上输入“3，3”如下图所示。

二维数组定义


这个2维数组，可以看作是3个拥有3个成员的单维数组组成，这个数组中各个成员，按成员顺序排列，表示方法如下：
变量[1][1]、变量[1][2]、变量[1][3]、变量[2][1]、变量[2][2]、变量[2][3]、变量[3][1]、变量[3][2]、变量[3][3]

在易语言中，多维数组成员也可以以单维数组的表示方法来访问，上边的多维数组有9个成员，按成员顺序排列也可以表示为：
变量[1]、变量[2]、变量[3]、变量[4]、变量[5]、变量[6]、变量[7]、变量[8]、变量[9]

数组变量也可以直接称之为数组，本书中以后如没有特别声明，所提到的数组都是指的数组变量。
3．数组变量的赋值
(1)直接赋值
数组变量的赋值，就是给数组中的成员赋值，每个成员都有独立的存储空间。数组中的每个成员都可以看作是单独的变量，可以使用给变量赋值的方法来给数组的成员赋值，例如，给一个有2个成员的整数型数组赋值，让每个成员都为100，程序代码为：
变量[1]＝100
变量[2]＝100
例如，给一个2维的整数数组赋值，每个维有2个成员，每个成员都赋值100：
变量[1][1]＝100
变量[1][2]＝100
变量[2][1]＝100
变量[2][2]＝100
(2)连续赋值
给数组变量赋值还有一个十分简便的方法，就是使用一对大括号将要赋予的值括起来，每个值都用“，”号隔开，被隔开的值赋予数组中的对应位置的成员，例如上面讲的给有2个成员的数组赋值，每个成员都赋值100，就可以使用下面的方法：
变量＝｛100,100｝
使用这种方法给数组成员很多的数组赋值，尤为方便，如给一个有10个成员的整数数组，就可以输入：
变量＝｛10,20,30,40,50,60,70,80,90,100｝
(3)命令赋值
可以使用“连续赋值（）”命令给数组赋值，“连续赋值（）”命令可将指定的常数、常数集、常量、资源、对象或者变量赋予到一系列变量或变量数组中去。参数<1>的名称为“用作赋予的值或资源”，参数<2>的名称为“被赋值的变量或变量数组”，命令参数表中最后一个参数可以被重复添加。具体也可以参考即时帮助，例程如：
局部变量：变量1  数据类型：整数型  数组：3
连续赋值 (100, 变量1 [1], 变量1 [2], 变量1 [3])
(4)直接用命令的返回值给数组赋值
有些命令的返回值就是一个数组，所以可以直接使用该返回值给数组赋值。赋值的时候首先要注意，根据命令返回数组的数据类型来给数组定义数据类型；还要注意数组的成员数是可变的，并且命令返回的数组成员数也不固定，所以可以定义接收返回值的数组成员数为0，当该数组接收了命令的返回值后，会自动定义成员数。例如：“分割文本（）”命令的返回值，就是一个文本型的数组，在程序中可以表示为：


代码运行后，如果运行目录是“d:\Program Files\e”，那分割后返回后子文本就是“d:”、“Program Files”、“e”，即文本数组就有了3个成员，每个成员的值就是返回来的子文本。
(5)命令参数是数组
有些命令或组件方法的参数是数组，此类命令或方法就需要根据帮助信息，来了解参数中的数组所代表的意义。例如画板的画多边型方法，第一个参数中的添入的数组顺序记录多边形各顶点的横向及纵向坐标值，坐标是成对出现，所以，数组中每2个成员就代表了要画出多边型的１个点，要让画板画出一个三角型就可以用以下代码：




6.2动态管理数组变量





数组变量的最大特点就是它的成员数也是可变的，这样就有非常大的灵活性，在程序运行中，可以动态的为数组添加成员、删除成员等等，这样就达到了对数组的动态管理。
动态管理数组主要通过命令来实现，易语言提供了10个专门针对数组操作的命令，如图所示。

命令解释参见下表所示。
数组操作命令

命令名
命令解释

重定义数组
可以重新定义指定数组的维数及各维的上限值。

取数组成员数
取指定数组变量的全部成员数目，如果该变量不为数组，返回-1，

取数组下标
返回指定数组维可用的最大下标（最小下标固定为1）

复制数组
将数组数据复制到指定的数组变量

加入成员
将数据加入到指定数组变量的尾部，自动增加其成员数目

插入成员
将数据插入到指定数组变量的指定位置，自动增加其成员数目

删除成员
删除指定数组变量中的成员，自动减少其成员数目

清除数组
删除指定数组变量中的所有成员，释放这些成员所占用的存储空间

数组排序
对指定数值数组变量内的所有数组成员进行快速排序

数组清零
将指定数值数组变量内的所有成员值全部设置为零


下面就结合实例来了解如何动态的管理数组。首先新建一个易程序，在窗口中添加2个编辑框组件和1个列表框组件，再添加5个按钮组件。
添加列表框组件是因为对数组的操作是不可见的，是在程序内部进行操作，这里将对数组的操作过程用列表框显示出来；2个编辑框一个用来填写向数组中添加的内容，另一个用来填写“插入成员”和“删除成员”的成员位置，2个编辑框的“输入方式”属性都设置成“整数文本输入”。5个按钮组件的标题用5个常用的组操作命令名来命名。
首先双击“加入成员”按钮，切换到程序编辑界面，然后新建一个程序集变量，变量名为“被操作数组”，数据类型为“整数型”，然后定义为0个成员的数组变量。如下图所示。

定义一个数组
1．“计次循环首（）”和“取数组成员数（）”命令
“计次循环首（）”命令经常和“取数组成员数（）”命令一起使用，用一个计次循环，就可以轻松的调用数组中的每一个成员。方法如下：首先用“取数组成员数（）”命令将数组中的成员数取出来，然后用此成员数限定“计次循环首（）”命令循环次数，每次循环，“循环次数变量”就会递增1，所以就可以用：
数组名[循环次数变量]
用这行代码就可以依次访问数组中的每个成员。在本例程中首先要考虑：要用一个列表框显示出数组中的每个成员，所以要将数组中的每个成员依次取出，并添加到列表框中，并且每次对数组操作后都要重新显示数组中的成员。新建一个子程序，这个子程序专门用来让列表框刷新显示数组内容的，这样可以节省很多代码。
在程序设计界面用Ctrl+N来新建一个子程序，将子程序名改为“刷新列表框”，然后在子程序中输入代码：


程序中的计次循环，第一次循环，“循环次数变量”是1，就将“被操作数组[1]”加入了列表框；第二次循环，“循环次数变量”是2，就将“被操作数组[2]”加入了列表框，依此类推，就将数组中所有的成员加入了列表框。由于被操作数组成员是整数型，所以要转换成文本型后再加入列表框。
2．“加入成员（）”命令
“加入成员（）”命令很简单，第一个参数填写欲加入成员的数组名，第二个参数填写欲加入的成员值。例程中是将编辑框1中的内容加入数组，所以用鼠标双击“加入成员”按钮后产生的“_按钮1_被单击”子程序中输入代码：


刷新列表框（）是用来调用刚才新建的“刷新列表框”子程序，子程序被调用后就会运行子程序中的代码。以后每次对数组操作后都将调用这个子程序，用来重新显示被操作后的数组成员情况。
3．“插入成员（）”命令
“插入成员（）”命令，其实就是可以在数组中的指定位置加入成员。命令的第二个参数填写欲插入成员的位置。例程中编辑框2用来填写插入成员的位置，双击“插入成员”按钮，在产生的子程序中输入代码：


4．“删除成员（）”命令
“删除成员（）”命令可以将数组中指定位置的成员删除，命令的第二个参数，用来填写欲删除的成员位置。例程中用编辑框2来填写欲删除的成员位置，双击“删除成员”按钮，在产生的子程序中输入代码：


5．“清除数组（）”和“数组清零（）”命令
“清除数组（）”命令用来删除指定数组中的所有成员；而“数组清零（）”命令是将数值型数组的所有成员都设置为0。这里要注意，“数组清零（）”命令只能对数值型数组进行操作。例程中只使用到了“清除数组（）”命令，双击“清除数组”按钮，在产生的子程序中输入代码：


6．“数组排序（）”命令
数组排序命令也只能对数值型数组进行操作，可以将一个数值型数组进行从大到小或从小到大的重新排列。双击例程中的“数组排序”按钮，在产生的子程序中输入代码：


还有“重定义数组（）”、“复制数组（）”、“取数组下标（）”命令，都是对数组操作非常方便的命令，这里就不详细介绍了。


6.3文本与数组操作实例
   
6.3.1 查找和替换文本
无论程序的大小，几乎都有查找和替换文本的工具。例如在Microsoft Office Word中，使用[Ctrl + F]组合键，可以弹出此功能的对话界面。下图所示：



其中“替换”子项中的功能更具代表性，所以下面编写的示例主要以此为范例，加以简单的解释。

首先，介绍下图中常用功能的使用方法。查找内容：在“查找内容”框内输入要查找的文字，单击“查找下一处”。替换文字：可自动替换文字，例如，将“你”替换为“您”。，字同意osoft Office Word

新建“Windows窗口程序”，程序界面设计如下图所示：



文本编辑框主要属性设置如下：
是否允许多行    真
        滚动条          纵向滚动条
        输入方式        只读方式
编写代码如下所示：


    第一步，添加程序集变量，如上。


    第二步，打开对话框，选择文本文件，并将文件的读写位置移动到文件的首部。如上。


    第三步，使用“子文本替换（）”命令，将“文本编辑框”中的指定文本用另一个文本替换掉，并重新把替换后的文本放到“文本编辑框”中。


第四步，查找指定的文本，并选中。


    第五步，使用“文本替换（）”命令，替换查找到的当前一个文本，然后把替换后的文本重新方到“文本编辑框”中，最后调用“_查找按钮_被单击（）”子程序查找下一个匹配的文本，并选中。


  如果编辑顺利，可按“F5键”运行。


6.3.2创建CSV文本文件
CSV是逗号分隔值文件的缩写，这是一种使用逗号来分隔各个元素的文本文件。例如，假设你具有一个由用户的单位、姓名和职位组成的CSV文件，那么这个文件的内容可能类似如下：
三川实业有限公司，刘小姐，销售代表

国皓，黄雅玲，市场经理

世邦，黎先生，采购员

先来看一段代码，然后介绍一个较为实用的示例。以下示例可将文本“文，”、“武，”“双，”、“全”写入名为“文本文件.csv”的文本文件中，代码如下：


不管在什么时候使用“打开文件（）”你都需要使用适当的到参数，这取决于你想要读取、写入或是追加一个文件。使用“打开文件（）”命令来创建一个名为“文本文件.csv”的新文本文件。（注意：如果没有指定路径，这个文本文件会创建在源代码所在的相同的文件夹中。也可以指定一个完整路径（例如D:\Documents and Settings\Administrator\桌面\文本文件.csv）。
从文本“文，”开始写入（注意：创建csv文件时我们必须手动写入逗号），“写出文本（）”命令会写入指定的第一个文本数据，并将当前读写位置置于当前位置，因此，下一次此命令添加“武，”文本时，恰好位于“文，”文本的右侧，后面的添加依此类推。最后得到的文本文件的内容如下：
文，武，双，全

注意逗号和下一个项目之间没有任何空格。一个项目结束时，另一个项目马上开始。来看另一个示例。
上面的代码虽然可以写出csv文件，但在实际操作中是不现实的，这样就需要重新编写代码。首先创建“Windows窗口程序”，在“启动窗口”上添加三个“编辑框”组件和一个“按钮”组件；在“_按钮_被单击”事件子程序中添加如下代码：


使用“写出文本（）”命令将检索返回的数据写到指定的文件中。
使用“检索”检索信息，其子程序代码如下：


如你所见，在子程序中的代码与前一个程序有了很大的差别，其中不再使用类似“文，”、“武，”、“双，”、“全”的固定编码值，而是使用类似于“单位”的参数和变量。同样可以写出相同格式的文本文件。
但要注意的是，当使用包含逗号的数据可到会遇到，如一个用户的职位为“销售代表”，而另一用户的职位为“市场助理，销售经理”这样，文本文件应该类似如下：
万海，林小姐，销售代表

嘉元实业，刘小姐，市场助理，销售经理

其第一行包含三段信息：万海/林小姐/销售代表；由于职位中包含逗号，第二行中却有四个段信息：嘉元实业/刘小姐/市场助理/销售经理。
处理这种嵌入逗号的方法是使用一个双引号包含每段信息；当文件被其它程序（Microsoft Office Access、Microsoft Office Excel以及Windows系统中的通讯簿）使用时，嵌入的逗号就会被忽略。文件类似如下所示，
"万海"，"林小姐"，"销售代表"

"嘉元实业"，"刘小姐"，"市场助理，销售经理"

为解决双引号的问题，必须在“检索”子程序中将双引号加进去，代码修改如下：




6.3.3读取CSV文本文件


前节创建的程序，可以将输入的客户信息直接转换到cov文件格式，并能使共其它默认程序正确的打开，虽然很方便，但毕竟不是自己编写的程序。那为了能在易语言中方便的读取和使用cov文件，下面就提供一此代码来实现这个功能。的户Vs
创建“Windows窗口程序”，界面如下图所示：



示例程序界面

“超级列表框”组件的主要属性设置如下：
    类型        报表列表框
    整行选择    真
双击“按钮”组件，在其事件子程序中添加代码如下：


    以上是在编写程序中所声明的变量。


上面代码的功能是，打开上节中创建的cov文件。
下面代码实现读取文本文件中的各行文本，并分析和去除各段数据的多余文本。其中还是使用了一些硬性代码，所以对其它方面的支持要差强一点，但这是为了更容易的理解这段代码。这里就不多做解释了。

• 评论(已有0条)
• 查看全文

第十课.子程序2009-12-09 14:49

分享

搭积木时把一个个不同形状，不同大小的木块作不同的组合，可以搭出各种各样的模型来。把一个个具有特定功能的程序段作为若干个独立块，再把它们作不同的组合，也可以构成一个完整的程序，这种方法称作模块化结构程序设计方法。
当一个具有特定功能的程序段在一个程序中多次被使用到时，如果在每次使用它的地方都写一遍，不仅写起来麻烦，输入机器时也费时间，还容易增加出错机会。而且这种程序较长，占用内存空间大，读起来也讨厌。可以设想，如果能只把它们写入一次，需要使用它们时就调用它们一次，那不就简单了吗？
其实子程序就是用来对一系列命令进行封装，实现模块化、重用及抽象，从而有利于程序的结构化开发，使程序结构更清晰。合理划分代码结构是软件成功的基本保障。


5.1子程序的分类



易语言中的子程序可以分为两大类：“事件子程序”和“用户自定义子程序”。
对应组件所发生事件的子程序，称作组件的“事件子程序”。例如：按钮有被单击、被双击、左键被按下等事件，选中按钮后，在属性面板中的事件列表中选择这些事件，就可以生成对应的事件子程序，大家可以在这些事件子程序中写入具体执行的代码。运行时，一 旦这些事件产生，就会自动执行相应的子程序。事件子程序的名称、返回值类型和参数个数都是系统定义的，不允许用户任意修改。
“用户自定义子程序”是由用户创建，其参数个数和返回值都由用户自行定义的子程序。用户可以根据需要在程序设计时对其任意修改。
使用子程序的好处很多，例如有段代码在程序中多处被重复调用，此时就可以将其编写到一个子程序中，不仅减少了代码输入的重复劳动，而且需要修改这段代码时，只要修改一个地方即可，而不用在程序中逐个修改，即实现重用；再例如要实现一个相对复杂的功能，如果全部代码写在一起，发现错误就无法确认问题来源，此时可将问题分解为多个简单问题，使用子程序逐个实现，这样有利于提高代码的正确性和清晰度。


5.2用户自定义子程序的创建



子程序是存在于程序集中的，由程序集分组管理。若一个新建的易程序还没有进行任何操作是没有程序集的，这时可以使用菜单：“插入”→“程序集”来新建一个程序集放置自己所写的用户自定义子程序；或通过在窗体空白处双击鼠标，会自动创建该窗口对应的窗口程序集，并自动生成“_启动窗口_创建完毕”子程序（创建完毕事件子程序可包含本窗口创建时被执行的程序代码）；或双击按钮等组件，也会创建该窗口对应的窗口程序集及组件对应缺省事件子程序。此时就可以在当前窗口程序集中添加新的子程序了。如下图所示。



创建窗口程序集


用户自定义子程序可以放在窗口程序集中，或自定义的程序集中，当然，建议您将当前窗口用到的用户自定义子程序放在当前窗口程序集中，这样就可以非常方便地引用程序集变量和窗口中的组件，而且查找起来也较为方便。
2．若程序集已建立，可通过程序面板切换到程序集中操作，或通过窗口菜单切换。
定义一个新的子程序可以通过在程序编辑界面按下“Ctrl+N”键；或在程序编辑界面点击鼠标右键，在弹出菜单中选择第一项“新子程序”；或者选择易语言菜单“插入”→“新子程序”来新建子程序。
创建后的子程序可以根据需要修改其名称，建议在定义子程序名称时，尽量选择能体现其功能的名称，如“求和”、“统计字符”等。


5.3 子程序的调用

子程序的调用方法和命令的调用方法相同，输入子程序的名称就可以调用该子程序。如果子程序要求提供参数，在括号中要按照子程序参数定义的数据类型和参数个数顺序填写参数；如果需要用变量保存子程序返回值，必须使用和子程序返回值相同的数据类型变量。


5.4返回值和参数的定义



使用“返回（）”命令，可以将子程序处理后的结果返回给调用它的程序使用。
为子程序定义返回值，需要在子程序的“返回值类型”单元格中定义其返回值的数据类型，同时，在子程序任意一个结束分支中，都必须使用“返回（）”命令将欲返回的值回传。
为子程序增加参数定义，首先在子程序名称上按回车键增加一个空白参数定义，修改该参数的名称和数据类型即可。参数的“类型”如果为空，系统默认为整数型参数。如果某项参数的“可空”类型未被设置，在调用该子程序时就必须为此参数提供初始值。
子程序的参数在当前子程序内可以当作变量引用。例如：

上述子程序定义中，子程序名为“相加运算”，返回值类型为“整数型”，子程序有2个整数型参数，分别为“加数1”和“加数2”。

该子程序可以对参数做相加运算，并将运算结果回传。调用该子程序的方法如下：



5.5 子程序嵌套




与循环嵌套类似，子程序中再调用另一个子程序，叫子程序嵌套。而调用子程序本身，则被称作递归调用。


5.6子程序指针

易语言中部分命令必须以子程序在内存中的起始地址作为参数，如“启动线程（）”命令；使用某些外部API函数时，也同样需要知道调用的子程序在内存中的起始地址。在易语言中，以子程序指针型变量记录子程序在内存中的起始地址。赋值方法为“&”+子程序名。如：
变量1＝＆子程序1
启动线程 (变量1, )
赋值之后，“变量1”（类型为“子程序指针型”）存储的就是“子程序1”的可执行代码首地址。


5.7 子程序参数的“参考”属性           



子程序参数的“参考”属性用于设置系统为当前子程序参数传递数据时是否为传递指向数据的指针。如果所传递过来的参数数据为数组、用户定义数据类型、库定义数据类型、文本型、字节集型数据，则无论此属性是否为“真”（选中），都将传递指针。如果所传递过来数据的类型与相应位置处参数的数据类型不一致但可以相互转换。例如将“整数型”数据传递到“小数型”的参数中，则在数据被实际传递前，系统将首先自动将“整数型”数据转换为“小数型”数据，然后再进行传递。因此在这种情况下，即使本属性为“真”，系统也无 法传递指向原数据的指针，只能传递数据本身。如果系统将数据指针成功地传递过来，那么在子程序中对此参数内容的更改将会相应地反映到调用子程序时所提供的参数数据上。
给子程序参数定义“参考”属性，只要将属性相应位置打上“√”即可。
下面通过一个例程来观察“参考”属性的作用。
新建一个“Windows窗口程序”，然后在“_启动窗口”中添加一个画板组件和一个按钮组件。
双击按钮组件，在代码编辑界面新建一个子程序，定义子程序名为“测试”，为该子程序定义2个参数，均为整数型；参数名分别设为“参考参数”和“非参考参数”，将“参考参数”的“参考”属性上打上“√”：

在“_按钮1_被单击”子程序中输入代码：

运行程序，观察运行结果。如下图所示。

“参考”属性对变量的影响比较
上述程序中，每次点击按钮，就会调用“测试”子程序对2个参数进行修改。从画板的显示结果可以看出，对应“参考参数”的变量1，因子程序内部对相应参数的操作而被修改，而对应“非参考参数”的变量2没有发生任何变化。


5.8 子程序参数的“可空”属性



易语言自带的支持库命令中有一些参数可以被省略，一般查找帮助时可以看到可省略的部分用中括号括起来了。如“时间到文本（）”命令的第二个参数是可以省略的，它也可有一个默认的数据，此命令帮助如下：
调用格式： 〈文本型〉 时间到文本 （欲转换到文本的时间，［转换部分］）

将指定时间转换为文本并返回。

参数<1>的名称为“欲转换到文本的时间”，类型为“日期时间型（date）”。

参数<2>的名称为“转换部分”，类型为“整数型（int）”，可以被省略。参数值可以为以下常量： 1、#全部转换； 2、#日期部分； 3、#时间部分。如果省略了本参数，默认为“#全部转换”。

用户自定义子程序也可以实现这样的功能。
在设计子程序的时候，有些参数可能经常用到相同的数据。如果每次调用该子程序，均需手工指定此数据作为参数初始值，那是一件非常繁琐的事情。在这种情况下，可以将此数据作为该参数的默认值，内置在子程序中，并将参数属性设为“可空”类型。当子程序被调用时，该参数没有指定具体的初始值，就为该参数赋予默认值参与运算。如果某项参数的“可空”类型未被设置，在调用该子程序时就必须为此参数提供数据。
定义“可空”属性的方法和定义“参考”属性相同，将该属性打上“√”即可。如果需要检测当前子程序被调用时，该参数是否传递了数据，可用“是否为空（）”命令进行确认。
下面编写一个可以进行加法或减法运算的子程序，来了解“可空”属性的实际应用。
本例程将加减运算的功能制作成一个子程序，通过第三个参数确定是作加法计算还是减法计算，如果第三个参数为空进行加法运算，不为空则进行减法运算。
第一步，新建一个易程序，在窗口中添加3个编辑框组件，2个按钮组件和1个标签组件，将按钮组件的标题分别改为“加法运算”和“减法运算”，标签组件的标题改为“=”。如下图所示。

加减法运算例程界面


第二步，切换到代码编辑界面，新建一个子程序，将子程序名改为“加减运算”。给该子程序定义3个整数型参数，参数名分别为“被运算数”、“运算数”和“进行的运算”，将“进行的运算”参数的“可空”属性被设置，在子程序中输入如下程序代码：

子程序中，“进行的运算”参数控制子程序进行何种运算，该参数为空进行加法运算，该参数不为空则进行减法运算。
第三步，回到“_启动窗口”双击“减法运算”按钮，然后在“_按钮1_被单击”和“_按钮2_被单击”子程序中分别输入代码：

可以看到，在“_按钮1_被单击”子程序中，省略了“加减运算”子程序第3个参数的填写。
最后，运行程序，查看运行后的效果。如下图所示。

加减法运算例程的运行效果


程序运行时点击左边按钮，程序运行的“加减运算”子程序第三个参数没有填参数，因此进行的是加法计算。点击右边按钮，程序运行的“加减运算”子程序第三个参数设置参数为1，因此进行的是减法计算。本例程可以参考随书光盘中的例程“加减运算.e”。


5.9 子程序参数的“数组”属性



子程序参数也可以接收数组，如系统的“播放MP3 (, )”命令的第二个参数就可以接收数组。而用户自定义子程序也可以实现这个功能，接收一个数组，在子程序内部进行处理。
子程序参数定义了“数组”属性后，就可以给这个参数中填写一个数组变量。
子程序的参数如果是“数组”型变量，就自动具有了“参考”属性。
定义参数的“数组”属性，在该参数的数组属性上打“√”。
下面就编写一个例程，来了解数组参数的作用。
第一步，新建一个易程序，在窗口中添加一个画板和一个按钮组件。
第二步，双击按钮组件，在程序设计界面新增一个子程序，然后将子程序名改为“测试数组属性”，给该子程序定义一个参数，将参数的名称改为“数组”，并将参数的数组属性选中：

第三步，在按钮1被单击的子程序中输入代码：




运行后，画板显示出调用子程序前后数组变量中各成员的值，在调用子程序后，可以看出数组参数自动具有了参考属性，数组变量中成员的值发生了改变。

• 评论(已有0条)
• 查看全文

第九课.程序的循环和跳转2009-12-09 14:48

分享

本章将介绍循环程序设计的概念。循环语句是专用于这类程序设计的，由于它有着固定的格式和执行方法，使用起来十分方便。


4.1 循环类流控制命令



循环类流程控制命令可以在一定条件下多次执行重复的代码。例如，将某数据库中前100条记录的“姓名”字段内容读出并显示在表格中，使用循环命令只需要几行代码即可实现。
循环流程类命令都由循环首和循环尾2部分组成，输入了循环首命令，循环尾就自动出现。循环首表示循环的开始，循环尾表示循环的结束，循环首和循环尾之间的代码，是循环执行的代码。
1．“判断循环首（）”和“循环判断首（）”命令
“判断循环首（）”命令首先检查判断条件是否成立。如果不成立，直接跳到循环尾后的代码继续执行；如果条件成立，则进入循环。每次循环结束后，会再一次检查“判断循环首”中的条件，如果条件不成立了，就退出循环，执行后续代码。





例如：让画板滚动写出100以内的偶数，“Windows窗口程序”代码如下：

“循环判断首（）”命令是先循环再判断，即首先运行一次循环首和循环尾之间的代码，再判断条件是否成立。如果“循环判断尾（）”中的条件为真，就跳到循环首处继续循环，如果条件不成立，则循环终止。将上面的代码中的“判断循环首”直接转换为“循环判断首”，运行结果是相同的。可以看出，这两个命令在一定情况下是可以互换的，但由于两个命令的判断位置不同，有可能对循环体内的运行结果造成影响，在实际应用中要注意区分。

下面编写用列表框组件列出C盘根目录下所有文件的程序。
首先，新建一个“Windows窗口程序”，然后添加1个列表框组件和1个按钮组件。
双击按钮组件，在“_按钮1_被单击”子程序中输入代码：

这里用到了“寻找文件（）”命令，当使用“寻找文件（）”命令在指定目录连续检索相同条件的文件（非子目录）时，第二次调用无需填写参数，该命令会自动继续向下寻找。
运行程序，程序会将C盘根目录中所有的文件，包括被隐藏文件和系统文件都显示在列表框中。

可尝试将“判断循环首（）”命令转换成“循环判断首（）”命令，看运行结果是否有所不同。


2．“计次循环首（）”命令
“计次循环首（）”命令可以指定循环的次数。命令的第二个参数可以填入一个变量，用来记录已循环次数，第一次循环时变量值为1，第二次循环时变量值为2，依此类推。

下面编写一个将1到指定范围内的所有整数相加的程序。
创建“Windows窗口程序”，在“_启动窗口”中添加一个编辑框组件和一个按钮组件。
然后将编辑框的“输入方式”属性设置为“整数文本输入”，双击按钮，在“_按钮1_被单击”的子程序中输入代码：

最后，试运行程序，在编辑框中输入一个大于1的整数，然后点击按钮，可以求出1到编辑框中的数值范围以内所有整数的和。但要注意的是，如果输入的数过大，就会导致循环的时间过长，程序暂时失去响应；如果输入的数值范围太大，可能会出现数据溢出情况。
3．“变量循环首（）”命令
该命令用做一个变量的内部循环，有四个参数，规定了变量的起始值，目标值和递增值，每次循环，变量的起始值都会增加规定的递增值，直到达到目标值，退出循环。第四个参数记录当前起始值，类似“计次循环首（）”命令的记录循环次数的变量。


例如，可以求出100到200之间的整数和，用以下代码：

循环结束后的“相加变量”就是求得的结果。最后将结果显示在编辑框中。


4.2循环的套用



循环流程命令可以嵌套使用。
在循环体内再次使用循环语句，构成了循环语句的嵌套使用。大循环内套一个小循环，小循环内还可以再套一个循环。一个套一个，所套的次数，叫做循环嵌套深度。
多重循环在解决应用问题中，是非常有用的。
例如，下面就用易语言做一个简单的程序：
打印乘法表的1×1=1，1×2=2，1×3=3，…，1×9=9
可以使用“计次循环首（）”命令。新建“Windows控制台程序”。程序代码如下：

这个程序在输出格式上作了一些考虑。在每输出一次运算结果（内层循环中的输出语句）的后面加上两个空格，以便使下次输出能与之保留距离。在外层循环中的输出语句是使以后的输出能另起一行。这样就可以显示出格式正确的九九表。

双重循环语句的执行过程中，程序总是先遇到最外层那个循环。这时你就可以把内层循环当作一个语句来看待。最外层循环执行过程中，是将其内部的每条语句顺序执行的，而遇到内层循环时，我们既把它当作一个语句，也一样要执行这个语句。然而它毕竟是一个循环语句，所谓执行它，还是按一般循环语句的执行方法。因此，就事论事刚刚列出的显示九九表的程序而言，每对“乘数”循环一次，就要对“被乘数”完整的循环当前“乘数”变量中的次数。

三重循环、四重循环等，执行过程依此类推。



4.3跳转类流程控制命令



有了跳转类流程控制命令，可以更加方便的控制循环，“返回（）”和“结束（）”命令可以控制子程序和整个程序的结束。
1．“到循环尾（）”和“跳出循环（）”命令
这两个跳转类流程控制命令都是用来控制循环的。当一个循环中运行了到“到循环尾（）”命令，将会直接跳到循环尾的代码处，当一个循环中运行了“跳出循环（）”命令，那么当前的循环就会结束，然后继续运行循环体以后的代码。例如：
（1）让一个编辑框中只显示10以内的奇数“1，3，5，7，9”，代码如下：

当循环变量等于不想显示出的值，就会执行“到循环尾（）”命令，跳过显示到编辑框的代码。
（2）如果在循环过程中，当某个条件产生，想提前结束该循环，可以使用“跳出循环（）”命令，如：

当循环变量等于8，就运行“跳出循环（）”命令，循环即会结束，所以编辑框会显示“1234567”。
2．“返回（）”命令
“返回（）”命令被执行后，会退出当前子程序。当前子程序中“返回（）”命令之后的代码将不再被执行，程序将自动跳转到调用本子程序语句的下一条语句处继续执行。

由于“返回（）”命令后面的代码不被运行，所以“返回（）”命令也经常被用于程序的侦错，在后面的章节会有介绍。有返回值的子程序必须使用“返回（）”命令来返回执行结果，要注意实际返回值的数据类型要和子程序定义的返回值数据类型相匹配。例如返回日期时间型的数据：
返回（[2004年11月15日]）
在循环中使用“返回（）”命令，也可以终止一个循环的运行。例如：


当变量1等于10的时候，就运行“返回（）”命令，当前循环和当前子程序都会被终止。
3．“结束（）”命令
“结束（）”命令是结束当前易程序的运行。不论当前易程序有多少个已载入窗口，都会被自动关闭。可以用于程序的关闭按钮。“结束（）”命令没有返回值也没有参数。若仅想关闭当前的某一个窗口，应使用“窗口”的“销毁（）”方法。
例如，在按下“关闭按钮”后，就将结束程序：

      注：建议尽量在程序中使用销毁所有已载入窗口的方法来结束程序。

• 评论(已有0条)
• 查看全文

第八课.程序流控制命令2009-12-09 14:47

分享

“如果（）”命令



“如果（）”命令的参数为一个逻辑型数据，非真即假。若条件为真，则程序顺序执行后续代码；若条件为假，则程序跳转到左箭头所示的代码行继续运行。




新建一个“Windows窗口程序”，在“_启动窗口”中添加1个编辑框组件和一个按钮组件。然后双击按钮，在“_按钮1_被单击”子程序中输入代码：

运行程序。此时编辑框中没有任何内容，单击按钮，可以看到编辑框显示“Windows窗口程序”；再单击按钮，此时编辑框中已有内容，则编辑框显示“”。
其实上面代码中的：
如果（编辑框.内容=“”）
解释为，编辑框中的内容是空文本（条件语句的值为真），程序可以向下顺序执行。
可以看出，条件语句的值只能是逻辑型的“真”或“假”。
“如果（）”命令参数中还可以填写多个条件，用“或”和“且”连接，例如：

用“或”连接多个条件时，只要有一个条件成立时，整个条件参数就为真。上述代码中，当“比较值”等于100、50或25时，“比较值”被改为0，否则就等于它自身的五倍。

用“且”连接的多个条件，必须所有条件都成立时，整个条件参数才为真。上述代码中，只有当“比较值”等于100，并且“比较值”等于50时，“比较值”被改为0，否则“比较值”会加1。


3.2“如果真（）”命令



“如果真（）”命令从流程线上就可以看出与“如果（）”命令的不同，“如果真（）”命令在条件成立的时候运行“如果真（）”命令下的代码，否则“如果真（）”命令没有任何动作。





例如：

当“比较值”大于100，则会运行“比较值=0”的代码，否则直接跳到判断结束后的代码继续运行。


3.3“判断（）”命令



本命令根据提供的逻辑参数的值，来决定是否改变程序的执行位置，如果提供的逻辑参数值为“真”，程序将跳过同组后面的“判断”语句继续顺序向下执行，否则跳转到下一分支处去继续判断。
“判断（）”命令主要用于条件的分支选择，如下面2段代码运行效果相同，程序结构也相同，但使用“判断（）”命令，代码流程结构要清晰许多，而使用“如果（）”命令，不仅会使程序嵌套太多，程序代码难以看清楚，也降低了程序运行效率。

• 评论(已有0条)
• 查看全文

第七课.运算符和表达式2009-12-09 14:46

分享

管理提醒： 本帖被 小豪 执行提前操作(2009-11-02)
将数据类型相同的常量、变量和函数用规定的运算符连接起来，就构成了表达式。表达式本身有一个值。
编写代码时，除了大量的使用命令或对组件的属性或方法进行操作，运算符的使用也非常重要。程序中所有涉及到的算术运算或关系比较运算等操作，都需要使用运算符。
易语言中提供了大量的运算符。例如赋值时使用的“=”号，就是赋值运算符，比较大小时使用的“>”和“<”号，是关系运算符等等。如表2-2所示。
易语言运算符

运算符分类
运算符
运算符含义
代码中显示

算术运算符号
＋
加法运算，将加号两边的数相加
＋

－
减法运算，将减号两边的数相减；负号
－

＊
乘法运算，将乘号两边的数相乘
×

／
除法运算，将除号两边的数相除
÷

\
整除运算，将整除号两边的数整除
＼

%
求余数运算
％

关系运算符
>
判断是否大于
＞

<
判断是否小于
＜

= 或 ==
判断是否等于
＝

>=
判断是否大于等于
≥

<=
判断是否小于等于
≤

<> 或 !=
判断是否不等于
≠

=
判断是否约等于
≈

逻辑运算符
&& 或QIE
逻辑与运算符，可以连接几个必须同时满足的条件
且

｜｜或HUO
逻辑或运算符，可以连接几个可选条件
或

赋值运算符
＝
将等号后面的值赋值给等号前面的对象
＝




程序中的运算符都有其优先级别，在程序运行的时候会按照符号的优先级别，从高到低依次运行。运算符的优先级别参见下表。
易语言常用运算符的优先级

运算符
优先级

()(小括号)
最高

*(乘)    /(除)     


\(整除)

%(求余数)

+(加)    -(减)

<(小于)  <=(小于等于)  >(大于)  >=(大于等于)

==(等于)    !=(不等于)    ?=(约等于)

&&(逻辑与)

||(逻辑或)

=(赋值)


在这里我们已看出：算术表达式中算术运算符号的优先顺序，和在数学上是完全一样的：
（1）如果有括号，必须先做括号内的。在程序中，没有大、中、小括号之分，一律使用应括号（），括号内可以套用括号，但不得超过36层。这就同数学上一样，先做最内层括号中的计算，层层向外脱，最后处理最外层括号中的计算。
（2）无论括号内或括号外，函数计算优先于其它算术运算符。
（3）乘、除运算优先于加、减运算。乘或除同时出现在一个表达式中时，先完成左边的后完成右边的(即以先后出现顺序为序)。
（4）最后做加、减运算。加、减号同时出现在一个表达式中时，也以先后出现的顺序为序。
对于初学者来说，下列几点要格外注意：
1.在数学上，代表两个数的字母相乘时，可以连写。如A代表一个数，B代表一个数，则可用AB代表两个数相乘。在表达式中，这是绝对不允许的(这时它会把AB当作变量名)。必须写成A*B。用A.B也是不允许的。
2./号代表除号。
3.左右括号必须成对出现。且不得用方括号[ ]或花括号{}代替。


2.8.1算术运算符和算术表达式



1．算术运算符
在程序中表示为：
＋，加法运算。如：3+2
—，减法运算或负值运算。如：10-2、-10
×，乘法运算。如：2×3
／，除法运算。如：20/12
＼，整除运算。如：12＼5，运算后会将保留一个整数，小数部分将被舍去
％，余数运算。还可以输入“求余数”，第一个参数填被除数，第二个参数填除数，第二个参数可以重复添加。如：1220%100、1220%100%120
2．算术表达式
用算术符号和括号将运算对象连接起来的，符合易语言语法规则的式子，称易语言算术表达式。例如，下面是一个合法的易语言算术表达式：
变量＝((6 × 12 ＋ 16 ÷ 8) － 23) ＼ 10
表达式中运算的先后，是按照运算符的优先级别来进行判定的。
算式计算的结果可以被程序调用。


2.8.2赋值运算符和赋值表达式



1．“=”是赋值运算符，在程序中给变量赋值或用代码改变组件属性，大部分都是使用“=”进行赋值的，将等号后面的值赋值给等号前面的赋值对象。
2．赋值表达式
一个正确的赋值表达式，一定要保证欲赋的值和被赋值的对象之间的数据类型相同，不同的数据类型要转换成相同的数据类型后再赋值。
3．赋值运算符“＝”和关系运算符“＝”的区别。虽然2个运算符使用的是相同的符号，但含义却不同，赋值运算符“＝”是用于赋值，将“=”右边的值（或变量）赋值给“=”左边的变量（或组件属性、数组成员、自定义数据类型成员）；关系运算符“＝”，是比较符号两边的值是否相等，如果相等返回真，不相等返回假。





上述代码中，条件语句“如果（）”中的“被比较值＝比较值”，是用关系运算符“＝”进行比较，如果相等会返回“真”，不相等会返回“假”，如果返回“真”将会执行：标签１.标题=“相等”；如果返回“假”将会执行：标签１.标题＝“不相等”，这2行给标签标题属性赋值的代码中，使用的就是赋值运算符“＝”。
2.8.3文本运算符与文本表达式

字符串在易语言中被称为文本，其运算符只有一个：
+            连接运算符
其功能是将两个文本连接起来。
例如：
“ABCD”+“123”
将得到一个新的文本，其值为“ABCD123”。
可见，可用字符串运算符连接两个字符串，构成字符串表达式。

• 评论(已有0条)
• 查看全文

第五课.易语言的数据类型2009-12-09 14:45

分享

2.5.1 了解数据类型




易语言中基本数据类型有６种，包括数值型、逻辑型、日期时间型、文本型、字节集型、子程序指针型。
字节型。可容纳 0 到 255 之间的数值。

数值型中整数型数据，如：13556。
逻辑型数据，只能有２种值，即“真”或“假”。
日期时间型数据，用来记录日期及时间，如：［2002-2-2］。
文本型数据，可用来记录一段文本，如：“中文编程易语言”。在程序中表示一段文本数据，都要用双引号将文本引起来。
　　字节集型数据，用作记录一段字节型数据，表示为{23456754}。图片或mp3格式的文件是典型的字节集型数据，在程序中，存放此类数据的变量一定要定义为字节集型。
子程序指针型数据，是一个子程序在内存中的地址。


2.5.2 给变量正确赋值



定义了变量的数据类型后，要给变量赋值就应注意赋值的类型要和变量类型相同。例如：
文本变量＝“中文编程易语言”　‘ 给文本变量赋值
整数变量＝32342　　          ‘ 给整数变量赋值
日期时间变量＝[1982年1月1日]  ‘ 给日期时间型的变量赋值
字节集变量＝＃图片　          ‘ 给字节集变量赋值,图片1图片资源表中的资源
这里要注意，给“子程序指针”类型的变量赋值，表示为“&”＋要指向的子程序名。例如：
变量＝&子程序1


2.5.3 数据的比较



在编程中，经常会在各种数据间进行比较。同种数据类型之间进行比较，可以直接进行；而不同种数据之间进行比较，就要先进行数据类型的转换，将不同种的数据类型转换为同一种数据类型后才能进行比较，否则程序会报错。
例如：编辑框中输入了一个整数，要比较编辑框中的内容是否大于50。由于编辑框中的内容是一个文本，首先要将编辑框中的内容转换成整数型数据后，再进行比较，输入以下代码：
到数值（编辑框１．内容）＞５０
比较后，会返回一个逻辑值，如果大于50就会返回真，小于或等于50将返回假。
易语言中常用的数据类型间转换的命令有：
“到数值（）”命令，用来将一个通用型数据转换到整数型。
“到文本（）”命令，用来将一个通用型数据转换到文本型。
“到字节集（）”命令，用来将一个通用型数据转换到字节集型。
“从字节集转换（）”命令，用来将一个字节集型的数据转换成通用型数据，命令的第2个参数控制欲转换成的数据类型。
“到时间（）”命令，用来将一个文本型的数据转换成日期时间型。
使用这些数据类型间互相转换的命令，就可以进行不同数据类型间的比较了。
例如：比较2个编辑框中数的大小，用信息框显示出比较的结果，并用第3个编辑框显示出较大数减较小数的结果。在窗口中添加3个编辑框组件和一个按钮组件，双击按钮组件，然后输入代码：


变量之间的比较也是一样，一定要注意变量的数据类型，不同数据类型的变量一定要转换成相同类型后再进行比较。


2.5.4 数据类型的存储字节与溢出



1．数据类型的存储字节

各种数值型的数据都在内存中占用一定的存储空间。字节(byte)是系统中的基本存储单位。数据类型所占字节数越多，所能够容纳数值的范围就越大。参见表2-1。


表2-1  常用数据类型
数据类型名称
占用字节数
取值范围

字节型
1
0 到 255

短整数型
2
-32,768 到 32,767

整数型
4
-2,147,483,648 到 2,147,483,647

长整数型
8
-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807

小数型
4
-3.4E38 到 3.4E38 (7位小数)

双精度小数型
8
-1.7E308 到 1.7E308 (15位小数)

逻辑型
2
“真”或“假”，

日期时间型
8
100年1月1日到9999年12月31日

子程序指针
4
尺寸为 4 个字节。具有此数据类型的变量可以用来间接调用子程序。

文本型
 

由以字节 0 结束的一系列字符组成

字节集
 

一段字节型数据



从上表可以看出，数值型数据容纳的数值范围越大，占用的字节就越多。比如，短整数型的数值3000和整数型的数值3000，都代表了数值3000，但在系统中占用的空间却不同，即短整数型占2个字节，整数型占4个字节。所以，在实际应用时就要根据自己的需要来选择使用的数据类型，避免存储空间的浪费。例如，存储的数据在-32768至32767以内，就要采用短整数型；如果使用小数而对精度不高，就可以使用小数型而不用采用双精度小数型等等。
2．数据的溢出

某数据类型存储的值超出了其所能容纳的范围，就会发生数据溢出错误。比如，让短整数型数据存放大于32767的数值，将会得到错误的结果。所以在选择数据类型时，除了要避免空间的浪费，又要防止数据的溢出。
可以做一个简单例程来测试一下数据的溢出，新建一个“Windows控制台程序”，然后在“_启动子程序”中首先按下Ctrl+L键，新建一个变量，并定义变量名为“整数变量”，变量类型为整数型，然后输入代码：

最后按“F5键”试运行程序，输入一个很大的数（比如：10000000000），然后按“回车键”，如果超出整数型变量容纳范围而产生溢出，会显示出错误的结果。



2.5.5自定义数据类型



除了使用易语言提供的数据类型以外，还可以根据需要自定义新的数据类型。例如要定义一个数据类型“矩形”，定义方法如下：
第一步，新建一个“Windows窗口程序”，双击程序面板中的“自定义数据类型”。

第二步，在自定义数据类型界面按下Ctrl+N键，新建一个数据类型。然后将数据类型名定义为“矩形”，由于决定一个矩形的位置取决于矩形左上点的横纵坐标和矩形右下点的横纵坐标。所以，在“成员名”上按4次回车，加入4个成员。将4个成员名分别定义为“左上横坐标”、“左上纵坐标”、“右下横坐标”、“右下纵坐标”。

最后，就要来使用这个自定义的数据类型了。画板有一个方法是“画矩形（）”，下面就用自定义的数据类型“矩形”来为画矩形方法填写参数。在窗口中添加一个画板组件和一个按钮组件，双击按钮组件，在“_按钮1_被单击”子程序中新建一个变量，变量名为“矩形”，然后定义变量的数据类型为“矩形”，然后输入代码：

代码输入后试运行程序，点击按钮，画板会以画板的边框大小画一个矩形。


2.6常量

常量，其值在使用过程中不会发生变化的变量，称为常量。比如数字15，不管程序如何变化，它永远是数字15。
核心支持库中已经定义了大量常量，其它支持库通常也会定义一些常量，用户也可以在程序中定义自己的常量。
各种图片或声音等资源都被看作常量，要想在程序中随时调用，可以将其存放在资源表中，这样在编程时不但可以随时调用，而且资源表中的资源会和程序一起编译到可执行文件里面。


2.6.1 了解常量

常量是一个固定的量，其值不可以被改变。易语言中规定了一些常量，这些常量都有固定的值，例如易语言中的“#蓝色”代表了数值16711680、“#F键”代表了数值70，所以在程序中使用“#蓝色”其实是调用了“16711680”这个颜色值。
核心支持库定义了许多常量，这些常量可以直接用#常量名即可调用，有数值型常量，如颜色值：#蓝色、#绿色；有文本型的常量，如：# 引号等等。扩展支持库也有许多常量的定义，并且新增加的支持库中，有的也会增加新的常量。


2.6.2 ASCII码



ASCII码是各种计算机通用的一种常量。例如字符a的ASCII码是97、字符b的ASCII码是98等等，参见下表所示。可以使用易语言中的“字符（）”和“取代码（）”命令，在ASCII码和字符之间进行转换。例如：
信息框 (取代码 (“a”, 1), 0, )
信息框会显示“a”的ASCII码。


常用ASCII码表

ASC值 对应字符 ASC值 对应字符 ASC值 对应字符 ASC值 对应字符
032 （space） 056 8 080 P 104 h
033 ! 057 9 081 Q 105 i
034 " 058 : 082 R 106 j
035 # 059 ; 083 S 107 k
036 $060 <
084 T 108 L
037 % 061 = 085 U 109 M
038 & 062 >
086 V 110 N
039 ' 063 ? 087 W 111 O
040 ( 064 @ 088 X 112 P
041 ) 065 A 089 Y 113 Q
042 * 066 B 090 Z 114 R
043 + 067 C 091 [ 115 S
044 , 068 D 092 \ 116 T
045 - 069 E 093 ] 117 U
046 . 070 F 094 ^ 118 V
047 / 071 G 095 _ 119 W
048 0 072 H 096 ` 120 X
049 1 073 I 097 a 121 Y
050 2 074 J 098 b 122 Z
051 3 075 K 099 c 123 {
052 4 076 L 100 d 124 |
053 5 077 M 101 e 125 }
054 6 078 N 102 f 126 ~
055 7 079 O 103 g 127 □



2.6.3 常量的使用

下面就介绍常量的使用方法：
（1）颜色值常量的使用
有颜色属性的组件，在颜色属性上都有一个颜色选择器，用来直接改变颜色，颜色选择器上可直接选择颜色的颜色值都作为常量提供，在调用的时候直接输入“#颜色名”即可，如：
标签1．背景颜色＝＃天蓝
（2）“＃换行符”的使用
一段文本尾部加入了一个“#换行符”，接在换行符后面的文本将另起一行，相当于在记事本中输入的回车键。如果想让编辑框显示一段文本并自动换行，就需要使用换行符，将“＃换行符”加到欲换行文本的前面即可，如：
编辑框1.是否允许多行 ＝ 真
编辑框1．内容＝“易语言”＋＃换行符＋“编程可视化”
（3）“#引号”、“#左引号”、“#右引号”
为了不和代码中表示文本数据的引号相冲突，程序中将文本的引号作为了一个文本常量，如果要让编辑框显示出一个引号，就要使用“#引号”常量，要显示中国标点中的引号，就要使用常量“#左引号”、“#右引号”。例如：让编辑框显示出：“我爱易语言，我爱编程！”，需要输入以下代码：
编辑框1．内容＝＃左引号＋“我爱易语言，我爱编程！”＋＃右引号
（4）键代码的使用
易语言中，将标准的101键盘上所有键的键代码都作为了核心支持库定义的常量，在程序中使用只需要输入“#”+键名，如键盘上的F11的键代码，在易语言中用常量表示为：#F11键。例如，在向编辑框中输入内容的时候，想简单的屏蔽掉某个键，就可以在编辑框的“按下某键”事件子程序中输入代码。
（5）用常量填写参数
很多命令参数填入的都是常量，如：“时间到文本”命令，此命令将指定时间转换为文本并返回。第1个参数为“欲转换到文本的时间”，而第2个参数值可以为以下常量：1、#全部转换；2、#日期部分；3、#时间部分。在填写第二个参数时，可以填写数字，也可以直接填写常量名，如：
时间到文本 ([2004年3月16日5时11分11秒], #日期部分)



2.6.4 枚举常量




枚举常量是一种非常方便的常量类型，它本身就是一个常量的集合，将多个常量以成员的形式，存放在一个常量中，使用的格式为
#枚举常量名．成员名
这里要注意，枚举常量只是一种常量的表现形式，是由易语言支持库定义的常量，和普通常量相同，但只能由用户来调用，但不能自定义。
易语言中有很多支持库中使用了枚举常量，如核心支持库中定义的“变体类型”，“变体类型”提供变体型中所能够容纳数据类型的枚举值。如表3-4中的某类型枚举常量可存放于变体型中，通过“变体型．取类型（）”取回当前变体型对象的数据类型。
变体类型常量成员及常量值

变体类型 枚举常量集合类型 


成员 描 述
未知

常量值为 -1


初空

常量值为 0


数值型

常量值为 1


文本型

常量值为 2


逻辑型

常量值为 3


日期型

常量值为 4


对象型

常量值为 5


错误值型

常量值为 6


数值型数组

常量值为 7


文本型数组

常量值为 8


逻辑型数组

常量值为 9


日期型数组

常量值为 10


对象型数组

常量值为 11


错误值型数组

常量值为 12


变体型数组

常量值为 13



表中，列出了“变体类型”常量的所有成员名及成员的常量值，在程序中，如果想调用“变体类型”常量中的“日期型”成员，该成员的常量值为4，程序中调用该成员就等于调用了4这个整数，例如用信息框显示出该成员使用代码：
信息框 (#变体类型.日期型, 0, )
运行后，信息框将显示4。
这里要注意，在核心支持库中还定义了“变体型”，“变体型”和“变体类型”不同，“变体型”是一种数据类型，可以将一个变量的类型定义成“变体型”，“变体型”的变量，可以加入成员和改变成员的值；而“变体类型”是一个常量，其值只可以调用而不可以改变。
“变体型”变量的成员和值，要通过调用命令来改变。
例如程序定义一个“变体型”变量，并加入一个文本型成员，然后给该成员赋值“”，然后用信息框显示该成员，代码如下：

对“变体型”变量的操作的其他一些命令包括：清除（）、取类型（）、取数组成员数（）、取文本（）、取数值（）、取逻辑值（）、取日期（）、取对象（）、取变体型（）、赋值（）、创建数组（）。程序中可以使用这些命令来操作“变体型”变量。


2.6.5 自定义常量




除了各支持库定义的常量以外，易语言中还可以自定义常量，自己来规定一个新的常量及其代表的值。自定义常量，可以定义一些固定值，编程中使用一些自定义常量还可以增加编程的灵活性，当程序中多个地方调用了某个自定义常量时，如果改变这个自定义常量的值，那这些调用该常量的地方将会自动调用改变后的新值，这样可以节省改写程序的时间。
定义了一个新的常量后，可以任意定义常量的名称，然后在“常量值”上输入该常量的值。自定义常量的使用方法和非自定义的常量的使用方法相同，用“＃”＋自定义常量的名称。
下面就用一个简单的例程来学习使用自定义常量。新建一个“Windows窗口程序”，在窗口中添加１个编辑框组件、１个标签组件和１个按钮组件。然后按照上面介绍的方法自定义一个常量，常量名叫“显示内容”，然后将常量值定义为“易语言”。这里要说明的是，如果定义数值型的常量，直接在“常量值”上输入数值即可；如果定义文本型常量要在欲定义的文本两端加双引号。
双击窗口中的按钮，在“_按钮1_被单击”子程序中输入代码：

最后运行程序，按下按钮后，可以看到标签和编辑框同时显示出“易语言”。可以试着在不改变代码的情况下，直接改变自定义常量的值，再次运行程序，可以看到改变常量值后，标签和编辑框显示的内容也跟着改变。