模板收集冰雪——www.AAA.com

易 语 言 论 坛
名称:
口令:
登陆注册 忘记密码
站 务 新 闻
2002/07/01 模板由冰雪编辑过。
2002/07/01 第一个免费ASP空间申请通过。
2002/07/01 技术论坛投入使用。
2002/07/01 易语言试开通，欢迎来访。
本 站 服 务 项 目

每 周 酷 程 推 荐
程序名称:
程序作者:
程序介绍:
推荐指数:☆☆☆☆☆
程 序 分 类 共有加盟网站500 个
教程类精品网站
系统工具

教程类精品网站
数据库

教程类精品网站
通用控件

教程类精品网站
数值运算

教程类精品网站
网络通讯

教程类精品网站
其他类别

加 盟 网 站 焦 点
浪花
飞扬工作室
西风
世恒
bb88
Taowen
小米虫
Eatapoe
Candy
liigo

设 计 联 盟
申请加盟
作品欣赏
作品欣赏（原码）
关于设计联盟
最 新 作 品 欣 赏
名称:
作者:
类别:
名称:
作者:
类别:

模板提供：冰雪 模板收集：冰雪　请保留本站链接，谢谢


三分钟学会编程，易学，易懂，易用，易写，易交流等等，这些都是易语言的特点。
  可是最近我在网上通过QQ所接触到的一些朋友，却让我感觉到他们学易语言并没有当初我学易语言那么“易”。那下面，我就针对这一部分入门级的朋友讲一下应该怎么来样学习易语言：
  如果你对编程连一点基础都没有的话，那我们一起来打开易语言（双击e.exe这个程序）在打开后，你会看到，这就是你以后编程中所常见到的程序界面了。如下面图一所示：

现在我们首先找到上面的菜单，点击最后一个菜单项（帮助），这时我们就会看到第二项为易语言知识库，单击打开，此时，程序自动打开一个名叫《易语言知识库1.9版》的帮助文件。好了，下面就开始我们的学习了。
  点击《知识库》的左边，选择目录，在目录项里再选择编程基础知识，切记，这是学编程中所最重要的。在这里，我们将会学习到如下的概念：窗口单元及事件驱动、对象，以及对象的概念、对象的创建、在程序中如何引用对象的属性及引用方法。下面我再讲述一下：
  窗口单元：所谓“窗口单元”，即用作组成用户图形界面的基本成员，譬如：窗口、编辑框、图片框等等。窗口单元按可否容纳其它窗口单元划分为容器类和非容器类。按运行时是否可能具有可视外形划分为界面类和功能类。容器类窗口单元内可以包容其它的窗口单元，譬如窗口、选择夹、图片框等都属于容器类。而功能类窗口单元仅用作在其所在窗口上提供某种功能，譬如时钟、打印机等。（这些编程框、图片框、时钟等就在上图右边的窗口单元箱里可以找到的。）
  什么叫事件：所有窗口单元在其状态被改变或操作者在其上进行了某种操作后，就会产生事件，都会有可能向用户程序发送这种事件，所以，我们编程也就是要通过我们的程序接收这些事件来进行程序的下一步操作。（但是要注意，并不是所有的事件都会发送给用户程序的）。比如，我们有一个程序要求：在一按钮被按下的时候，该程序退出。在这里，按钮被按下时，按钮（这就是一个窗口单元）就会向用户程序发送一个事件，这个事件的名字就叫做“按钮被单击”的事件。所以，我们在程序中就去接收这个事件，一旦我们接收到这个事件，程序就退出。这样，我们就完成了该程序的要求。（注意：我们要怎么要才能知道一个窗口单元有哪些事件呢？请看下面图二）

  参见上图，在易语言的左边，刚才我们选择的是支持库，那下面我们就选择属性（看红圈所示），在这里，我们就可以看到有一个叫在此处选择加入事件处理子程序的下拉菜单，点击这个菜单我们就可以看到针对这个按钮的所有可能发生的事件了。同理，我们也可以找出其他窗口单元的所有事件。
  到这时，可能你也基本上明白编程的思路了吧：用户程序根据接收来自各个窗口单元的事件来进行不同的操作而达到不同的目的。这就是编程。
  在编程基础知识中，其他部分就参见《知识库》中所写的内容。
  只是对“bq1.bt = "祖国，您好！"”这一句话解释如下：（在按钮被单击的事件里）我们让标签1的标题内容为“祖国，你好！”。bq1.bt表示取标签1的标题这个属性。由于这个属性为文本型，所以，我们后面的“祖国，你好！”要加上双引号，表示这是一个文本型的数据。

  好了，编程基础知识第一章就讲到这里，如果大家学得这样可行的话，请跟贴，这样，我就会有信心继续写下去的。


终于忙过了，所以，现在有时间坐下来，继续为大家写一点入门级的教程了。。。：）
  （本章内容主要是转载《易语言知识库》中的内容，因本章对编程基础非常重要，请大家仔细阅读）
  在上一讲中，我们学会了如何采用bq1.bt=“祖国，你好！”这一句代码来写一个程序，可是这一句代码是怎么样来实现这个程序的呢？今天，我们就这一个程序来讲一讲我们易语言的语言手册（详细内容可见《易语言知识库》中）
  一：易语言的命名约定：首先，我们易语言所讲究的就是全中文编程，所以，我们在整个程序中都可以采用我们自己的方式来为我们程序中不同的类（如子程序、容器、数据类型、控件等）来命名，而具体的命名规则为名称的首字母必须为全半角字母或汉字，其它字符必须为全半角字母、全半角数字或者汉字。虽然名称中允许半角字符“_”存在，但它被保留为系统专用，因此不要使用。那么在bq1.bt=“祖国，你好！”这个程序中，左边的bq1代表的是标签1，根据易语言的命名规则，我们可以用任意名字来定义这个标签（请注意，修改标签的名字应该在标签的属性栏里修改），比如我们可以写为“显示器”，那么这一句话就就成了xsq.bt＝“祖国，你好！”，大家注意看，我们改了名字和没有改名字以前这两句相同的部分在哪里？后面的.bt是代表标签的标题这一个属性，所以，不管我们的标签改成了什么名字，但是他仍是标签，他的属性并没有改变，所以，我们可以总结出这样一个规律：可以采用任何一个名字来命名一个类，这只是方便我们编程中的使用，不会改变其属性或参数的。
  二、程序的启动方式：分为通过名称为“_启动窗口”的窗口启动和通过名称为“_启动子程序”的子程序启动两种方式，大家可以在易语言上面的菜单项里选择程序项，再选择系统配置，在弹出的系统配置对话框窗口中选择“通常”选项卡，大家就可以看来，有一个单项选择，让你来选择程序的启动方式。这两种不同的启动方式的区别是什么呢？如果以通过名称为“_启动窗口”的窗口启动，那么，你的程序在启动时，首先载入的就是你所编辑的那个主窗口（名为_启动窗口），如果以通过名称为“_启动子程序”的子程序启动，那么在程序中就会有一个名字叫做“_启动子程序”的子程序，程序每一次启动时，此子程序都会在程序载入时最先执行。比如，我们在此子程序中写个一个xxk("你好!",0,)，那么此程序每次运行时，都会首先弹出一个内容为“你好”的信息框。
  三、易语言的语言要素：
    1、 数据类型

    数据类型分为系统基本数据类型、库定义数据类型、用户自定义数据类型三类。

系统基本数据类型列表及其说明如下：

字节型。可容纳 0 到 255 之间的数值。

短整数型。可容纳 -32,768 到 32,767 之间的数值，尺寸为 2 个字节。

整数型。可容纳 -2,147,483,648 到 2,147,483,647 之间的数值，尺寸为 4 个字节。

长整数型。可容纳 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 之间的数值，尺寸为 8 个字节。

小数型。可容纳 3.4E +/- 38 (7位小数) 之间的数值，尺寸为 4 个字节。

双精度小数型。可容纳 1.7E +/- 308 (15位小数) 之间的数值，尺寸为 8 个字节。

逻辑型。值只可能为“真”或“假”，尺寸为 2 个字节。“真”和“假”为系统预定义常量，其对应的英文常量名称为“true”和“false”。

日期时间型。用作记录日期及时间，尺寸为 8 个字节。

文本型。用作记录一段文本，文本由以字节 0 结束的一系列字符组成。

字节集。用作记录一段字节型数据。字节集与字节数组之间可以互相转换，在程序中允许使用字节数组的地方也可以使用字节集，或者相反。字节数组的使用方法，譬如用中括号对（“[]”）加索引数值引用字节成员，使用数组型数值数据进行赋值等等，都可以被字节集所使用。两者之间唯一的不同是字节集可以变长，因此可把字节集看作可变长的字节数组。

子程序指针。用作指向一个子程序，尺寸为 4 个字节。具有此数据类型的容器可以用来间接调用子程序。参见例程 sample.e 中的相应部分。

    在以上的基本数据类型中，字节型、短整数型、整数型、长整数型、小数型、双精度小数型被统称为“数值型”，它们之间可以任意转换。不过编程需要注意转换可能带来的精度丢失。譬如：将整数 257 转换为字节后的结果为 1 ，这是因为值 257 超出了字节型数据的最大上限 255 ，从而产生了溢出。

    另外，通用型数据类型仅在系统内部使用，它能够匹配所有的系统基本数据类型、库定义数据类型、自定义数据类型。

库定义数据类型：

    库定义数据类型由运行支持库提供，用户在程序中可以直接使用，就如同是系统基本数据类型一样。

自定义数据类型：

    用户可以随时在程序中自行定义新的数据类型。自定义数据类型时需要设置数据类型的名称及其成员。数据类型成员各属性的设置方法等同于容器设置时相应属性的设置方法。

引用库定义或自定义数据类型对象的成员：

    数据类型成员等同于对象的属性，必须通过具有该数据类型的对象来引用。引用方法参见编程基础知识中的《引用对象的属性及方法》节。

    2、命令及操作符

    命令由运行支持库提供给用户在程序中使用，它们被分为很多类。有些命令的最后一个参数可以被扩展，譬如“相加”，它的“加数”参数可以被无限制地扩展，用作支持连续相加。这些命令在录入到程序中后在编辑窗口内其首部会显示出一个右双箭头作为标志。命令中的某些参数也有可能可以被省略，即调用时可以不提供参数数据。具体情况请参阅《支持库手册》。
     3、子程序。每一个程序都是由很多小的子程序组合而成的， 子程序可用于压缩重复任务或共享任务，例如，压缩频繁的计算处理等等。用子程序编程有两大好处：

子程序可使程序划分成离散的逻辑单元，每个单元都比无子程序的整个程序容易调试及理解；

一个应用程序中的子程序，往往不必修改或只需稍作改动，便可以成为另一个程序的子程序。

    每次调用子程序时，子程序中的所有语句都将被从第一条开始顺序执行，当执行到子程序尾部或者遇到“返回”命令时即返回到调用此子程序语句的下一条语句处。

    子程序可以接收参数数据和返回值。参数数据由调用子程序的语句传递过来，子程序的返回值被返回到调用子程序的语句处。

    子程序如需要返回值，必须先在子程序定义表的“返回值类型”栏中定义欲返回值的数据类型，然后在子程序中使用“返回”命令返回相应格式的数据。

    子程序如需要接收参数数据，必须先在子程序定义表中参数表部分定义与欲接收数据数目相同的参数。调用子程序时所传递过来的数据将被顺序地填入对应的参数中。如果所传递过来的数据与对应位置处的参数数据类型不一致，在可以互相转换时，系统将自动进行转换，否则会产生运行时错误。参数仅能在子程序内部使用。

定义子程序参数时需要定义以下几项主要属性：

参数名。 定义该参数在子程序中的使用名称。参数可以如同容器一样使用；

类型。所定义的数据类型应该与欲接收数据的数据类型相同或者能够互相转换；

参考。设置系统为当前子程序参数传递数据时是否为传递指向数据的指针。如果所传递过来的参数数据为数组、用户定义数据类型、库定义数据类型、字节集型数据，则无论此属性是否为真，都将传递指针。如果所传递过来数据的类型与相应位置处参数的数据类型不一致但可以相互转换，譬如将“整数型”数据传递到“小数型”的参数中，则在数据被实际传递前，系统将首先自动将“整数型”数据转换为“小数型” 数据，然后再进行传递。因此在这种情况下，即使本属性为真，系统也无法传递指向原参数数据的指针，只能传递数据本身。如果系统将数据指针成功地传递过来，那么在子程序中对此参数的内容的更改将会相应地反映到调用子程序时所提供的参数数据上。参见例程 sample.e 中的相应部分。

可空。如果本属性为真，那么在调用本子程序时，调用方可以不为此位置处的参数传递数据。主要用作支持具有默认值的参数，也可以在为子程序添加了新参数后又不想去更改以前调用此子程序的语句时使用。在子程序中可以使用“是否为空”命令来查询调用方是否提供了参数数据。参见例程 sample.e 中的相应部分。

数组。设置当前子程序参数是否为接收数组数据。如果本属性为真，则调用方应该为本参数传递数组数据，否则只能传递非数组数据。参见例程 sample.e 中的相应部分。

四、Dll 命令

    在易应用程序中可以直接调用系统外部动态连接库（即 Dll 库）中的命令。在调用前，必须首先进行定义，定义Dll 命令涉及到以下主要属性：

Dll 命令名。定义该 Dll 命令在易程序中的使用名称；

返回值类型。定义 Dll 命令返回值的数据类型，只能为无、字节、短整数、整数、逻辑及文本型；

Dll 库文件名。 定义当前 Dll 命令所在动态连接库的文件名。如果不指定库文件名，系统将默认在 Kernel32.dll、Gdi32.dll、User32.dll、Mpr.dll、Advapi32.dll 等 Windows 系统的基本应用程序界面函数（API）库中搜寻指定命令；

Dll 命令在 Dll 库中的对应命令名。定义当前 Dll 命令在其所在动态连接库中的名称，如果不指定，系统将默认等同于 Dll 命令名；

定义 Dll 命令参数时的主要属性：

类型。Dll 命令参数所定义的数据类型应该与实际的 Dll 库命令一致。可以使用除了文本数组及字节集数组外的任何数据类型，包括库自定义和用户自定义数据类型。

传址。某些实际 Dll 库命令的参数需要接收数据地址，设置本属性为真可以确保将参数数据的地址传递过去。如果参数数据的类型为数组、文本、字节集、用户定义数据类型、库定义数据类型，则无论此属性是否为真，都将传递数据地址。如果本属性为真且调用 Dll 命令时所传递过来数据的类型与相应位置处所定义参数的数据类型不一致但可以相互转换，则系统先分配一块临时内存空间，然后进行转换并将转换后的数据存放到该空间，最后将此内存空间的地址传递到实际的 Dll 库命令。参见例程 sample.e 中的相应部分。

数组。意义同上。

五、程序集

    程序集顾名思义即子程序的集合，用作将应用程序中的子程序分组归类。在程序编辑过程中，每个程序集将在单独的编辑窗口内进行编辑。

六、容器

    容器即其它编程语言中的“变量”。

    在易应用程序执行期间，可以使用赋值语句在容器内临时存储数据。容器有名字（用来引用容器所包含内容的词）和数据类型（确定容器能够存储数据的种类）。

    容器有使用范围，在全局容器表内定义的容器被称为“全局容器”，可以被整个应用程序中的所有子程序使用；在程序集容器表内定义的容器被称为“程序集容器”， 仅能够被此程序集中的所有子程序使用；在子程序容器表内定义的容器被称为“局部容器”，仅能够被此子程序所使用。

容器的初始化

    所有全局容器、程序集容器、局部静态容器在程序被启动运行前、所有非静态局部容器在其所处子程序被开始执行前，都将被自动分配空间并初始化。其中，数值型容器被初始化为零，逻辑型容器被初始化为假，日期时间型容器被初始化为 1899 年 12 月 30 日 0 时 0 分 0 秒，文本型容器被初始化为空文本（“”），字节集型容器被初始化为空字节集，子程序指针型容器被初始化为空子程序指针。
    特例：系统在对库定义数据类型的对象容器进行初始化时，将首先查询该数据类型的各成员在库中是否指定了初始值。如果指定了初始值，则使用该值进行初始化。譬如：“字体”为系统核心支持库中所提供的库定义数据类型，其“字体大小”成员的初始值在库中被指定为 9 点（1 点等于 1 / 72 英寸），“字体名称”成员的初始值被指定为“宋体”。

容器的赋值

    非数组容器可以通过赋予一个常数、常量、资源、对象或者容器来赋值。所赋予过来数据的数据类型必须与被赋予容器的数据类型一致或者可以互相转换。可以将一个对象赋予给容器后再使用该容器间接引用此对象。譬如：假设存在一个数据类型为“标签”，名为“容器1”的容器，使用“容器1 = 窗口1.标签1”语句可以将“窗口1”上的“标签1”窗口单元对象参考到“容器1”上，以后在程序中就可以直接使用“容器1.标题”来引用“窗口1”上“标签1”单元的标题属性。

    数组容器可以通过赋予一个常数集或者另外一个数组容器来赋值。如果所赋予的数组数据的成员数目小于此数组容器的成员数目，那么多余成员部分将被自动重新初始化。如果大于此数组容器的成员数目，将会产生运行时错误。

定义容器时的主要属性

容器名。 定义该容器在程序中的使用名称；

类型。定义该容器所能储存数据的数据类型；

静态。本属性仅在定义局部容器时需要被设置。如果局部容器在定义时此属性被设置为假，那么运行应用程序时，此容器在其所在子程序开始被执行前自动分配存储空间并初始化，在所在子程序执行完毕后自动释放所分配的存储空间。也就是说，容器的存储空间仅在其所在子程序执行过程中存在；如果此属性被设置为真，那么此容器与全局、程序集容器一样，被分配给在程序运行期间永久存在的存储空间并仅在应用程序启动运行前被初始化一次。

数组。设置当前容器是否为数组容器及数组各维的上限值（即成员数目）。如为多维数组，定义时各上限值之间用逗号分隔。引用容器数组中某成员的方法为使用被中括号括住的从 1 开始的索引数值，如：“[1]”（单维数组），“[2][1]”（多维数组）。所有多维数组均可以使用单维数组格式引用其成员。譬如：数组定义为“2, 3”的多维数组，其成员“[2][2]”可以被单维数组格式“[5]”所引用。

参考容器

    使用“参考”命令可以将一个容器的内容置为参考到其它容器的指针，以后对此容器进行的读写操作将被自动转移到其所参考到的容器。具体情况请参见系统核心支持库中有关“参考”命令的解释。

七、常数

    常数为可以直接在程序中使用的数据，具有以下几种类型：

数值型常数。如： 1、100 ；

逻辑型常数。如： 真、假 ；

日期时间型常数。日期时间常数的内容必须用中括号括住，并且应按以下格式之一提供，年份后的时间部分可以被省略：

1、[1982年4月23日12时30分25秒]
2、[1982/4/23/12/30/25]
3、[1982/4/23/12:30:25]
4、[1982-4-23-12-30-25]
5、[1982-4-23-12:30:25]

文本常数。文本常数的内容为一段文本，必须使用全角或半角双引号括住。如："文本"、“文本”等等；

子程序指针常数。子程序指针常数为指向程序中某一子程序的指针数值，表达方式为符号“&”再加上子程序名称。如：“&子程序1”、“&_启动子程序”等等；

常数集。常数集用作提供其它各类常数或常量的数组形式。表达方式为使用大花括号括住一系列相同类型且通过逗号分隔的各类常数或常量。如：“{ 1, 2, 3 }”、“{ "abc", "bcd" }”、“{ [1982年4月23日], [2000年1月1日12时] }”、“{ &子程序1, &_启动子程序 }”、“{ #红色，#黑色 }”、“{ #图片1，#声音1 }”等等。常数集也可以为空，表达方式为“{ }”，此时它将被认为包含有 0 个数值型常数，可以用作重新初始化一个数值数组或者将某字节集清空，譬如：“数值数组1 = { }”、“字节集1 = { }”等等。

八、常量

    常量用作存储在整个应用程序执行过程中保持不变的数据，其类型可以为数值、文本、逻辑值和日期时间。易语言核心支持库中已经提供了许多常量，但用户也可以在程序中自行定义。常量的引用表达方式为符号“#”再加上常量名称。如：“#pi”常量等同于数值“3.1415926535”、“#换行符”常量等同于文本 <回车> + <换行> 等等。

九、资源

    资源用作存储用户需要在程序中所使用的图片、声音等等字节数据，其数据类型为字节集型。引用表达方式等同于常量。

十、窗口、窗口单元及窗口程序集

    窗口为应用程序的界面，窗口单元为窗口的组成成员。每个窗口拥有一个专用程序集，名为窗口程序集。此窗口上所有的事件处理子程序都必须放在此程序集中。窗口程序集中的子程序引用所属窗口上的窗口单元属性或方法时可以省略窗口对象。譬如：假设程序中存在名为“窗口1”的窗口，该窗口上绘制有一个名为“标签1”的标签窗口单元。在其它程序集中的子程序欲引用“窗口1”的“标题”属性需要使用“窗口1.标题”，引用“标签1” 的“标题”属性需要使用“窗口1.标签1.标题”。而在该窗口的窗口程序集中的子程序可以直接使用“标题”、“标签1.标题”来进行相同的引用。

    系统核心支持库中定义的“窗口”窗口单元数据类型的所有方法能够被其它所有非功能类窗口单元数据类型所共享，就好象这些方法是其本身所具有的一样。

    在一个程序集中可以就象引用窗口对象的属性或方法一样来引用另外一个窗口程序集中的程序集容器和子程序。譬如：假设存在名为“窗口1”的窗口，其窗口程序集中存在名为“容器1”的程序集容器，名为“子程序1”的子程序，在其它程序集中可以使用“窗口1.容器1”及“窗口1.子程序1”来引用此程序集容器和子程序。

    窗口单元的属性除了被标明为“只读”的外，其它属性在运行时皆既支持读也支持写。

窗口的载入

    程序内所设计的所有窗口，运行时在使用前都必须先载入。除开“_启动窗口”由系统在启动程序时自动载入外，其它窗口都必须使用“载入窗口”命令载入。有关查阅“载入窗口”命令详细信息的方法，请参见《支持库手册》。在窗口被载入后，所有对此窗口及其所有单元的对象属性的修改，在窗口被关闭后都将自动被复原到设计状态。但是如果在窗口被载入前修改了窗口或其单元的固定属性，则此属性值将永久存在而不会被复原，就好象是在设计窗口时所设置的一样。

窗口单元的固定事件

    所谓窗口单元固定事件，即由系统而非窗口单元本身提供支持的窗口单元事件。其列表如下：

1、鼠标左键被按下：当在窗口单元上按下鼠标左键时产生本事件。

2、鼠标左键被放开：当在窗口单元上放开被按下的鼠标左键时产生本事件。

3、被双击：当在窗口单元上双击鼠标左键时产生本事件。

4、鼠标右键被按下：当在窗口单元上按下鼠标右键时产生本事件。

5、鼠标右键被放开：当在窗口单元上放开被按下的鼠标右键时产生本事件。

6、鼠标位置被移动：当在窗口单元上移动鼠标时产生本事件。

事件（1 - 6）的事件参数为：

1、横向位置： 指示鼠标在当前所处窗口单元中的横向位置；

2、纵向位置： 指示鼠标在当前所处窗口单元中的纵向位置；

3、功能键状态：用于查看各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数值与想要得知功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，表示同时按下了此功能键。

7、按下某键：当用户按下某键时产生本事件。

8、放开某键：当用户放开所按下的键时产生本事件。

事件（7 - 8）的事件参数为：

1、键代码： 为键常量值，如：“#F1键”、“#回车键” 等等。具体所有的键常量见系统核心支持库库常量表；

2、功能键状态。其意义同上。

    对于事件（1 - 8），对应的事件处理子程序皆可以返回一个逻辑值。如果返回假，则取消本事件，不再将此事件传递到所属窗口单元上去；如果不返回值或返回真，则将此事件继续传递到所属窗口单元上去。

9、获得焦点：当窗口单元获得输入焦点时产生本事件。

    所谓“输入焦点”，即当前用户按键操作所对应的目标对象。譬如：用户正在编辑框中输入文本，那么此编辑框就具有输入焦点，因为它将获得目前用户所进行的所有按键操作。所谓“获得”或者“失去”输入焦点，即当前用户按键操作所对应的目标对象发生转移。譬如：现在用户正在编辑框1中输入文本，突然使用鼠标或其它方法切换到了编辑框2上去继续输入。那么此时，编辑框1就“失去”了输入焦点，编辑框2就“得到”了输入焦点，因为在此以后用户所进行的所有按键操作都将被改为编辑框2所获得。

10、失去焦点：当窗口单元失去输入焦点时产生本事件。

11、字符输入：当用户按下和松开一个字符键时产生此事件。

    字符键包括任何可打印的键盘字符及回车（Enter）和退格（BackSpace）键。在对应的事件处理子程序中，将事件处理完毕后可返回一个字符代码，用于替换将继续传递到所属窗口单元上字符键事件中的字符代码；如果返回 0 ，则取消此事件，不再将此事件传递到所属窗口单元上去；如果事件处理完毕后没有返回值，则将本字符键事件继续原样传递到所属窗口单元上去。

本事件的事件参数为：

１、字符代码： 表明所按下的字符键所对应的字符代码，可以使用“字符”命令取出所对应的具体字符。

窗口单元的固定属性

    所谓窗口单元固定属性，即由系统而非窗口单元本身提供支持的窗口单元属性。在窗口单元属性表中，被显示在以粗线条隔开的第二组属性中。固定属性与普通属性在程序中的使用区别为：固定属性在窗口单元被创建之前也能被程序所使用，而普通属性则不能。其列表如下：

1、 左边、顶边、宽度、高度：指定窗口单元的位置及尺寸。如果窗口单元为“窗口”，其位置值相对于屏幕的左上角，如果为窗口单元，其位置值相对于其所在窗口或者父单元的左上角。

2、标记：指定跟随于窗口单元的一段文本，用于在程序中取得或设置与该窗口单元相关联的数据。

3、可视：指定窗口单元是否具有可视外形。

4、禁止：指定窗口单元是否可以被操作者操作。

5、鼠标指针：指定鼠标移动到窗口单元上时的外形。

6、可停留焦点：设置当用户使用 TAB 或光标键在窗口上各单元之间移动输入焦点时是否允许在本单元上停留。

7、停留顺序：本属性必须在上一属性被置为真时才有效。用作设置用户使用 TAB 或光标键在窗口上各单元之间移动焦点时的顺序。当窗口被载入后，输入焦点将被交给具有最小停留顺序值的单元。

    （本章内容主要是转载《易语言知识库》中的内容，因本章对编程基础非常重要，请大家仔细阅读）


          什么是api，我们怎么去使用？     作者：浪花

  在论坛里，大家经常都可以看到api这个字样，并且有很多朋友的程序里也涉及到了这些，这个api究竟代表的是什么呢？让我们打开《易语言知识库》的第二十二章：dll命令。
同时，再打开任何一个api查看器（在易语言源程序交流园地里有下载链接）。
  为大家举一个例：ClipCursor函数。从字面上来直译，好象是剪辑光标之类的什么意思对吧。下面，我们来看看在VB里这个函数他代表的是什么：
  VB声明
Declare Function ClipCursor& Lib "user32" (lpRect As RECT)
  说明
将指针限制到指定区域。
  返回值
Long，非零表示成功，零表示失败。会设置GetLastError
  参数表 ：
参数 类型及说明
lpRect：       RECT，指定一个矩形，用像素屏幕坐标系统表示。鼠标指针必须在这个区域内运动。
  注解 ：指针剪切后，按Ctrl+Alt+Del可简单的清除剪切区域
  下面，我就针对上面的一些内容给大家讲解一下api函数：
  一、Declare Function ClipCursor& Lib "user32" (lpRect As RECT)这一句的意思就是：声明函数ClipCursor，该函数所在库为“user32”里，此函数有一个参数，名为lpRect，此参数的类型为RECT。
      为什么要声明函数？这是在编程中所必须的。就象你在程序中所设立的那些容器一样，你首先必须得在程序前面说明（当然，在易语言中声明api函数是在专门的位置里声明的），这样，程序才能知道你会使用到他，所以，我们必须得声明函数。
  二、说明：将指针限制到指定区域。这句话的意思就是我们可以在程序中用此函数将我们的鼠标指针给限制在某一个特定的区域里。想想我们计算机的屏幕保护程序采用密码保护时吧。你的鼠标跑不出它的密码输入框的。
  三、返回值：Long，非零表示成功，零表示失败。会设置GetLastError。这句话的意思就是该函数执行后，会有一个返回值，如果该返回值不是零，就表示该函数执行成功，反之则失败。后面那一句可以不理会。
  四、参数表：此函数只有一个参数lpRect，而它的数据类型为RECT。在我们的易语言中，可是没有这种数据类型的哦。那我们怎么办呢？没关系，我们不是可以自定义数据类型吗？所以，这一个问题也就解决了。请注意RECT是代表一个矩形，也就是说它得有四个成员（左、上、右、下）
  好了，上面给大家详细解释了一个这个函数在VB中的声明，下面，我们回到易语言中。一起来写一写这个程序：
  新建一程序，现在大家可以看到一个我们经常放置各种编程框呀，按钮之类的那个窗口了对吧，现在我们就什么也不放。首先，在易语言的菜单里，选择：插入－>新数据类型。现在大家又可以看到一个新的样式的表格了，对吧。OK，动手吧。将“数据类型1”改为“矩形样式”，回车，表格是不是又多了一行？好了。成员名输入“左”，类型输入“整数型”，再回车，同理，一直要输入完左、上、右、下四个成员，其类型均为整数型。这样，我们的新数据类型就声明完毕了。
  现在，我们再回到易语言的菜单里，选择：插入－>新dll命令。大家又可以看到另外一种新的样式的表格了对吧。唉呀。这里面怎么这么多的内容呢？我们应该怎么样去填写呢？
别急，回想一下刚才我们所讲述的VB的api函数声明里，有些什么内容？对了，第一，好象是叫什么声明函数对吧？OK，那我们就在dll命令名里填入函数名，可是我们易语言可不讲究名字的哦，所以，我们可以自己随意取名字的。那我们就写“限制鼠标”吧，第二项叫返回值类型。刚才我们不是有一个叫什么非零成功的吗？对了，那他就是整数型了。第三项叫库文件名，也有，就是那个叫什么“user32”的。（填写的时候可不能有双引号哦，并且此项也可以不填，程序会自动寻找）。第四项，本dll命令在dll库中的对应命令名，这可是最重要的哦,输入ClipCursor（最好注意一下大小写）。刚才我们不是讲述了这个函数有一个自定义数据类型的参数吗？怎么这里的参数下面就没有表格了呢？回一下车，看看，是不是又多出了一行？好了，这里，我们就可以输入参数了，但是，我们是易语言，所以，可不能直输入lpRect哦（虽然不影响程序），因为我们是中文编程，所以，得给它改改名字，对了，就叫它“矩形”吧，类型呢？就是我们刚才声明的那个新数据类型呀，叫做“矩形样式”。这样，整个api函数我们就声明完毕了。
  现在，我们又选择易语言菜单：窗口－>3窗口：_启动窗口。 又回到了我们什么也没有放置的那个启动窗口了。这下，我们该写点什么内容了吧？
  在左边的“支持库、程序、属性”选择夹里，选择“属性”，然后在下面的“事件处理子程序”下拉菜单里选择“创建完毕”（以上方法也可以用鼠标直接双击启动窗口就可以得到），这时，我们就进入了一个窗口程序集1，里面有一个名为“__启动窗口_创建完毕”的子程序。好了，开始我们的代码的编写吧。
  选择窗口程序集1，回车，出现一个容器表格，输入“矩形”，类型为“矩形样式”，选择“__启动窗口_创建完毕”子程序，输入以下代码：
  矩形。左＝_启动窗口。左边
  矩形。上＝_启动窗口。顶边
  矩形。右＝_启动窗口。左边＋_启动窗口。宽度
  矩形。下＝_启动窗口。项边＋_启动窗口。高度
  限制鼠标（矩形）

  好了，我们的程序就是这么多代码，简单吧！接一下F5运行一下啦。
  什么？你的鼠标被限制在了那个启动窗口里了？出不来了？哈哈，你的程序就这样就成功了呀！怎么退出来？呵呵，不好意思，刚才有一句话，是写出来了，但是后来我就没再说了，按Ctrl+Alt+Del就可以退出来啦。。。。。。。

  本教程由浪花编写，欢迎转载，如有不对的地方，请各位朋友多多指教，谢谢！


（转载自.::Etp工作室::.之『教育部』）
  对于初学者来说，即使代码是全中文的，也需要别人讲解才能明白其中的意思。如果我们能够理解其中大多数的代码的意思，那我们学习易语言就会相对容易。为此下面列举易语言常见的各类语句供大家学习或编程时参考。
 ㈠、赋值型语句。（也可称属性型语句）（特征：有一个“=”号将左右两边连起来）

      这是我们学易语言首先会接触的一类语句。比如：标签1.标题 ＝ “祖国，您好！” ，这句代码的意思是：标签1的标题是：“祖国，你好！”——即将标签1的标题属性值定为“祖国，你好！”（所谓赋值也）。我们所见的给变量赋值就是用此类语句。赋值语句常见有以下两类：
 ...⑴、将某一对象的某种属性值赋给另一对象。
     比如：标签1.标题=编辑框5.内容。意思即是“标签1的标题跟编辑框5中的内容一样”。比如我们在编辑框5中输入“易语言使英语盲也学会了编程”，那么在相关事件（比如单击按钮）的驱动下，标签1的标题也相应显示为“易语言使英语盲也学会了编程”。
 ...⑵、将某一类型的属性值赋予某个对象。
     比如：标签1.标题=“祖国，你好！”，将“祖国，你好！”赋给标签1的标题。
所赋予的属性值可以是各种类型的，比如：窗口1.可视=真，这个“真”是一个逻辑型数值。如果是文本型数值要用双引号，比如刚才的例子：标签1.标题=“祖国，你好！”即是。
     又如，我们会发现这类句子：标签2.标题 ＝ 到文本 (取小时 (取现行时间 ())) ＋ “:” ＋ 到文本 (取分钟 (取现行时间 ())) ＋ “:” ＋ 到文本 (取秒 (取现行时间 ()))。因为标签类对象只接受文本型数据，所以要把时间型数据转化为文本型，否则测试时会提示：“所接受的数据类型与传递给它的数据类型不一致”。
     有时我们会发现此类句子：容器1=容器1+10，这个语句的意思是：“将容器1加10之后，再将新值传回给容器1”。 从这里可以看出，这里的“=”号跟数学中的“=”号在含义上是不同的，在数学中不可能出现b=b+2之类的表达式，而在易语言中这种表达式却是允许的，而且是经常运用的。
     另外，我们又会看到这类句子：编辑框1.高度=取用户区高度 （）。“=”号的右边表示操控程序的命令，也即是说有时可以将系统命令、执行条件、项目、常量、子程序、函数、资源乃至其他对象的方法等，都可以当作是属性值赋给对象。“编辑框1.高度=取用户区高度 （）”可以理解为取得“取用户区高度 （）”的返回值（运算结果），然后将此值赋给编辑框1。
   预告：以下我们将会继续介绍方法型语句、命令型语句、流程控制型语句、运算型语句、函数型语句等。
   由于我也是菜鸟，所以分类可能不太严密。请高手帮我看看上面有哪些地方说错了，我自己是不太清楚的。


㈡、非运行语句。
     非运行语句包括以下几种。

  ①、注释型语句。

  易语言的注释型语句的格式是：

          ※ 注释语句

  注释语句不能执行程序，只是用来解释上一行代码的意思。易语言是把注释代码隐藏起来的。显示某行代码的注释语句的方法是：选中某行代码，如果在该行代码前出现“+”号，说明该行代码有注解，点击该“+”号可以打开该行代码的注解，点击“-”可以重新隐藏注解。
  上述注释型语句是易程序中固有的，我们也可以自己添加注释型语句。方法：直接改动某一备注或用右键选“修改备注”。
   除了上述的备注方法外，在下方的“提示夹”里有对该行代码更详细的解释。
   我们也可以把下面的草稿型语句作为备注。

 ②、草稿型语句。

   易语言的草稿型语句的格式是：

         ※草稿：程序代码

  草稿型语句也不能被程序执行，有两种情况会出现草稿型语句：①、没有转为正式语句，在代码前会有“※草稿：”字样，转化为可以运行的正式代码的方法：双击该行代码使之变灰，然后按回车键（即Enter键）。②、该行代码有错误，不能转化为正式语句。处理：修改错误。

 ③、测试型语句。（等等再解释）

--------------------------------------------------------------------------------
交流附件上传地址：http://www.91asp.com/


㈢、方法型语句。

    我们如果看过《控件的属性、事件和方法》，就会理解方法是一个具体对象能够执行的动作。有的方法会有参数表，有的方法则不用参数，“参数”大概相当于调用这个方法的各种相关数据，包括相关对象属性值、系统命令、执行条件、项目、常量、子程序、函数乃至其他对象的方法等，都是可以调用的参数。不同的方法有不同的参数，一种方法可以有多种类型的参数。执行、调用一个对象的方法的一般格式如下：
           对象名.方法名(参数1,参数2,...)。

   例如需要在一个名为“购物篮”的列表框里添加一个叫“苹果”的列表项目，其语句如下：
                 购物篮.加入项目（苹果）。
   上面这句话的意思可以理解为：“将购物篮的加入项目（方法）定为苹果”。在这个例句中，“加入项目”是“购物篮”的方法，“苹果”是其参数。其中调用列表框的“加入项目”方法的句式是：
          列表框.加入项目 (欲加入项目的文本,[与欲加入项目相关的数值])
   同时我们又会发现另一类句式，比如“销毁()”，这个句式跟命令型句式很象，但其实它是下面这个句式的省略表达：窗口单元.销毁 （）。也即是说调用当前窗口单元的方法句式可省略前面的对象名前缀，它仍然是一种方法型语句。再举另一例子，“窗口单元.弹出菜单 （欲弹出的菜单，［水平显示位置］，［垂直显示位置］）”可以省略表达成“弹出菜单 （欲弹出的菜单，［水平显示位置］，［垂直显示位置］）”。

   欲查看某类窗口单元具有哪些方法、这些方法的详细解释以及有哪些可用参数等，请到易语言设计界面的支持库夹中的“数据类型”分枝中寻找。譬如：想了解画板的所有方法，可以到“数据类型 -> 画板”下查看。
   下面列举几个调用对象方法的例子，以便让各位菜鸟举一反三：

    ①、在程序中使用常量时其名称前必须加上“#”符号,所以如果调用的参数中有常量,就在常量前面加上“#”符号,比如：
           列表框1.调整层次 (#底层)
    ②、调用系统命令作为参数。例句：
           画板1.滚动写行 (数值到人民币 (100, 假)) 。
    这句的意思是，调用“画板1”的“滚动写行”方法。而其欲写出的数据（参数）是“数值到人民币 (100, 假)”（这句的语法请看帮助），这是一种数值转换命令语句。
    ③、调用相关对象的属性值作为方法的参数。例句：
            列表框．加入项目 (编辑框1.内容,)

      其他用法就不一一列举了。


（四）、命令型语句。
    命令型语句跟方法型语句差不多，看看下面两者的对比就知道它们的差别了——方法型语句：对象名称.方法名称(参数,......)，而命令型语句的基本格式是：

                 命令名称 (参数,......)
    “命令”的意思也跟“方法”差不多，都是一种程序运行动作指令，只不过“方法”是某个具体对象所具有的能供调用的指令，而“命令”则是整个易语言系统固有的、可以供任何程序任何对象调用的指令，所以命令名称前面没有前缀的对象名。
     有时候命令的参数不是必需的（即“可选的”），比如：取随机数 （［欲取随机数的最小值］，［欲取随机数的最大值］），“［］”表示该参数不是必需的。如果是这种情况，该参数可为空，比如：取随机数 （）。
     那么，我们怎样调用命令呢（怎样编辑命令代码）？怎样查找易语言系统提供的命令呢？也是有两种方法：①、请到易语言设计界面的支持库夹中的“数据类型”分枝中寻找。譬如：想了解文件读写的“插入文本”命令，可以到“核心支持库-> 文件读写->插入文本”查看。点击该命令名称可以快速地在代码编辑区插入该命令的代码；②、选“帮助→易语言知识库→目录→参考手册首页→系统核心支持库”，我们会发现那里列举了易语言提供的所有命令类别，可以选中某类命令类别来查看。
    通过查找，我们会发现易语言提供以下几种类型的命令可供调用：
    ①、调用核心支持库命令，包括以下几大类型：
              流程控制 算术运算 逻辑比较 位运算
              容器操作 数组操作 环境存取 拼音处理
              文本操作 字节集操作 数值转换 时间操作
              磁盘操作 文件读写 系统处理 媒体播放
              程序调试 其他 数据库 网络通信

        比如“取现行时间 ()”是属于时间操作命令，而“数值到人民币 (100, 假)”是一种数值转换命令。
    ②、调用其他程序（包括窗口程序集、子程序等）、函数、API函数等的命令。有时候我们会发现某个命令在核心支持库里找不到，那可能是调用以上的东西，比如在某一个例子中有一个“添加用户（）”的命令，这个命令在系统命令列表里找不到，我们再看下面有一个子程序叫“添加用户”，原来该命令是调用“添加用户”子程序。

    下面再列举一些常见的命令以便举一反三：
   ①、载入窗口命令。我们想通过一个窗口启动其他窗口，可用此命令，其句式是：
           载入 （欲载入的窗口，［父窗口］，是否采用对话框方式）
      它的意思请查看有关说明。
   ②、运行命令。使本程序或其他程序运行，其句式为：
          运行 （欲运行的命令行，是否等待程序运行完毕，［被运行程序窗口显示方式］）。
          示例：运行（程序1,,假）。
   ③、信息框命令 。有时我们想使系统反馈指令，比如弹出相关提示，但又找不到有“信息框”这个控件（窗口单元），原来易语言是通过命令调用信息框的（类似的还有输入框命令），其格式是：
          信息框 （提示信息，按钮，［窗口标题］）。
   ④、关闭命令。这是一种数据库操作命令，当指定数据库操作完毕后，关闭已经被打开的指定数据库，以便清空数据变量，节约系统资源，其句式是：
          关闭 （［数据库别名或名称］）
   ⑤、结束命令。本命令结束当前易程序的运行，参数为空（无返回值），其格式是：
           结束 （）

   最后要说的是，我们只介绍了命令型的基本语句，我们在以后的学习中将会继续讲解命令型基本语句中的各类语句，包括流程控制语句中的条件语句、选择语句、循环语句等，还有容器操作、逻辑比较等命令语句都要继续讲解。


（五）、表格型语句（声明型语句）。

  学过其他编程语言的朋友初次用易语言一般会不太适应，因为代码都是用中文表示的，呵呵。其实易语言的语法规则跟其他编程语言是差不多的，可能他们比较不习惯的是声明型语句是用表格来表达。
  比如VB中声明变量的句式是“dim  变量名 as 变量类型”之类，而易语言是用表格声明容器来表示，表格所要填写的内容包括容器名（变量名）、容器类型（变量类型）等项目。用表格能更直观地了解、查找或插入所要声明的东西，例如变量、子程序、常数、dll函数、声音或图片资源等。
   如果我们把易语言的表格型代码复制粘贴到记事簿等文件中，会发现表格型代码转化为文字型代码，比如对子程序的声明会变成类似下面的语句：

                    子程序：_按钮1_被单击
                    返回值类型：字节型

   下面来列举一下声明型语句的几种类型和声明方法：
   ㈠、建立（声明）容器（变量）。需要声明（定义）的项目包括容器名、容器类型、是静态容器还是非静态容器、数组、备注等。
    建立容器的方法：⑴、局部容器—在子程序下面按下“Ctrl + L” 加入一个空容器。
⑵、窗口程序集容器—在窗口程序集下面按回车键。⑶、全局容器—在工作夹里选“程序→全局容器”，或在菜单里选“插入→新全局容器”。
   ㈡、建立子程序。声明项目包括子程序名、返回值类型、参数名等。
    建立子程序的三种方法：⑴、在菜单里选“插入→新子程序”，⑵、或者按“Ctrl + N”插入一个新子程序，⑶、也可以选定需要对其事件进行编程的控件对象（如按钮1）然后在属性夹里选取相关事件（如“被单击”），会同时在代码编辑区插入“按钮1.被单击”之类的子程序。
   ㈢、建立dll命令（api函数）。
    跟其他编程语言一样，易语言本身提供的系统命令是有限的，但在易应用程序中可以直接调用系统外部动态连接库（即 Dll 库）中的命令。在VB里声明api函数的语句类似于下面的句子：
           Declare Function ClipCursor& Lib "user32" (lpRect As RECT)
     这句话翻译成中文是：
  声明函数：ClipCursor  函数所在库：user32(函数参数名：lpRect  参数类型：RECT)
     那么在易语言里，声明dll命令也包括api函数名、函数所在库、函数参数名和参数类型等项目。
     建立dll命令来调用api函数的两种方法：⑴、在工作夹里选“程序→dll命令”。⑵、菜单里选“插入→新dll命令”。
    ㈣、其他的表格型语句还包括建立程序集、建立新数据类型、建立常量、建立声音或图片资源等。一般来说用表格来插入以上这些东西的方法有两种：⑴、在工作夹里选“程序→”。⑵、菜单里选“插入→”。

                                    （《易语言常用语句》全文完）


设立本100例教程的目的：把易语言现有的例程都学习一遍，以达到共同脱菜的目的。
 ★、例程来源。

  ㈠、例程名称：计算编辑框的输入内容的长度（暂名）
  ㈡、下载地址：
  ㈢、作者：（暂不详）

 ★、例程详解。

   不知程序作者是谁？该程序作者或提问者为什么要做该例程？有什么作用？有知道者请跟贴。我在编辑时修改。
   该例程只有一个子程序，该子程序只有一行执行代码，程序如下：

               子程序：_编辑框1_内容被改变
               标签1.标题 ＝ 到文本 (取文本长度 (编辑框1.内容))

   编程大概思路：
   ㈠、确定用什么样的子程序，包括确定用什么控件来发送指令（事件驱动承担者），什么控件用来传递指令，什么控件用来执行指令，什么控件用来反馈指令。
   ⑴、确定发送指令控件。比如用按钮作为事件驱动（发送指令）承担者，则程序大概是：

               子程序：_按钮1_被单击
               标签1.标题 ＝ 到文本 (取文本长度 (编辑框1.内容))

      当然，如果想使编辑框在输入文本时即时显示文本长度，就要用到编辑框本身的事件，如本程序的第一种子程序，即子程序：_编辑框1_内容被改变，通过在编辑框输入信息来发送指令。
   ⑵、确定传递、执行或反馈指令控件。如果我们用信息框来执行或反馈指令，则程序大概类似下面为好：

                    子程序：_按钮1_被单击
                    信息框 (“你输入的文本长度是：” ＋ 到文本 (取文本长度 (编辑框1.内容)), 0, )

      思考：如果想做到按“enter”时就弹出该信息框，应怎样做？

   ㈡、“计算编辑框的输入内容的长度”也即是确定编辑框的某个属性值，那么我们就重点查找编辑框的有关属性、方法和事件及易语言系统有关的命令，看有哪些在本例程中用得上。还是比较难找呢。

--------------------------------------------------------------------------------
交流附件上传地址：http://www.91asp.com/


由于还没有找到新空间存放例程，所以《菜鸟每日一课》和其他课程暂停，代之以一门新课程：《易语言时尚编程100例》，专门学习研究别人的程序。由于本人也是菜鸟，所以一般是照搬其中的代码，保持原汁原味，其中是否有错，由高手来跟贴完善评改吧。
★、例程来源。

㈠、例程名称：幼儿算术软件
㈡、下载地址： http://eyuyan.com/non-cgi/usr/1/1_3244.e
㈢、作者：bklbklbk

★、例程详解。

该程序近日由作者上传到论坛，程序明白易懂，主要功能代码也不多，所以我们现在就以它为研究学习对象。
该程序由三个窗口组成，其中_启动窗口只是该程序的封面，窗口2只是说明文件，核心功能都在窗口1中实现，所以这里只讲解窗口1，窗口1中又只有“出题”和“计算结果”两个重要子程序，其他的子程序是辅助的。

㈠、先讲讲怎样实现随机出题。
在随机出题中作者要做两件事：⑴、用单选框设置有三个出题计算数的范围：1到10；1到20；1到100，分别代表三种不同的学习程度。⑵、按三种计算数范围随机出题。下面看程序是怎样做的：

子程序：_按钮1_被单击

置随机数种子 ()
※一般过程是先置随机数种子再随机取数
编辑框1.内容 ＝ 到文本 (取整 (取随机数 (最小号码, 最大号码)))
※随机选择第一个计算数
编辑框2.内容 ＝ 到文本 (取整 (取随机数 (最小号码, 最大号码)))
※随机选择第一个计算数。取整数的随机数，“取整”是算术运算命令
编辑框3.内容 ＝ “”
※清空“编辑框3”以便你把结果填上去
标签2.标题 ＝ “”
※清空“标签2”（提示正确与否）以方便指出对还是错
编辑框3.获取焦点 ()
※使“编辑框3”获取焦点光标以便你输入计算结果
如果 (单选框1.选中 ＝ 真)
最大号码 ＝ 10
※当选择最大数为10的计算范围时
否则
如果 (单选框2.选中 ＝ 真)
最大号码 ＝ 20
否则
如果 (单选框3.选中 ＝ 真)
最大号码 ＝ 100
否则
如果结束
如果结束
如果结束

㈡、再讲讲怎样评价你的计算结果。

该子程序分别设置了加、减、乘、除四种运算情况，我们以“减法”为例说明：

如果 (标签3.标题 ＝ “-”)
※当选择为减法运算时。选择不同的运算方式，该标签的标题就发生相应变化
如果 (变量1 ＞ 变量2)
※当减数大于被减数时
如果 (变量3 ＝ 变量1 － 变量2)
※当运算结果正确时
标签7.可视 ＝ 真
※该标签的标题是“正确”
标签2.标题 ＝ “恭喜你！做对了”
标签5.标题 ＝ 到文本 (变量4 ＋ 1)
※显示正确的次数，变量4存放的是正确次数，为静态短整数型容器，静态容器能将正确次数保留到下次运算，数值型数据的默认值为0
变量4 ＝ 变量4 ＋ 1
※给变量4赋值
否则 ※当运算结果错误时
标签2.标题 ＝ “错啦！重做一遍”
标签8.可视 ＝ 真
※该标签的标题是“错误”
标签6.标题 ＝ 到文本 (变量5 ＋ 1)
变量5 ＝ 变量5 ＋ 1
如果结束
变量6 ＝ 变量4 ＋ 变量5
※赋值于变量6 ，表示运算次数的总和，即正确次数与错误次数之和
标签13.可视 ＝ 真
※该标签的标题是“共计”
标签12.标题 ＝ 到文本 (变量4 ＋ 变量5)
标签9.标题 ＝ 到文本 (取整 (变量4 ÷ 变量6 × 100))
标签11.可视 ＝ 真
※该标签的标题是“正确率”
标签10.可视 ＝ 真
※该标签的标题是“ %”
否则
标签2.标题 ＝ “不能相减”
※当减数小于被减数时
如果结束

上面是以减法的实现为例对该软件功能实现作一说明，整个窗口1的程序如下：

窗口程序集：窗口程序集2

程序集容器：最小号码 数据类型：短整数型
程序集容器：最大号码 数据类型：短整数型

------------------------------

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

局部容器：变量1 数据类型：短整数型
局部容器：变量2 数据类型：短整数型
局部容器：变量3 数据类型：短整数型
局部容器：变量4 数据类型：短整数型 <静态>
局部容器：变量5 数据类型：短整数型 <静态>
局部容器：变量6 数据类型：整数型

变量1 ＝ 文本到数值 (编辑框1.内容)
变量2 ＝ 文本到数值 (编辑框2.内容)
变量3 ＝ 文本到数值 (编辑框3.内容)
编辑框3.获取焦点 ()
如果 (标签3.标题 ＝ “+”)
如果 (变量3 ＝ 变量1 ＋ 变量2)
标签7.可视 ＝ 真
标签2.标题 ＝ “恭喜你！做对了”
标签5.标题 ＝ 到文本 (变量4 ＋ 1)
变量4 ＝ 变量4 ＋ 1
否则
标签2.标题 ＝ “错啦！重算一遍”
标签8.可视 ＝ 真
标签6.标题 ＝ 到文本 (变量5 ＋ 1)
变量5 ＝ 变量5 ＋ 1
如果结束
变量6 ＝ 变量4 ＋ 变量5
标签13.可视 ＝ 真
标签12.标题 ＝ 到文本 (变量4 ＋ 变量5)
标签9.标题 ＝ 到文本 (取整 (变量4 ÷ 变量6 × 100))
标签11.可视 ＝ 真
标签10.可视 ＝ 真
否则
如果 (标签3.标题 ＝ “-”)
如果 (变量1 ＞ 变量2)
如果 (变量3 ＝ 变量1 － 变量2)
标签7.可视 ＝ 真
标签2.标题 ＝ “恭喜你！做对了”
标签5.标题 ＝ 到文本 (变量4 ＋ 1)
变量4 ＝ 变量4 ＋ 1
否则
标签2.标题 ＝ “错啦！重做一遍”
标签8.可视 ＝ 真
标签6.标题 ＝ 到文本 (变量5 ＋ 1)
变量5 ＝ 变量5 ＋ 1
如果结束
变量6 ＝ 变量4 ＋ 变量5
标签13.可视 ＝ 真
标签12.标题 ＝ 到文本 (变量4 ＋ 变量5)
标签9.标题 ＝ 到文本 (取整 (变量4 ÷ 变量6 × 100))
标签11.可视 ＝ 真
标签10.可视 ＝ 真
否则
标签2.标题 ＝ “不能相减”
如果结束
否则
如果 (标签3.标题 ＝ “×”)
如果 (变量3 ＝ 变量1 × 变量2)
标签7.可视 ＝ 真
标签2.标题 ＝ “恭喜你！做对了”
标签5.标题 ＝ 到文本 (变量4 ＋ 1)
变量4 ＝ 变量4 ＋ 1
否则
标签2.标题 ＝ “错啦！重做一遍”
标签8.可视 ＝ 真
标签6.标题 ＝ 到文本 (变量5 ＋ 1)
变量5 ＝ 变量5 ＋ 1
如果结束
变量6 ＝ 变量4 ＋ 变量5
标签13.可视 ＝ 真
标签12.标题 ＝ 到文本 (变量4 ＋ 变量5)
标签9.标题 ＝ 到文本 (取整 (变量4 ÷ 变量6 × 100))
标签11.可视 ＝ 真
标签10.可视 ＝ 真
否则
如果 (标签3.标题 ＝ “÷”)
如果 (变量2 ≠ 0)
如果 (变量3 ＝ 变量1 ÷ 变量2)
标签7.可视 ＝ 真
标签2.标题 ＝ “恭喜你！做对了”
标签5.标题 ＝ 到文本 (变量4 ＋ 1)
变量4 ＝ 变量4 ＋ 1
否则
信息框 (“错啦！重做一遍”, #错误图标, “错误”)
标签8.可视 ＝ 真
标签6.标题 ＝ 到文本 (变量5 ＋ 1)
变量5 ＝ 变量5 ＋ 1
如果结束
变量6 ＝ 变量4 ＋ 变量5
标签13.可视 ＝ 真
标签12.标题 ＝ 到文本 (变量4 ＋ 变量5)
标签9.标题 ＝ 到文本 (取整 (变量4 ÷ 变量6 × 100))
标签11.可视 ＝ 真
标签10.可视 ＝ 真
否则
信息框 (“除数不能为0”, #错误图标, “错误”)
如果结束
否则
如果结束
如果结束
如果结束
如果结束

------------------------------

子程序：_按钮7_被单击

销毁 ()

------------------------------

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

标签3.标题 ＝ “+”
标签1.标题 ＝ “加法运算”
编辑框3.获取焦点 ()

------------------------------

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

标签3.标题 ＝ “-”
标签1.标题 ＝ “减法运算”
编辑框3.获取焦点 ()

------------------------------

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

标签3.标题 ＝ “×”
标签1.标题 ＝ “乘法运算”
编辑框3.获取焦点 ()

------------------------------

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

标签3.标题 ＝ “÷”
标签1.标题 ＝ “除法运算”
编辑框3.获取焦点 ()

------------------------------

子程序：_按钮1_被单击

置随机数种子 ()
编辑框1.内容 ＝ 到文本 (取整 (取随机数 (最小号码, 最大号码)))
编辑框2.内容 ＝ 到文本 (取整 (取随机数 (最小号码, 最大号码)))
编辑框3.内容 ＝ “”
标签2.标题 ＝ “”
编辑框3.获取焦点 ()
如果 (单选框1.选中 ＝ 真)
最大号码 ＝ 10
否则
如果 (单选框2.选中 ＝ 真)
最大号码 ＝ 20
否则
如果 (单选框3.选中 ＝ 真)
最大号码 ＝ 100
否则
如果结束
如果结束
如果结束

------------------------------

子程序：_窗口1_创建完毕

编辑框1.内容 ＝ “”
编辑框2.内容 ＝ “”
编辑框3.内容 ＝ “”
单选框1.选中 ＝ 真
最小号码 ＝ 1
编辑框3.获取焦点 ()

------------------------------

子程序：_按钮8_被单击

载入 (窗口2, , 假)
窗口1.可视 ＝ 假

--------------------------------------------------------------------------------
交流附件上传地址：http://www.91asp.com/


[这个贴子最后由bb88在 2002/04/26 08:32pm 编辑]

   我们进行网络通讯编程常常要获取自己或对方的网络地址（IP），比如通过IP连接进行网络对战游戏，或通过IP连接的聊天室，都要知道主机方（建立游戏或聊天室的一方）的IP才能连接，就象你给对方打电话要知道对方的电话号码才能通话一样。假如你是主机方，你先要告诉对方你的IP，对方才能进入你的主机。怎样即时显示自己的IP而免去查找的麻烦？看看下面的解答。
    要实现显示自己IP的功能只需一个子程序，程序示例如下：

              子程序：__启动窗口_创建完毕
              标签1.标题 ＝ “欢迎你登陆bb88的IP获取教程，你的主机名是：” ＋ #换行符 ＋ 到文本 (取主机名 ()) ＋ #换行符 ＋ #换行符 ＋ “你的IP是：” ＋ #换行符 ＋ 到文本 (转换为IP地址 (取主机名 ()))

   解析：⑴、画一个标签用来显示你的主机名及IP地址。用载入启动窗口作为该子程序的驱动事件（_启动窗口_创建完毕）。
         ⑵、易语言关于网络通讯的命令只有四个：取主机名、通信测试、转换为主机名、转换为IP地址，本例程用到其中两个命令。
         ⑶、取主机名——即返回本机的主机名，用作在网络通讯中标志本机地址。语法：  取主机名 （）。该命令参数为空，若有参数，可能会类似这样：“取主机名（主机）”或“取主机名 （202.103.113.8）”，即该命令处理的数据对象是某个主机，用“取主机名”的方式进行处理。
         ⑷、转换为IP地址——即将指定的主机名转换为其 IP 地址。如果失败返回空文本。语法：转换为IP地址 （欲转换主机名）。我们要先获得你的主机名才能转换，所以该语句为：转换为IP地址 （取主机名 （））。该命令所处理的数据对象（参数）为“所取得的主机名”（即“取主机名 （）”的返回值），用“转换为IP地址”方式处理该参数。

   思考题：⑴、假设你已经知道你的主机名叫“huhuhu”，为什么用“标签1.标题 ＝ 到文本 (转换为IP地址 (到文本 (huhuhu)))”却不能获得你的IP地址？欢迎高手菜鸟作答。
   ⑵、为什么“取主机名 （）”这个命令的参数为空？

--------------------------------------------------------------------------------
交流附件上传地址：http://www.91asp.com/


[这个贴子最后由bb88在 2002/04/27 07:09pm 编辑]

 ★、例程来源。

 ㈠、例程名称：小小闹钟
 ㈡、下载地址：
 ㈢、作者：（请作者跟贴说明）
 ㈣、主页：

 ★、例程详解。

 ㈠、主要功能。⑴、设定闹钟铃响时间。⑵、显示剩余时间（现时间离闹钟铃响时间的间隔）。⑶、到设定的时间时闹钟铃响。
 ㈡、功能实现。
     ⑴、设定闹钟铃响时间。分别建立时、分、秒和开始这四个窗口程序集容器，分别用来存放设定闹钟铃响时间中的时、分、秒和开始计时的状态。用下面的子程序来设定闹钟铃响时间（即分别给三个变量“时”、“分”、“秒”赋值）。

       子程序：_时编辑框_内容被改变
       时 ＝ 文本到数值 (时编辑框.内容)
       ------------------------------
      子程序：_分编辑框_内容被改变
      分 ＝ 文本到数值 (分编辑框.内容)
      ------------------------------
      子程序：_秒编辑框_内容被改变
      秒 ＝ 文本到数值 (秒编辑框.内容)

     ⑵、显示剩余时间。

       子程序：_时钟1_周期事件
       如果真 (开始)
           开始计时 ()
           剩余时间显示标签.标题 ＝ 到文本 ((取时间部分 (取现行时间 (), #小时) － 时) × -1) ＋ “时” ＋ 到文本 ((取时间部分 (取现行时间 (), #分钟) － 分) × -1) ＋ “分” ＋ 到文本 ((取时间部分 (取现行时间 (), #秒) － 秒) × -1) ＋ “秒”
       如果真结束

    ※变量“开始”表示按下了“确认按钮”（确定闹钟铃响时间和开始计时）。“如果真 (开始)”的意义等同于“如果真 (开始=真)”。
    ※显示剩余时间（现时间离闹钟铃响时间的间隔）好象这样也行：

           剩余时间显示标签.标题 ＝ 到文本 (时 － 取时间部分 (取现行时间 (), #小时)) ＋ “时” ＋ 到文本 (分 － 取时间部分 (取现行时间 (), #分钟)) ＋ “分” ＋ 到文本 (秒 － 取时间部分 (取现行时间 (), #秒)) ＋ “秒”

     ※我的数学基础很差，不知以上代码行不？望原作者给予解答。

    ⑶、到设定的时间时闹钟铃响。

       子程序：_确认按钮_被单击

       如果 (时 ≤ 60 且 分 ≤ 60 且 秒 ≤ 60)
           如果 (时 ≥ 取时间部分 (取现行时间 (), #小时))
               时编辑框.禁止 ＝ 真
               分编辑框.禁止 ＝ 真
               秒编辑框.禁止 ＝ 真
               确认按钮.禁止 ＝ 真   ※以上使确定闹钟铃响时间的编辑框不可以输入
               开始计时 ()           ※调用“开始计时”子程序
               开始 ＝ 真            ※表示按下了“确认”按钮，使系统开始计算剩余时间
           否则
               信息框 (“错误！输入时间小于当前时间！”, #确认钮, “错误！”)
                   ※排除闹钟铃响的过期时间
           如果结束
       否则
           信息框 (“请确认输入时间不得大于60！”, #确认钮, “错误！”)
                   ※排除输入错误的时间
       如果结束
       ------------------------------
       子程序：开始计时
       如果真 (取时间部分 (取现行时间 (), #小时) ≥ 时)
           如果真 (取时间部分 (取现行时间 (), #分钟) ≥ 分)
               如果真 (取时间部分 (取现行时间 (), #秒) ≥ 秒)
                   时编辑框.禁止 ＝ 假
                   分编辑框.禁止 ＝ 假
                   秒编辑框.禁止 ＝ 假
                   确认按钮.禁止 ＝ 假
                   开始 ＝ 假
                   _启动窗口.位置 ＝ 1
                   _启动窗口.总在最前 ＝ 假
                   鸣叫 ()
                   信息框 (“请注意！您所定的时间到了！”, #确认钮, “时间到了！”)
               如果真结束
           如果真结束
       如果真结束
       返回 ()

     ※以上“开始计时”设定当时间到期时闹钟响铃，通过调用“鸣叫”系统处理命令（通过计算机媒体设备或者喇叭发出一个声音）来表示，或者也可以通过调用一个模拟铃声的声音资源来表示。

  ㈢、该小小闹钟的完整源程序如下：

       窗口程序集：窗口程序集1

程序集容器：时    数据类型：整数型
程序集容器：分    数据类型：整数型
程序集容器：秒    数据类型：整数型
程序集容器：开始  数据类型：逻辑型

------------------------------

子程序：_时钟1_周期事件

当前时间标签.标题 ＝ “当前时间为：” ＋ 时间到文本 (取现行时间 (), )
如果真 (开始)
   开始计时 ()
   剩余时间显示标签.标题 ＝ 到文本 (时 － 取时间部分 (取现行时间 (), #小时)) ＋ “时” ＋ 到文本 (分 － 取时间部分 (取现行时间 (), #分钟)) ＋ “分” ＋ 到文本 (秒 － 取时间部分 (取现行时间 (), #秒)) ＋ “秒”
如果真结束

------------------------------

子程序：_时编辑框_内容被改变

时 ＝ 文本到数值 (时编辑框.内容)

------------------------------

子程序：_分编辑框_内容被改变

分 ＝ 文本到数值 (分编辑框.内容)

------------------------------

子程序：_秒编辑框_内容被改变

秒 ＝ 文本到数值 (秒编辑框.内容)

------------------------------

子程序：_确认按钮_被单击

如果 (时 ≤ 60 且 分 ≤ 60 且 秒 ≤ 60)
   如果 (时 ≥ 取时间部分 (取现行时间 (), #小时))
       时编辑框.禁止 ＝ 真
       分编辑框.禁止 ＝ 真
       秒编辑框.禁止 ＝ 真
       确认按钮.禁止 ＝ 真
       开始计时 ()
       开始 ＝ 真
   否则
       信息框 (“错误！输入时间小于当前时间！”, #确认钮, “错误！”)
   如果结束
否则
   信息框 (“请确认输入时间不得大于60！”, #确认钮, “错误！”)
如果结束

------------------------------

子程序：_更改按钮_被单击

确认按钮.禁止 ＝ 假
时编辑框.禁止 ＝ 假
分编辑框.禁止 ＝ 假
秒编辑框.禁止 ＝ 假
_启动窗口.位置 ＝ 1
_启动窗口.总在最前 ＝ 假

------------------------------

子程序：_退出按钮_被单击

结束 ()

------------------------------

子程序：开始计时

如果真 (取时间部分 (取现行时间 (), #小时) ≥ 时)
   如果真 (取时间部分 (取现行时间 (), #分钟) ≥ 分)
       如果真 (取时间部分 (取现行时间 (), #秒) ≥ 秒)
           时编辑框.禁止 ＝ 假
           分编辑框.禁止 ＝ 假
           秒编辑框.禁止 ＝ 假
           确认按钮.禁止 ＝ 假
           开始 ＝ 假
           _启动窗口.位置 ＝ 1
           _启动窗口.总在最前 ＝ 假
           鸣叫 ()
           信息框 (“请注意！您所定的时间到了！”, #确认钮, “时间到了！”)
       如果真结束
   如果真结束
如果真结束
返回 ()


[问题解答]什么叫赋值？

   解答一：这...学易这么久，还真没认真考虑过这个问题，好像是把一个常量定义给一个变量吧，就像方程式中的 令X=10 ...
   解答二：“属性”即事物的性质，“属性值”即事物性质的具体表现，比如“颜色”是事物的性质（即“属性”），而“红色”是“颜色”这个属性中的一种属性值，我们知道，“红色”是系统中的一种常量值，它的颜色属性值是“255”，也可以表达为“#红色”。确定事物的具体性质即是确定事物的属性值（赋值），比如给你女朋友送一套红色的衣服，那么你女朋友这件衣服的属性值是“红色”。衣服.颜色=红色 ，即将衣服的颜色的属性值定（赋）为红色，这个行为就叫“赋值”，是“赋予属性值”的简称。
   或者可以这样理解：用代码来设置对象的属性，就称为“赋值”。
   解答三：呵，其实就是把一个东西放进一个空的箱子里的过程。


要理解什么叫“返回值”，要先从对象的方法或系统的命令的含义着手理解。所谓对象的方法或系统的命令可以理解为对所提供的相关数据（即参数：提供给系统处理的一种变量）进行的处理（运算）。
    不同的方法或命令有不同的处理方式，比如“载入 （窗口1，，假）”，是对“窗口1”这个已赋值参数用载入的方式进行处理，又如“相加 （被加数，加数）”是对“被加数”和“加数”两个数据用相加的运算方式处理。
    有处理结果或运算结果（即能返回一个值）的系统命令我们就称为函数。“返回”即“处理”，“返回值”即对函数参数的处理结果。
    系统命令也可以称为系统函数，因为它有返回值。比如信息框函数的返回值有以下几个常量值：
    0、#确认钮； 1、#取消钮； 2、#放弃钮； 3、#重试钮； 4、#忽略钮； 5、#是钮； 6、#否钮
    比如当我们按下“确认钮”时，信息框函数值为0；若按下“取消钮”，信息框函数值为1......依此类推。


谈谈返回值
    Y=f(X1,X2,...Xn)表达了一个函数关系，如果将X1,X2,...Xn看作参数，f看作过程或算法，那么Y就是结果或是返回值。任何一个过程都有它的结果，函数、子程序、以及事件都是一个过程，理论上都有其返回值，而返回值又是另一个过程的判据。
    最有意思的是返回值的传送常常困扰着我们，前不久有个易友提出如何控制小数点问题，是西风帮助解决了，最近我也遇到了类似的问题，最后归纳起来：都是返回值问题。即使已有一知半解，还常常被其击倒。

    问题如下：道具：一个窗口，一个编辑框，一个按钮

子程序：_编辑框1_按下某键
返回值类型：逻辑型

参数：键代码 数据类型：整数型
参数：功能键状态 数据类型：整数型

局部容器：容器1 数据类型：整数型

如果真 (键代码 ＝ 32)
编辑框1.内容 ＝ “”
编辑框1.可视 ＝ 假
计次循环首 (1280, 容器1)
编辑框1.加入文本 (“:” ＋ 到文本 (容器1) ＋ “:” ＋ #换行符)
计次循环尾 ()
编辑框1.可视 ＝ 真
编辑框1.获取焦点 ()
编辑框1.起始选择位置 ＝ 3

如果真结束

    想让光标处于:1:之后，可怎么运行，光标都在第四个位置，以为是BUG来了，其实不然，易语言的BUG不是那么容易被你发现的。究竟是怎么回事，换另一种方法试试：改由＿启动窗口＿按下某键，后面的一切照旧，问题没有了，这就说明不是BUG。仔细地思考忽然想到键代码＝32不是空格键吗，空格键下按后光标是一定要向右走一步的（一个半角字符的位置），就是说光标原来已在“:1:”后，又由于空格键操作的原因，向右多移了一个字符的位置。那为什么编辑框＿按下某键会有这个结果呢，是因为空格键操作的结果传递给窗口没有什么影响，而传递给编辑框（当然是获得了焦点的编辑框）就大不一样了。简而言之就是空格键的操作结果影响了光标的移动，要知道，事件驱动的结果只有返回给编辑框，光标才会做出响应，如果不让其返回问题不就解决了吗！于是就在程序的最后加上一句“返回（假）”。

   再如：用鼠标点击编辑框后，选中编辑框中所有的文本，程序如下

子程序：_编辑框1_鼠标左键被按下
返回值类型：逻辑型

参数：横向位置 数据类型：整数型
参数：纵向位置 数据类型：整数型
参数：功能键状态 数据类型：整数型

编辑框1.被选择字符数 ＝ -1
编辑框1.起始选择位置 ＝ 0
返回 (假)
    如果不返回假就怎么也不会选中框内的所有字符，因为本来是执行了选中所有字符的命令的，但鼠标左键按下后，编辑框又获得了焦点，就使选中后的光珊又被去掉了，变成了光标在闪动的结果，而返回假就去掉了这后一步的动作，实现了选中所有字符的目标。

    由此回想起小数点问题也是某键按下的驱动事件，当你判断出前面已经有小数点存在的时候，小数点键码再次按下时返回为假就可以了。影响的过程总是先有事件后有响应，事件之后切断消息的传递就可以了。
    在面向对象的程序结构中，总是一个事件连接着另一个事件，每一个事件都会有一个结果，这个结果有时也会产生负作用，当你利用一个事件的某一方面时，却忽略了另一个方面，最终受另一个方面的困扰，你应经常要想到这个事件会产生什么后果，对你的预定目标有没有影响，多一个想法也许会给你带来福音！


谈谈容器
    容器在程序中是最重要的角色，具有载数和传数的功能，对容器赋值正是对内存中某一个地址单元赋值。容器1，容器2，就是两个不同的地址单元，唯一不透明的地方就是不知道是哪一个地址，这正是高级语言的特色，可以脱离具体的硬件进行操作。
   容器的工作对象具有分工：有的可以载数值，有的可以载文本，有的可以载字节集等。
    容器的工作范围也有划分：如全局容器，就象长途汽车，是跑长途的，在整个程序中都适用；程序集容器就是跑中途的，只能在一定的范围内运行，通常属于某一个窗口；而子程序容器就是跑短途的，只能在更小的范围内运行，通常属于某一个窗口单元，如跟着“按钮”打工。
    原则上全局容器和局部容器在命名上最好不重名，不过易语言是支持重名的，要在命名时进行声明。如果在子程序中命名一个容器和程序集在取名上犯冲，如大家都叫容器1，就要及时声明这是属于该子程序的，否则就会出现混乱。同一程序集下不同的子程序可以使用同名容器，不同的程序集下也可以使用同名容器，因为这里隔着一道“墙”，它们相互之间是没有影响的，或者叫：隔席不说话。
    每一个容器在投入工作前都有一个初始状态，一定要弄清楚这一点：全局容器只在打开运行程序时有一个初始的过程，程序集容器会在打开某一窗口时有一个初始过程，子程序容器只有在操作某一个对应的窗口单元时有一个初始过程，数值容器在初始化时其值为0，文本容器在初始化时其值为空等等。
   容器有静态和动态之分，这是一个重要的概念，一个容器在程序操作过程中只有一次初始化以后不再经过初始化就具有静态特征，如全局容器，可以用来在窗口之间传递数据。程序集容器就只能在同一窗口中对不同的单元操作传递数据。经常有人问如何在两个窗口之间赋值就是指的这一点。静态是相对的，全局容器相对于子窗口是静态的，程序集容器相对于同一窗口单元也是静态的，一个子程序中的容器要想具有静态特色就要进行设置。如：在一个子程序中执行　“容器1＝容器1+1　”，当再一次进入该子程序时，通常容器1＝0，如需要保留上一次的数值即带着上一次的状态进入，就要设其为静态。与些相反，在子程序中使用程序集容器时，如再一次进入子程序，只要不出该程序集，容器都有保留状态的特色，而在有一种情况下我们却不需要它这个保留，如在一个子程序中调用另一个子程序，所设定的容器将在这两个子程序中都发生作用，肯定是要使用程序集容器，而当我们每一次都需要有一个初始状态时，就只有令：容器1＝0。　　　以上这两种情况相反的使用，常常让初学的人摸不着头脑。
     进一步地看，画板，编辑框，窗口标题等都是更高层次的容器，因为都具有赋值功能，可以向其中添加文本，图片等，不过这个大容器是有很多属性的，作为容器来理解，才会将一个可执行文件作为图片资源来处理。
     编写一个大型程序一定要进行容器的命名上的管理，最好用一张纸进行纪录，以避免重复使用造成不应有的麻烦。

--------------------------------------------------------------------------------

易中的“容器”即其它语言的“变量”。
变量主要掌握以下几个概念：
一、存在性
    变量在当前是否存在。
二、可用性
    变量在当前是否可引用。
三、局部性
    就是变量以上两个特性的有效范围。

注意：
1、可用一定存在，但存在并不一定可用。如：静态变量。
2、局部性表明程序可按一定范围从大到小划分，也可以说一个程序是由许多小范围组成的一个整体。


㈠、变量（容器）的含义和作用
   变量观念是培养程序设计能力的基础，因为在程序中的数据都必须通过变量来处理，而为了处理不同的数据，必须使用不同的变量类型。为了使初学者明白变量的涵义，下面变换几个角度来阐述之。
   平时我们上街的时候，大多数人总会拎个小包或者手提袋什么的，装上点儿琐碎的东西，回家以后就取出东西来，将袋子扔到一边去。告诉你，计算机里也得用上这种小包或小袋子，把我们输入的字符串或者数值装起来，要的时候就取出来。
   易语言中的小包、小袋子就是变量，也称为容器。变量可以保存临时数据，但是变量中保存的数据在计算机关上之后就不再存在，因为它只是临时的保存，以节省内存空间。用户还可以根据需要来改变变量中的数据，但修改之前，数值是不变的。
   变量还能用来在函数或过程中传递参数（在函数或过程中需要处理的数据对象），也就是说，参数也是一种变量（但不能说变量就是参数）。见名知意，变量的值是可以改变的。所以变量也可以通俗地不准确地表述为事先（赋值之前）没有固定值的数据类型。
   简单地说，变量是用来代表某内存位置的名称，即在内存中存放未知值的所在处，您可以利用变量名称将数据临时保存到内存中；反之，也可以通过变量名称将内存中的数据取出以供我们的程序使用。
   例如，为水果铺编一个销售苹果的软件时，由于在销售实际发生之前并不知道苹果的价格和销量，因此，可以设计两个变量来保存未知数，将它们命名为“苹果价格”和“苹果销量”。每次运行程序时，用户就为这两个变量提供具体值。为了计算总的销售额，并且将结果显示在名叫“总额文本”的编辑框中，代码应该是这样的：
             总额文本.内容=苹果价格×苹果销量
   根据用户每次提供的数值，这个表达式返回不同的金额。因此，有了变量就可以设计一个算式，而不必事先知道实际的输入是多少。又如下面的算式：
             文本1长度=2000
   “文本1长度”就是一个变量的名称，计算机会自动配置“文本1长度”对应的内存位置，而上述表达式的作用是将数值2000保存到“文本1长度”对应的内存位置上。
   变量具有名字（用来引用该变量所含的值的名词）、值（该变量实际的值）和数据类型（确定变量可以存储的数据的种类，依内存大小而定）这三个要素。注意，变量和变量值是两回事，例如，我们可以设置变量“颜色”，它的值可以是“红色”、“蓝色”等等。
   变量是一种跟常量不同的数据类型（见《基本数据类型》一节），在程序中我们可以把所有元素都当成数据来处理，那么也可以把这些东西用变量来处理。比如，当“_按钮1_鼠标左键被按下”事件出现时，让“鼠标状态”这个变量的值为“1”，即：鼠标状态=1，而当“_按钮1_鼠标左键被放开”事件出现时，鼠标状态=0，于是我们就可以根据不同的事件来决定程序的运行状态，比如：

              子程序：_按钮1_鼠标位置被移动
              返回值类型：逻辑型

              参数：横向位置    数据类型：整数型
              参数：纵向位置    数据类型：整数型
              参数：功能键状态  数据类型：整数型

              如果真 (鼠标状态 ≠ 0)
                  按钮1.左边 ＝ (按钮1.左边 ＋ 横向位置) － 按钮1.宽度 ÷ 2
                  按钮1.顶边 ＝ (按钮1.顶边 ＋ 纵向位置) － 按钮1.高度 ÷ 2
              如果真结束

   上面这个子程序可以实现按钮1随按下的鼠标移动而移动。
   为了使大家进一步了解变量储存临时数据的作用，再举一例。除了用一般变量来储存临时数据，其实也可以用控件的属性（对象型变量）来储存临时数据，比如为了实现象记事簿一样可以选择是否自动换行的效果，可用下面的程序集：

        子程序：__启动窗口_尺寸被改变

        编辑框1.高度 ＝ 取用户区高度 ()
        编辑框1.宽度 ＝ 取用户区宽度 ()
            ※模拟记事本的编辑框效果
        ------------------------------

       子程序：_自动换行_被选择    ※“自动换行”是一个子菜单名称

       自动换行.选中 ＝ 取反 (自动换行.选中)
           ※ 取反：如果参数值为真则返回假，如果参数值为假则返回真。
       标签1.标题 ＝ 编辑框1.内容
       编辑框1.是否允许多行 ＝ 取反 (编辑框1.是否允许多行)
       编辑框1.内容 ＝ 标签1.标题

   在上面的“_自动换行_被选择”子程序中，用“标签1”来储存临时数据。如果我们用其他类型的变量来储存数据，就不用在程序上多加“标签1”这个控件，但要先声明该变量，如：

        子程序：_自动换行_被选择
        局部容器：编辑框内容    数据类型：文本型  <静态>
            ※“局部容器”即“局部变量”
        自动换行.选中 ＝ 取反 (自动换行.选中)
        编辑框内容 ＝ 编辑框1.内容
        编辑框1.是否允许多行 ＝ 取反 (编辑框1.是否允许多行)
        编辑框1.内容 ＝ 编辑框内容

   上面两个例程下载：1、http://www.ccfly.com/leoboard/non-cgi/usr/13/13_147.e
   2、http://www.ccfly.com/leoboard/non-cgi/usr/1/1_4698_10.e


㈡、变量（容器）的数据类型
   在易语言中提供了多种数据类型，以供用户在编写代码时使用。一般常用的是：数值型、文本型（字符型）、逻辑型（布尔型）和对象型。其实各种类型各有所长，我们在编程时应根据具体需要来决定所定义的变量类型。一般来说数值型变量存放数字，文本型变量存放文本。
   变量所占用的内存大小根据变量的数据类型而定，依照变量中保存数据的特性，可概括分为：

                                  ┌—字节型变量
                                  │  整数型变量
                                  │  短整数型变量
                  ┌—数值型变量—│  长整数型变量
                  │              │  小数型变量
                  │              └—双精度小数型变量
                  │  文本型变量
                  │　逻辑型变量（布尔型变量）
    变量（容器）—│　日期时间型变量
                  │　字节集型变量
                  │　子程序指针型变量
                  │
                  │               ┌—窗口
                  └—对象型变量 —│  编辑框
                                   │  图片框
                                   │  ......
                                   │  菜单
                                   └—字体

   以下是一些变量的声明（建立容器）与初值赋值实例：

   ⑴、数值型变量。
   数值型变量依字节的长度分为字节型、整数型、小数型等等。数值型变量应用如：

          容器1=3.1456289

   ⑵、文本型变量。
   所谓文本（字符串）是指由字母、数字、汉字或标点符号所组成的一串字符集合。文本型数据必须存放在文本型变量中，而表示文本时，必须在文本的前后使用双引号（“）。
   初学者常常会忘记在文本前后加双引号，就会出现错误。比如你建立一个叫“文本a”的文本型变量，如果你这样赋值的话：文本a ＝ 2.147483647568，运行时会出现错误提示：

    “错误(20026): 现行容器或参数的数据类型与传递给它的数据的类型不一致”。

           文本型变量的正确写入方法如下面的例子：

           文本a ＝ “2.147483647568”
           文本1=“abc”
           文本2=“新年快乐！”
           文本3=“祖国，您好！”

   在文本中可以连接特殊字符，如换行符、空格等。下面是使用特殊字符的例子：

           内容1=“你选择的数值是：”+ 到文本（数值1 ） + #换行符 +“你要说的话是：”+ #左引号 +“祖国，您好！” + #右引号 +“。”

   上面语句中的“+”号在易语言中是一个连接符号，即将相同类型的数据连接起来。其中的“数值1”是数值型变量，为了使赋值数据与被赋值变量之间的类型一致，就要把上例的“数值1”转化为文本型，否则就会有出错提示。

   在易语言中，文本中的空格符用“        ”之类表示。

   ⑶、逻辑型变量。
   逻辑型数据是一种只有“真”和“假”两种状态的数据类型，这种数据类型通常使用与逻辑判断运算中，例如下例中的“清除”是逻辑型变量：

         如果（清除=真） 则
             清除=假
             文本=“0”
         否则
             清除=真
         结束如果

   ⑷、对象型变量。
   对象可以说是一群属性的集合，每一个属性都有一个名称（name）和数值（value），属性的数据类型可以是前面介绍的任何一种。
   由于对象型变量比较特殊，我们在界面上画上一个控件就表示该控件的各种属性变量已被建立，所以不用再另外建立容器来存放这种变量。
   表示对象的某一属性时使用点“.”符号，例如：

       编辑框1.内容=标签1.标题
       编辑框2.内容=“100”
       编辑框3.左边=100
       窗口1.可视=真
       哈哈哈=按钮1         ※先将“哈哈哈”定义为按钮型变量（对象型变量），再赋值为“按钮1”。
   从对象的各种属性值事先未知这一点来说，对象的属性就是一种变量，属性值也即是变量值。

--------------------------------------------------------------------------------


㈢、变量的声明和赋值

   ★、变量的声明（容器的建立）
   为了使用变量，需要为变量指定一个名称和规定该变量所保存的数据类型，有时要确认是否为静态容器、是否数组容器，以便将变量事先通知程序，这项工作称为声明变量，又称建立容器。易语言强制必须声明变量后才能使用变量（对象型变量除外）。如果没有经过声明就使用该变量，比如：容器1=“100”（容器1还没有被建立），那么使用该容器的代码行就会无法确认， 并出现“编译错误”提示框：
            “找不到指定的容器名称：容器1”
   ⑴、那么怎样建立容器呢？ 分几种以下情况：
   ①、建立局部容器（又称子程序容器，即局部变量）。
   第一种方法：在代码编辑区选中子程序，再选菜单“插入→新局部容器”，就会在该子程序下出现一个空的容器表格，在“容器名”一栏填上你需要的任意名称，再填上数据类型，其余的“静态”、“数组”、“备注”等根据情况而定。容器的表格内容相当于VB中的“Dim 变量名 As 变量类型”这个语句。
   第二种方法：在代码编辑区选中子程序，按下 Ctrl + L 加入一个空容器，再添加容器内容。
   ②、建立程序集容器。
   在代码编辑区选中程序集，然后按[Enter]键。
   ③、建立全局容器。
   选菜单“插入→新全局容器”，或点击“工作夹→程序子夹→全局容器”。
   ⑵、容器的命名规则。
   我们既可以给变量起一个任意的名称，也可以在变量中存放任何想要存放的东西。但是如果用户在一个名为“电话”的变量中存放一个人的生日代码，显然是不明智的。
   这里我们提醒同学们，为了方便起见，变量名应该代表存放在其中的数据信息。比如说，变量名“电话”一般用来存放电话号码，变量名“生意”应该存放做生意的名称等。
   在给变量命名时必须遵守一些规则，否则易语言系统会大发脾气，不确认你的命名，并教训你 ，如：
         错误⑴:指定名称“容器（）”无效，名称首字符必须为全半角字母或汉字，其他字符必须为全半角字母、全半角数字或汉字

   ★、容器的赋值
   ⑴、赋值的含义。
   当声明了一个变量后，就必须对它进行赋值，因为声明变量时只是建立了一个空的容器，还要向里面添加东西。容器的赋值就象前面描述的是用“=”号来实现的，变量名放在“=”号的左边，表达式（所赋予的具体数据值）放在右边，其目的是将表达式的结果(返回值）赋给左边的变量。
   赋值就是为了方便而把一些在程序中经常用到的数据放到一个或多个空的容器（变量）中的过程，这个过程就叫赋值。初学者可能还不太明白这个“赋值”的含义，那么下面再变换几个角度来理解。
   比如“颜色”是变量，而“红色”是“颜色”这个变量中的一种具体值，我们知道，“红色”是系统中的一种常量值，它的颜色值是“255”，也可以表达为“#红色”。确定变量的具体数值即是赋值，比如给你女朋友送一套红色的衣服，那么你女朋友这件衣服的颜色值是“红色”，衣服.颜色=#红色 ，即将衣服的颜色值定（赋）为红色，这个行为就叫“赋值”。
   或者可以这样理解：用代码来设置变量值（包括对象属性值），就称为“赋值”。 就像你原来读小学，现在读中学了，你这个人“学历”的变量值就由“小学”被赋为“中学”了。
   ⑵、容器的初始赋值（初始化）。
   在易语言中，所有类型变量在程序被启动运行前，所有非静态局部容器在其所处子程序被开始执行前，都将被自动分配空间并初始化，也即是在声明变量的同时系统将自动赋给变量一个固定的相应的初始值。对于严格的程序设计来说，必须清楚所有类型变量的赋值状态，否则可能会导致不可预料的结果。
   对于不同数据类型的变量，易语言给出的初始值是不同的。其中，数值型容器被初始化为零，逻辑型容器被初始化为假，日期时间型容器被初始化为 1899 年 12 月 30 日 0 时 0 分 0 秒，文本型容器被初始化为空文本（“”），字节集型容器被初始化为空字节集，子程序指针型容器被初始化为空子程序指针。
   ⑶、赋值规则。
   赋值规则可以归结为“类型要一致”：①、赋值式两边的数据类型必须匹配；②、用于相加的多个变量，它们的类型也必须匹配；③、就象上面所说，为了在赋值式中区别文本型数据和数值型数据，表示文本型数据的内容要用“”号括起来。
   一般来说，容器内仅能被写入类型与容器本身数据类型一致的数据。譬如：将一个整数写入到整数型容器中，将一段文本写入到文本型容器中等。比较特殊的是：任意数值类型的数据可以被写入到任意数值类型的容器中，系统将自动进行转换。譬如将一个短整数写入到整数型容器中，将一个整数写入到小数型容器中等等，但是此时必须注意防止下面所提到的溢出问题。
   打个比方，在炸炒米的机器里放入大米就是“赋值”。没有大米，整个过程就会是无米之炸，巧妇也难为啊。当大米炸好后得到米花，那可就是“返回值”（处理结果）了。 在炸炒米机里可不能放入大白菜哦，这就是是所谓的类型匹配。如果不匹配，就会产生下面的错误表现：
   ①、容器溢出。比如下面的子程序：

            子程序：_按钮1_被单击
            局部容器：数值容器   数据类型：短整数型

            数值容器 ＝ 100
            数值容器 ＝ 数值容器 ＋ 50000
            编辑框1.内容 ＝ 到文本 (数值容器)

   我们知道，100＋50000=50100，但是为什么执行上面的子程序后，编辑框的内容却是“-15436”呢？这就是我们上面中所说的溢出。因为，“数值容器”的数据类型被我们定义为短整数型，所以系统仅为此容器分配了一个短整数的存储空间，据上面所述，短整数型数值的最大值为 32767，而结果值 50100大于了此数值，导致系统为容器1所分配的存储空间不能容纳该数值，部分数据被丢弃，从而得到了错误的结果。
   ②、程序中断。若赋值式两边的数据类型不一致，就会使程序中断并出现错误提示信息，如：
            子程序：_按钮1_被单击
            局部容器：数值容器   数据类型：短整数型

            编辑框1.内容 ＝ 数值容器

   当运行上面的程序时，会中断运行并在状态夹的提示子夹中出现错误信息并用箭头指示出错的代码行：
       “错误(20026): 现行容器或参数的数据类型与传递给它的数据的类型不一致”

   这是因为“编辑框1.内容”（现行容器或现行变量）的数据类型是文本型，而“数值容器”却是短整数型，两者类型不一致，造成程序出错并中断。若赋值式两边的数据类型不一致，就需要改变它们的类型使之匹配。对于对象的属性变量来说，由于系统给予它们固定不变的类型，如果是给对象的属性赋值，就要使“=”号右边的类型与该属性的类型一致，如上例中“编辑框1.内容”是文本型，但“数值容器”是短整数型，那么上面的赋值式要这样表达才是正确的：
         编辑框1.内容 ＝ 到文本 (数值容器)
   注意，上面的语句不能表达为：编辑框1.内容 ＝“数值容器”，否则编辑框就只会出现“数值容器”这四个字。
   又如：
         数值型容器1=文本到数值（编辑框1.内容）
         编辑框1.内容=时间到文本 （取现行时间（））
   赋值式右边相加的各个容器类型也要匹配，如：
         子程序：_按钮1_被单击
         局部容器：文本容器   数据类型：文本型

         编辑框1.内容=到文本（取代码 （文本容器，）+到文本（标签1.左边）

   好了，学习了上面的知识，你就不会再对“...类型不一致”之类的出错信息迷惑不解了。


㈣、变量的生命周期和作用范围

   台湾著名的VB专家王国荣先生说：“如果把程序比喻成人体，那么调用语句、赋值语句、条件语句、循环语句…等语句就好像人体的骨骼、器官、肌肉…等组织，而数据则像流通于其中的血液，组织一旦成形就不会改变，但血液却会到处流窜，比较不好掌握…”。
   下面我们就继续说明变量这个数据类型在程序中如何充当血液的作用的。

   ★、变量的生命周期

   我们先来看下面一个例子，这个例子是点击按钮1在编辑框1里循环变换显示0 - 5这六个数字，下面的代码无法实现这个功能，大家帮忙看看问题在哪里：

                子程序：_按钮1_被单击
                容器名：数字   类型：整数

                编辑框1.内容 = 到文本（数字）
                数字 = 数字 + 1
                如果真（数字 > 6)
                    数字 = 0
                如果真结束

   以上子程式表面看来好象没有什么问题，但每点击“按钮1”编辑框1里的内容都是“0”，这是为什么？类似这样的问题是初学者几乎都会遇到的。如果我们把“数字”这个容器修改为静态容器（选中该容器的静态属性），运行就会成功了：

                子程序：_按钮1_被单击
                容器名：数字   类型：整数  <静态>

                编辑框1.内容 = 到文本（数字）
                数字 = 数字 + 1
                如果真（数字 > 6)
                    数字 = 0
                如果真结束

   在上面这个子程序中，每点击一次按钮1，“数字”的值都会被加一并被保留，于是每次输出到编辑框1的数字就会依次递增（0，1，2，3，4，5），到5后再从0开始循环，如下：

                数字 = 0
                数字 = 1
                数字 = 2
                数字 = 3
                数字 = 4
                数字 = 5

   为什么子程式一每点击一次按钮，数字都是0，而子程序二每点击一次按钮，数字都会按要求变化？其关键在于静态容器和非静态容器的生命周期不同。

   ⑴、静态容器和非静态容器

   所谓静态，就是静止存在，当所处子程序退出时，此类容器能够保留住现行内容以供下次继续使用。静态容器的最重要的特性是当子程序执行到最后时，变量所占用的内存不会被释放，而变量值一直保留着，直到程序被退出。
   而非静态的容器就不能，下次进入子程序时它将被重新初始化（比如整数型变量的初始值是0），例程一中的语句 “数字 ＝ 数字 ＋ 1 ”根本没有任何作用，这就是为什么非静态容器的内容在显示时始终为 0 的原因。非静态容器最重要的特性就是当子程序执行到最后时，变量所占用的内存就会被释放，而变量的内容也跟着消失。
   在子程序一中，“数字”的生命周期起于“编辑框1.内容 = 到文本（数字）”，结束于“如果真结束”。但是在子程序二中“数字”的生命周期却是起于程序被载入，结束于程序被载出，子程序二中的“数字”的生命周期长于子程序一中的“数字”。
   初学者可能弄不明白为什么要有静态容器和非静态容器之分，有多种理由，如：①、静态容器占用的内存资源比非静态容器多，所以能用非静态容器时就尽量不用静态容器；②、有时候变量内容需要保留，那么我们就要用到静态变量，但有时候在程序中变量的内容不需要保留，这时候如果使用静态变量同样也会出错。初学者要注意搞清什么时候要用静态容器，什么时候要用非静态容器，正如上面的例子一样。我们可以把上面例子作为静态容器应用的例程。

   ⑵、程序集容器

   在上面的循环显示数字的例程中，我们也可以用程序集容器来代替静态局部容器，如：

             窗口程序集名：窗口程序集1
             容器名：数字  类型：整数

   程序集容器的生命周期与静态容器相同，起于程序被载入时，灭于程序被退出时。

   ★、变量的作用范围

   无论是初学者或是专业程序员，都需要在使用变量之前，了解变量的使用范围，这是非常重要的。
   所谓变量的使用范围（作用域）是指变量所起作用的范围，即变量在代码区域的哪些部分是可用的，一旦超出了这个范围变量将不可用。易语言根据变量作用的范围大小将变量分为全局容器、程序集容器和局部容器。这三种容器的建立方法请看前面的变量声明的内容。
   ⑴、全局容器：在全局容器表内定义的容器被称为“全局容器”，可以被整个应用程序中的所有子程序使用。
   ⑵、程序集容器：在程序集容器表内定义的容器被称为“程序集容器”， 仅能够被此程序集中的所有子程序使用。
   ⑶、局部容器：在子程序容器表内定义的容器被称为“局部容器”，仅能够被此子程序所使用。
   划分变量的使用范围之所以重要，是因为我们声明变量要根据变量的作用范围而定，比如只在某子程序中使用的变量，我们就要声明为局部容器；在某窗口程序集中被两个或以上子程序应用的变量我们就声明为程序集容器；如果某变量在整个程序中都有应用，我们就声明为全局容器。
   有初学者可能会说，为什么要这么麻烦，既然全局容器在整个程序中都适用，不管三七二十一，把所有变量都声明为全局容器，这样每个子程序都可以调用这些变量，不是更方便吗？我们区分全局容器、程序集容器和局部容器也有多种原因，如：
   ①、是为了方便侦错。也就是说如果变量的定义太乱，那么当程序出错时，我们就很难查找出错之处，尤其对于大型程序来说，侦错的工作就会非常困难。
   ②、由于三种变量所占用的系统内存不一样，就会对程序的运行造成不同的影响。变量按使用范围大小排列如下：全局容器>程序集容器>局部容器。占用的内存资源也是这样：全局容器>程序集容器>局部容器。所以不到万不得已，还是用局部容器好。太多的全局变量会使程序运行缓慢，比如说循环一个有50个字段10000条记录的数据库，呵呵。所以你找一个空间来存放运行你的网页程序的时候，假如全局变量过多，有些空间商会取消你的空间。 可以说要尽量使用局部变量或者程序集变量，可以不使用变量的最好就不使用。

                                 （《变量的知识》全文完）


易语言能否建立多文档界面？就是象易语言本身的界面一样，由多个窗口共同打开在一个大窗口中，或者象网页编辑器一样在一个大窗口中有几个浮动窗口（浮动面板）。我还没有发现那个易程序用上浮动面板或多文档界面，但实际上这两者在应用程序里是广泛应用的。能否用易语言来建立呢？ 冰川哥哥说：“行， 用"载入 (窗口1, _启动窗口, 假)"”这个命令。好，我们现在就先来学习建立浮动面板。

 ㈠、首先我们配合易语言里的知识库来学习。运行易语言知识库（在帮助文件里），选“目录→参考手册首页→系统核心支持库→命令类别→其他→载入”，就进入了“载入”命令的帮助文件。我把这一页的文件复制在下面：

 “载入 命令    所属类别：其他

 ⑴、注解：载入指定的窗口，根据窗口的“可视”属性决定是否显示它。成功返回真，失败返回假。

 ⑵、语法：  （逻辑型）  载入 （欲载入的窗口，［父窗口］，是否采用对话框方式）

 ⑶、参数名及描述：
 ...①、欲载入的窗口 。
    描述：（必需的）；窗口。参数值指定欲载入的窗口。
 ...②、父窗口。
    描述：（可选的）；窗口。参数值指定欲载入窗口的父窗口，此窗口必须已经被载入。如果本参数被省略，表示无父窗口。如果窗口具有父窗口，其位置将永远位于父窗口的上面；当父窗口被关闭时，窗口将自动被关闭；当父窗口被禁止时，窗口将自动被禁止。
 ...③、是否采用对话框方式。
    描述：（必需的；）逻辑型，初始值为“真”。参数值指定用户在对被载入窗口进行操作的同时是否允许同时对其他窗口进行操作。如果本参数值为真： 1、即使被载入窗口的“可视”属性为假，在载入后也立即显示； 2、本命令一直等待到该窗口被销毁后才返回。

示例：”

  ㈡、以上就是该命令的帮助文件。我们会发现，那个示例=“”。好，我们现在就补充一个示例来学习这个命令。这个例子当然就是建立浮动面板。

  步骤一：建立有关窗口及窗口单元。
  ⑴、在启动窗口上建立一个编辑框。
  ⑵、再分别新建窗口1、窗口2、窗口3、窗口4，也分别给这四个窗口绘制一个编辑框。
  步骤二：设置有关窗口及窗口单元属性。
  ⑴、选“启动窗口”，在属性编辑区里将其边框设为普通可调边框。
  ⑵、选“编辑框1”，在属性编辑区选“是否允许多行→真”。
  ⑶、其余四个子窗口也如此设置属性。将四个窗口都设置在启动窗口（父窗口）的面积范围内，并且设置四个子窗口之间不重叠。
  步骤三：编写代码。
  ⑴、将“启动窗口”设为父窗口，其余四个窗口设为子窗口。

            子程序名：__启动窗口_创建完毕
            载入 (窗口1, _启动窗口, 假)
            载入 (窗口2, _启动窗口, 假)
            载入 (窗口3, _启动窗口, 假)
            载入 (窗口4, _启动窗口, 假)

       （上面代码的意义请参看再上面复制的帮助文件）
  ⑵、使窗口在改变大小的同时，编辑框的大小也随之改变。选“启动窗口”，在事件选择区里选事件“尺寸被改变”。

            子程序名：__启动窗口_尺寸被改变
            编辑框1.高度 ＝ 取用户区高度 ()
            编辑框1.宽度 ＝ 取用户区宽度 ()

  ⑶、其他子窗口也建立一样的子程序，代码也类似上面的，使各子窗口在改变大小的同时，编辑框的大小也随之改变。

  步骤三：调试程序。经过上面的步骤，我们建立了一个具有浮动面板的编辑区。

㈢、该程序的例子请下载：http://show4me.com/bbs/non-cgi/usr/5/5_34.e
 本课讲完了，同学们有问题在下面跟贴提出吧。好，下课！


还是把这一课作为最菜的一课吧：保存程序和生成.exe文件。

因为从易友们的提问来说，大概是这个问题最菜了。

㈠、保存程序的方法。

从菜单栏中选择“文件”菜单中的“保存”，随即屏幕上出现一个对话框。这个对话框的标题为“保存为：”。在该对话框中名称为“文件名”的输入框中输入你想要起的名字，然后单击“确定”。这时文件就被保存了，同时关闭对话框。如果你有多个文件要保存，那你就辛苦一下，多保存几次吧。
下次要用这个应用程序的时候，你可以从菜单栏中选“文件”菜单中的“打开”，然后从对话框中选择你要打开的文件，再确定一下即可。

㈡、生成.exe文件的方法。

⑴、一个独立运行的文件（指.exe文件）是不需要易语言环境的，它可以直接运行于windows和dos环境中。就是说，一个独立运行的文件就象是安装游戏时的setup.exe文件一样，只要单击它就马上安装游戏，而不必再易语言编辑环境中打开。

⑵、如果希望应用程序不必在易语言中打开，就必须把应用程序编译成.exe文件。好。让我们试一下。

从菜单栏中选“程序→编译发布版本”，弹出一个保存文件的对话框。从中输入一个你想要的文件名，再选择保存在什么地方（即保存的位置或路径），再单击“确定”。这样，一个.exe文件就形成了。
最后，你如果想看看自己的“战果”，可以进入windows的“我的电脑”或“资源管理器”中，找到该文件，然后双击文件名即可。当然，在DOS的系统提示符下键入文件名也能执行。


现在以一个实例来说明如何操作数据库。

  ㈠、寻找易语言帮助文件中的“易语言知识库→数据库应用手册”，这一页有一个数据库实例“工资表数据库”，但没有操作这个数据库的示例，现在我们就补充这个示例来学习数据库的管理。

  ㈡、创建工资表数据库。有两种创建方法：⑴、运行“结构编辑器”来创建（请看“数据库初步应用”一课）。⑵、在程序中创建。运行本课示例程序“工资表管理面板”，点击“创建‘gz’数据库”即可创建一个名叫“gz”数据库。若原来已存在gz数据库，把它删除再重新创建看看。代码如下：

   局部容器：字段表 数据类型：字段信息 数组：4

   字段表 [1].名称 ＝ “姓名”
   字段表 [1].类型 ＝ #文本型
   字段表 [1].最大文本长度 ＝ 10
   字段表 [2].名称 ＝ “工资”
   字段表 [3].名称 ＝ “扣除”
   字段表 [4].名称 ＝ “实发”
   连续赋值 (#小数型, 字段表 [2].类型, 字段表 [3].类型, 字段表 [4].类型)
   创建 (“gz”, 字段表)

   在这个子程序中，“连续赋值 (#小数型, 字段表 [2].类型, 字段表 [3].类型, 字段表 [4].类型)”的意思是把这三个字段表的类型的属性值都设为小数型。

   ㈡、添加新记录到数据库。点击“添加某个记录”按钮，切换到添加记录窗口（“窗口1”）。
   ...⑴、首先要打开数据库。代码如下：

             子程序名：_窗口1_创建完毕
             打开 (#gz数据库, , , , , , )
             置当前库 (“gz”)
   ...⑵、声明、定义容器（变量）。要使输入框的数据类型与数据表中相关字段的数据类型一致，就要建立新容器（声明变量），使两种数据类型统一起来。建立相关容器后下一步就是给这两个局部容器赋值（设置属性值），如“小数容器 ＝ 文本到数值 (编辑框2.内容)”，意思是将编辑框内容的数据类型（文本）转为数值型，以便跟字段（2）（名称为“工资”，类型为“小数”）的类型相一致，然后再将“编辑框2.内容”的属性值赋予“小数容器”。
    ...⑶通过下面的子程序来添加新记录到数据库：

          子程序名：_按钮1_被单击
          容器1 ＝ 到文本 (编辑框1.内容)
          小数容器 ＝ 文本到数值 (编辑框2.内容)
          查找 (容器1 ＝ 读 (1))      （将数据库中“姓名”的属性值传给“容器1）
          查找 (小数容器 ＝ 读 (2))
          加记录 (容器1, 小数容器)
          销毁 ()

   ㈢、删除记录、替换记录（在这个例子里是“加薪”）、查找记录的编程思路与添加记录差不多，就不一一解说。

    在“删除”子程序中用到一个循环语句：计次循环语句。目的是把数据库中的所有记录显示出来，然后从中寻找符合删除条件的记录。“计次循环首 (取记录数 (), 容器2)”的意思是循环开始，并且使循环的次数等于数据库的总记录数，“容器2”表示已循环次数记录容器，“计次循环尾 ()”表示循环结束。

   ㈣、在这个工资表管理程序里有一个个别的示例就是“添加张三到数据库”，如果数据库中已存在“张三”，把它删除再添加看看。语句是：加记录 (“张三”, 200)。 “200”表示字段2的数值（张三的工资数）。

   ㈤、在这个程序示例中，第六、七、八个按钮是读取相关记录的。试变换点击按钮六、按钮七，看看按钮八有什么变化。语句分别为：“到首记录 ()”、“到尾记录 ()”、“读 (#姓名)”。

   ㈥、本例程的查找不使用索引，不使用索引的查找记录方法类似如下：

            到首记录 ()          （如果当前记录指针在首记录上，则不需要此语句）
            判断循环首 (查找 (读 (#姓名) ≈ “王”))
            进行所需操作。
            跳过 ()
            判断循环尾 ()

    ——————例程下载：http://www.91asp.com/bbs.nsf/0/a83d8506430fc6cc48256bbf00398d2a/$FILE/gongzhi.zip


我们的应用程序经常要用到流程控制命令（比如条件语句），条件语句即“如果、、、，就、、、，否则、、、直至该流程结束”之类。这样就能使程序按照给定的指令（思路）自动运行下去，直至指令结束。比如：“如果是宝贝哥哥（bb88）来求婚，我就嫁给她，否则，免谈，over（就这样）”。这句话怎么编译成程序语言呢？是这样吧：
                 声明   变量1
                 声明   变量2
                 变量1=求婚者      （给变量赋值）
                 变量2= 回应

                 程序名：_求婚（控件）_被选择
                 读取求婚者
                 如果 求婚者=宝贝哥哥
                 则   她（标签）.回应（标题）=“啊，我嫁给你啦！”
                 否则 她.回应=“下辈子再说吧”
                 该流程结束

    好，当有人来求婚时(有人发送求婚指令),这个被求婚的MM就会识别此指令，并按照上面的程序来运行。但又不能永远运行下去，否则得不到休息，找不到运行方向，她会神经错乱（系统提示有错误，程序不能运行）。所以要指令她运行到该结束的地方结束。我是一个学编程仅只七天的极品新手，请高手帮我看看上面的代码哪里有错（好象有错）。

   如果想使程序运行长一段时间（损耗的资源也会多），那你给它的指令也复杂一点，比如“如果，就，又如果，就，否则，如果如果中又有如果，则、、、、”，最后才“如果结束”。

  题外话：在实际应用程序时，常常要多次向计算机发送不同指令。那怎样发送指令？
是不是用嘴对计算机说：“现在我向你下达一个旨意，怎样怎样”、“长江、长江，请追击敌人，over”，然后计算机说：“喳！遵旨”、“yes，黄河，yes，黄河，over”？当然不是，是通过按钮、发话框、选择框之类的控件（易语言称为窗口单元）发送命令，然后又由这些控件来执行指令的（即有些控件常用来发令，有些主要用于执行命令）。所以控件（控制部件）我们可以简单地解析为：“用来发送指令、传递指令、执行指令和反馈指令的那种东东（部件）”。所以我们不要小看按钮之类的东东，没有它程序何从运行。让我们在以后的学习中了解“按钮_被单击"、"按钮_被双击"之类的发令方式，再逐步学好如何运用控件、扩展控件。

  言归正传，现在我们通过一个例子来初步了解“如果”这个流程控制命令，这个例子就是：加口令的输入框。
  我们的应用程序常常要用户输入正确的口令才能进入。怎样做到呢？在这里做一个简单的密码登陆程序（不用输入用户名，密码正确就可进入），在这个例子里正确的登陆密码是"bb88"。

   第一步：规划程序界面。
   在启动窗口上画两个输入框（即编辑框，又称文本框），再在下方画两个按钮。

   第二步：设置对象的属性。
   ⑴、将第一个输入框设置为密码输入框。首先我们在属性窗口中找到“输入方式”这个属性，然后选“密码输入”。当然我们也可以通过代码来设置，语法是：编辑框1.输入方式 ＝ 2 。（输入方式可选的属性值分别有“0、通常方式 1、只读方式2、密码输入
3、整数文本输入 4、小数文本输入 5、输入字节 6、输入短整数 7、输入整数 8、输入长整数 9、输入小数 10、输入双精度小数 11、输入日期时间）。设置为密码输入框可以隐藏你输入的字符，加强保密性。
   ⑵、定义系统变量。变量（易语言称为“容器”）分为局部变量（只在某一子程序中应用）、程序集变量和全局变量三种。本例中有一个叫“密码”的变量在程序集1中应用（即是程序集变量），那么我们在“窗口程序集1”下面加一个叫“密码”的容器（方法是在“窗口程序集1”下面按回车键）。因为“输入框1”这个对象的数据类型为“文本型”，为使“密码”的类型跟它一致，也要把“密码”变量的类型定为文本型（这是初学者容易出错的地方）。

   第三步：编写事件过程代码。
   ⑴、先对“确定”按钮进行编码。切换到代码编辑窗后，在左边的“属性窗口”中选“支持库→流程控制→→如果”，点击“如果”将这条程序的框架加到“按钮1_被单击”子程序下面，再将下面代码填上去：

                       子程序名：_按钮1_被单击
                       密码 ＝ 编辑框1.内容
                       如果 (密码 ≠ “bb88”)
                       编辑框2.内容 ＝ “错了,再来!”
                      （否则）编辑框2.内容 ＝ “好,来吧!”（如果要登陆某个系统，可把这一句替换为“载入 (窗口1, , 真)”、“运行 (程序1, , 假)”之类）
                      （如果结束）

    ⑵、再对“清除”按钮进行编码：

                      子程序名：_按钮2_被单击
                      编辑框1.内容 ＝ “”
                      编辑框2.内容 ＝ “”

   第四步：运行程序。
   假设我们输入的口令为“BB88”，单击“确定”后，文本框2会出现提示：“错了，再来”，因为密码分大小写不同的（大小写改变时，密码就不同了）。当输入正确口令“bb88”时，系统提示：“好，来吧！”。

————————-最后本课例程下载：http://show4me.com/bbs/non-cgi/usr/5/5_36.e


 ㈠、简单讲解：就象我们想打开一个新网页，就先要建立一个新网页一样，我们要打开一个新窗口，就要先建立这个新窗口。方法是使用“插入->新窗口”菜单功能插入一个新的窗口，该窗口被系统自动命名为窗口1。当然也要对此窗口进行编辑。在两个窗口之间切换的方法：在编辑界面左边选“程序->窗口”。
㈡、主要表达式：若只在程序内打开一个新窗口，语法为：载入 (窗口1, , 假)   。若打开为一个新程序，则为：载入 (窗口1, , 真)
㈢、请在此处下载本课所编写的程序：http://show4me.com/bbs/non-cgi/usr/5/5_25.e


 ㈠、简单讲解：就象我们可以通过超链接来打开新网页一样，我们也可以在本程序里启动运行其他程序。
㈡、主要表达式：运行 (“程序路径”, 假, )  。如：运行 (“E:\易语言1.963版\China Eyuyan\eprogames.exe”, 假, ) 。
㈢、请在此处下载本课所编写的程序：http://show4me.com/bbs/non-cgi/usr/5/5_26.e


现在的编程趋势是方便至上，怎么让用户觉得方便，就怎么编。于是在程序界面上，经常会有许多栏目让用户选择，这可是让用户偷懒的一个好方法。这样，虽然程序复杂了点，但用户觉得简单了，我们设计程序的目的也就达到了。
  ㈠、控件简介。
    ⑴、选择框（复选框）。在易语言中，就提供了这样一个好东西，叫做选择框。选择框有两种状态可以选择。一种是选中了，小方框里就打上一个“√”号。这很符合我们的习惯，我们通常选中了什么东西，不就是用笔打个“√”号吗？另一种是不选状态，那么小方框里的“√”号就没有了。
    ⑵、单选框。聪明的读者想必已经猜出，有了复选框，必定有单选框。确实有，复选框是方的，单选框却是圆的。
     打个小比方，假如你要编一个程序，让用户选择国家足球队的最佳阵容，其中有守门员、后卫、前卫、前锋等几个选项栏，每一栏下有候选人让用户选择。这时，“守门员”这一栏下就只能用单选框，“后卫”、“前锋”等栏下面就能用复选框，对不对？谁也见踢足球的时候，一个门里站两个守门员的。道理就是这么简单。
    ⑶、分组框。单选框限制了我们的多重选择，但有时需要这样的限制，不然遇到像两个守门员争起来的事情，就麻烦了。可有时候又需要有多方面的选择，比如我们想为国奥队、国家队、青年队分别选一个守门员，就得在三拨人里面选三个出来，这就用到了分组框。我们先把单选框分成几组，每组用分组框分隔开，这样就能一一选择了。分组框之所以能起到分组的作用是因为它是一种包容型窗口单元（容器型控件）。

   ㈡、例程制作：字体选择。
     ⑴、例程说明：编写一个程序，允许用户选择输入字号、风格和字体。选择完毕后可即时在编辑框里显示用户所输入文字的字号、风格和字体的变化。这个实例综合了复选框、单选框和分组框的用法。
     ⑵、编程思路：本例程可供选择的字体类型有三种：字号（字体大小）、风格（字体格式）、字体名称。分别用三个分组框把三组选择内容分隔开来。“字号”一组只能选择其中一项，于是用单选框；“字体”一组也如是；“风格”一组中，可以任选其中一项或多项，所以用复选框。在编辑框的字体变化里我们要调用字体对象（系统对象，即非实体控件对象）的相关属性。
     ⑶、创作步骤：
        第一步：创建用户界面。
        ①、在窗体上创建一个编辑框、三个分组框，分组框1和分组框3各包含两个单选框，分组框2包含两个复选框。
        ②、设置对象的属性。将分组框1的标题定为“字号”，里面的两个单选框的标题分别为“18”和“24”。将分组框3的标题定为“字体”，里面的两个单选框的标题分别是“宋体”和“黑体”。将分组框2的标题定为“风格”，里面两个复选框的标题分别是“粗体”和“斜体”。
        第二步：分别对这六个单选框和复选框的事件进行编程。

             子程序：_选择框1_被单击

             如果 (选择框1.选中 ＝ 真)
                 编辑框1.字体.加粗 ＝ 真
             否则
                 编辑框1.字体.加粗 ＝ 假
             如果结束
                 ※备注：若给选择框1打上“√”号则返回（执行）“编辑框1.字体.加粗 ＝ 真”，若去掉“√”号则返回（执行）“编辑框1.字体.加粗 ＝ 假”。
             ------------------------------

             子程序：_选择框2_被单击

             如果 (选择框2.选中 ＝ 真)
                 编辑框1.字体.倾斜 ＝ 真
             否则
                 编辑框1.字体.倾斜 ＝ 假
             如果结束

             ------------------------------

             子程序：_单选框1_被单击

             编辑框1.字体.字体大小 ＝ 文本到数值 (单选框1.标题)

            ------------------------------

            子程序：_单选框2_被单击

            编辑框1.字体.字体大小 ＝ 文本到数值 (单选框2.标题)

            ------------------------------

           子程序：_单选框3_被单击

           编辑框1.字体.字体名称 ＝ 单选框3.标题

           ------------------------------

           子程序：_单选框4_被单击

           编辑框1.字体.字体名称 ＝ 单选框4.标题

     第三步：运行程序。
     运行程序时，在编辑框输入一行文字后任意选择界面上的单选框和复选框，就可以看到字体、字号、风格的变化。

         （例程下载：http://www.91asp.com/bbs.nsf/0/171c3998eeef368648256bba0061f941/$FILE/_c2fbtc4ucsk9t388jqjog_.e）


 ㈠、资料来源：不凡斋网站
㈡、程序例子：http://show4me.com/bbs/non-cgi/usr/5/5_31.e
 在许多应用软件在中，当鼠标指向工具栏上的任何一个按钮时，都会出现一个提示标签来说明该按钮的用途。在VB中，按钮控件有一个“ToolTipText”属性就是用来实现这个功能的，那么易语言中如何给按钮加上提示标签呢？下面通过实例来讲述这个方法。
在主窗体上加上三个按钮和一个标签，属性设置如下：

                  窗口单元             属性

                   按钮1          按钮1标题＝新建
                   按钮2          按钮2标题＝打开
                   按钮3          按钮3标题＝保存
                   标签1          标签1可视＝假
                                  标题＝“”（无内容）
                                  边框＝5（单线边框式）
                                  背景颜色＝黄色

设置好属性后运行程序，可以看到，标签1此时不可见。
接下来通过按钮的“鼠标位置被移动”事件将标签1移动到相应的位置、自动更改标题内容并显示出来，源码如下：

子程序：_按钮1_鼠标位置被移动
返回值类型：逻辑型

参数：横向位置 数据类型：整数型
参数：纵向位置 数据类型：整数型
参数：功能键状态 数据类型：整数型

标签1.左边 ＝ 按钮1.左边 ＋ 3
标签1.标题 ＝ “新建”
标签1.可视 ＝ 真

------------------------------

子程序：_按钮2_鼠标位置被移动
返回值类型：逻辑型

参数：横向位置 数据类型：整数型
参数：纵向位置 数据类型：整数型
参数：功能键状态 数据类型：整数型

标签1.左边 ＝ 按钮2.左边 ＋ 3
标签1.标题 ＝ “打开”
标签1.可视 ＝ 真

------------------------------

子程序：_按钮3_鼠标位置被移动
返回值类型：逻辑型

参数：横向位置 数据类型：整数型
参数：纵向位置 数据类型：整数型
参数：功能键状态 数据类型：整数型

标签1.左边 ＝ 按钮3.左边 ＋ 3
标签1.标题 ＝ “保存”
标签1.可视 ＝ 真

再次运行程序，看看效果是不是出来了？不过当鼠标移到其它地方时，标签并没有消失，接着来：

子程序：__启动窗口_鼠标位置被移动
返回值类型：逻辑型

参数：横向位置 数据类型：整数型
参数：纵向位置 数据类型：整数型
参数：功能键状态 数据类型：整数型

标签1.可视 ＝ 假

如果还有其它的窗口单元，只要按照在其“鼠标被移动”事件中将标签的可视定义为“假就”可以了。 怎么样？是不是很久简单啊？如果还有什么疑问，欢迎给我来信或到我的论坛上去提出来。


所谓最小化到系统托盘，就是既使程序隐藏，又在IE右下方（系统托盘）留下程序的图标，点击该图标可以显现该程序窗口。OICQ是典型的最小化到系统托盘的运用，当我们点击OICQ的最小化按钮时，QQ的界面被隐藏下来，但我们可以点击IE右下角的图标使它重新显现。隐藏程序的作用之一是使它不影响我们的视线，但又随时可以呼出该程序。
这里所讲的例程包括三个方面：⑴、最小化窗口；⑵、置程序图标于托盘；⑶、点击右键可以弹出托盘菜单。下面介绍如何实现这三项功能。
⑴、设置好菜单项目。关于菜单的制作，以前的某一课程有介绍。
⑵、设置要放置到托盘的图标。选“属性夹→资源表→图片”，切换到资源表编辑区，填好有关内容，比如设“图片名称”为“图片1”。点击“内容”栏，弹出图片资源属性窗口，点击“导入新图片”在文件中选择你需要放置在托盘上的图片，设置好后在“内容”栏会填上内容（如“766”）。
⑶、对最小化按钮进行编程，使窗口最小化到系统托盘。在本例中是用“按钮4”来代替最小化按钮。

         子程序：_按钮4_被单击
         _启动窗口.位置 ＝ 2           （“2”是最小化的代号）
         _启动窗口.可视 ＝ 假          （隐藏窗口或程序）
         置托盘图标 (#图片1, )         （将上面第2步所选择的图标放置到托盘）

 ⑷、设置托盘菜单。第3步已经实现最小化到托盘的功能，但我们常常会使托盘也能操作窗口的菜单。在本例中，双击鼠标左键可使窗口重新显现，单击右键会弹出菜单。程序如下：

          子程序：__启动窗口_托盘事件
          参数：操作类型    数据类型：整数型
          判断 (操作类型 ＝ #双击)
               _启动窗口.可视 ＝ 真      （使窗口重新显现）
               _启动窗口.位置 ＝ 0       （“0”即通常位置）
               置托盘图标 ()
          判断 (操作类型 ＝ #单击右键)
               弹出托盘菜单 (菜单)
             （默认）
          判断结束

以上程序中“判断”这个流程控制命令大约相当于“如果”流程控制命令，即“如果双击鼠标左键则可使窗口重新显现，如果单击右键会弹出菜单“。在“弹出托盘菜单 (菜单)”这一句中，括号里的内容是欲弹出的菜单的名称。
 本课例程下载：http://show4me.com/bbs/non-cgi/usr/5/5_30.zip


㈠、控件说明。
   滚动条、进度条和滑块条是三种功能和用法都相似的控件，都是在计算机系统中经常用到的，比如IE就是靠滚动条来显示完整的信息，还有播放系统的音量控制、播放进度等，可以说它们真是无处不在，非常有用。
   滚动条、进度条和滑块条实际上都是数值的图形化描述，即用图形来演示数字的变化。它们能表现的值可以从-32768～32767，这些数值基本上可以代表所需要的一切，比如说度量或数量。
   它们最右边的位置代表的是最大值，最左边的代表的是最小值。最大值和最小值可以在属性里区里设置，或用代码加载。
   在程序中，这三个控件最常用到的属性值是“位置”，该属性设定这三种控件的现行位置，可以用来进行一些渐变的数字处理，比如“滑块条1.位置 ＝ 滑块条1.位置 ＋ 5”。
   ㈡、程序实例：实时播放进度。

   ⑴、例程说明：本例程其实是一个最简陋的mp3播放器，只有两项功能：播放mp3音乐和用滑块条显示播放进度。
   ⑵、编程思路：本例程的难点在于显示播放进度。如果能够在开始播放时取得该文件的预计播放时间就容易了。比如我们取得一个文件的播放时间预计是100秒，假设我们设置滑块条每秒前进1个刻度，即“滑块条1.位置 ＝ 滑块条1.位置 ＋ 1”，那么该滑块条的最大位置应为100刻度，即“滑块条1.最大位置=100”，这样当音乐播放完毕，该滑块条的位置也刚好前进到最右端。
    ⑶、编程步骤：
       第一步：规划用户界面。在窗口上画一个滑块条、一个“打开”按钮、一个“播放”按钮、一个时钟控件、一个通用对话框。就这么简单。
       第二步：设置对象的属性值。基本上按照默认设置就行了。至于属性值的变化由代码加载。
       第三步：编写事件过程代码。
       ●  对“打开按钮”编程：
           子程序：_打开按钮_被单击
           通用对话框1.打开 ()
           mp3 ＝ 通用对话框1.文件名
               ※备注：该子程序用来选择打开将要播放的mp3音乐
       ●   对时钟控件编程：
           子程序：_时钟1_周期事件
           滑块条5.位置 ＝ 滑块条5.位置 ＋ 1
               ※备注：设置滑块条每周期前进1个刻度
       ●   对“播放按钮”编程：
           子程序：_播放按钮_被单击
           播放MP3 (1, mp3)
               ※备注：“1”表示播放次数为1次，mp3 ＝ 通用对话框1.文件名
           滑块条5.位置 ＝ 0
               ※备注：在播放开始时让滑块条的位置到最左端
           滑块条5.最大位置 ＝ 取文件长度 (打开文件 (mp3, 1, 1)) ÷ 16007
               ※备注：一般是每秒钟播放16007字节
           时钟1.时钟周期 ＝ 1000
               ※备注：设置每秒为一周期
       第四步：运行程序
   打开一个mp3文件并播放，观察滑块条的位置变化情况。

             （例程下载：
http://www.91asp.com/bbs.nsf/c53885e4b38488454825681f0035243d/c73de85fac5186fd48256bbc006f1a17/$FILE/_f2epaa4tnok9sld8jpaoh7ffo2ercg_.e）


㈠、简单讲解：一般的应用程序都会有“菜单”和“菜单工具栏”，比如易语言的操作界面就有“文件”、“编辑”、“查看”和“插入”等菜单。建立菜单可以精简程序界面。
 ㈡、主要步骤：
 ...⑴、在易语言菜单栏中选“编辑”，再点“G.菜单编辑器”。
 ...⑵、建立主菜单（顶层菜单）。填好“标题”和“名称”的输入框后，我们就建立了 第一个主菜单项，要建立第二个主菜单项点“向后插入”，依此类推，建立其余主菜项。
 ...⑶、建立分层的子菜单。初学者在完成步骤⑵后就按“确定”，就会出现提示：“错误（49），不能存在单独无子菜单的顶层菜单”，没有办法，我们一定要有子菜单。方法：先按照建立主菜单的方法建立某个菜单项，再点“右移”，它就会变成上一个菜单的子菜单。子菜单的显示如“...保存”之类即是（在前面有“...”号）。
 ...⑷、对菜单进行编程。比如一个标题为“运行新程序”的菜单项，它的名称（在菜单编辑器里设置）是“运行”，那你建立一个叫“_运行_被选择”的子程序。先在编辑面中选“插入→新子程序”，命名为“_运行_被选择”后，再对该子程序进行编程。又如：

                   子程序：_使用说明_被选择
                   载入 (窗口3, , 真)

  ㈢、本课程序例子：多程序启动器。该程序中有“菜单”和“帮助”两个主菜单。
      例子下载：http://www.91asp.com/bbs.nsf/0/d15f52d1a752acda48256bab001e8008/$FILE/caidang.zip


有人说，编写程序代码不是很简单吗？切换到代码编辑区，把代码填上去就行了啊。说是这么说，但真正精通还不是很简单的。如果我们精通了，就可以减少代码的编写时间，提高程序效率和工作效率，不用查来查去，或老是要引用别人的代码。还是让我们对代码的编辑多了解一些吧。

㈠、了解程序的构成及操作。

易程序由程序窗口、程序集、子程序、自定义数据类型、全局容器、DLL命令定义、常量、资源等组成。
⑴、程序窗口：分为启动窗口和其他窗口等。
操作：若要在各个窗口之间切换，可以在左边的属性区选“程序→窗口”，点击某个窗口名称可以切换（打开）到该窗口编辑界面。若要开一个新窗口，可在菜单中选“插入→新窗口”，或在左边的属性区选“程序→窗口”，再点右键插入。以下新程序、新容器、新常量等的插入与此一样。
⑵、程序集：一个程序窗口常常对应一个程序集名。比如有一个窗口叫“窗口1”，那它所对应的程序集名称为“窗口程序集1”。
⑶、子程序：是一个窗口程序集内的分程序。子程序的名称由“_对象名_事件名”构成。
对象要通过控件（窗口单元）来表现，或者说对象实际表现为某个具体的控件，而“对象名+事件名”构成一个子程序名称。
⑷、自定义数据类型。自定义数据类型分为支持库自定义数据类型（如：窗口、字体、编辑框等）和用户自定义数据类型。在程序中的任何位置，只要可以使用系统基本数据类型（如：整数型、文本型等），就可以使用自定义数据类型。所有的支持库自定义数据类型在支持库夹的“数据类型”分枝下可以找到，用户自定义数据类型由用户自行在自定义数据类型表中加入。
⑸、变量（易语言称为“容器”）分为局部变量（只在某一子程序中应用）、程序集变量和全局变量三种。在一例子中有一个叫“密码”的变量在程序集1中应用，即是程序集变量。三种变量中以全局变量损耗的资源最多，所以一般尽量避免使用。
⑹、其他程序部分。以后补充解析。

㈡、了解代码的种类及操作。

 打开易语言编辑界面，在左边有“支持库”，里面列举了多种表达式和语法，即是易语言代码的主要种类（不是全部种类）。
 若要在程序中插入某个种类的代码，可在左边是属性区选“支持库”，再点击某个代码种类，就会在代码编辑区显示该类型代码的框架。比如你想输入条件式流程控制命令，可先在要插入该代码的地方点一下左键，再选“支持库→流程控制→如果”，点“如果”后就会在代码编辑区出现该类型代码的框架，你将代码填上去就行了。

㈢、编写代码的一般思路。

⑴、确定整个程序的各个部分。首先初步确定有哪些窗口，然后初步找出有几个程序集及子程序，再分别找出有哪些变量（容器）及常量。一找全局变量，二找程序集变量，三找各子程序中有没有局部变量。然后在相关区域中插入相关变量及常量，并对数据类型确定好。
如果你缺少了哪个部分，在编写代码或调试程序时，系统会给予相关错误提示。
⑵、结合属性区设置对象的属性值。有些对象的某种属性在属性区里找不到，但有可能通过代码来设置。
⑶、运用核心支持库来编写代码。如上所说。
⑷、调试、补充、修改代码。在调试时假如出现错误，会在左下方的调试显示区有提示，并且在代码编辑区用指针指示出错的地方。虽然初学者不太明白它的错误提示的意思，但也大体能够知道出错的地方，马马虎虎知道出错的类型是子程序还是变量还是常量等。
可在菜单中选“调试”或“运行”来进行调试。
另外选中某行代码，如果在代码前有“+”号，点击“+”号可以打开该行代码的注解，你可以自己修改这注解。
另外初学者容易出现一个问题：在子程序中添加的语句怎么总是显示 “草稿”这两个字？因为它是草稿，所以不能在程序中运行。按一下回车键“草稿”两字就会消失。一般该行代码有错不能确定时，也显示为草稿。
⑸、参考或移用别人的代码来完善自己的程序。比如你将一个通讯录程序稍为改改名称或里面的文字，或是修改一下代码，就会变成一个网上留言本，或是一个办公程序，或是一个学生出勤记录，或是一个电话簿，或是一个电子影集，或是一个网页编辑器、、、、、、

 ㈣、如何复制、粘贴代码？

 对于这个来说，现在的易语言版本没有解决这个问题，但也不是没有办法的。有两法：
⑴、如果是将代码从这个编辑窗复制到另一个编辑窗，可用shift键选中要复制的部分，然后再复制粘贴到另一代码编辑窗，或者可用“全选”，再复制、粘贴该窗口所有码。
⑵、如果是要复制到其他地方（比如记事簿），在复制好后，在菜单栏中选“编辑→复制程序文本”，再粘贴到相关地方。

 -------------------该课没有程序例子。


阿猫：“什么是面向对象？常看到这个词，但就不太清楚什么意思。”
阿狗：“我也不懂，听着就是了 。”
阿牛：“就是OOP 。”
阿猪：“这样解释还不如不解释。”
阿木：“oop stands for object oriented programming。是一个编程思想。如果你是启蒙阶段，用易语言知道不如不知道。如果你想皈依程序，用Standard C++一定要知道。oop,多型，stl一个都不能少。 http://jjhou.csdn.net/这里有你想要的。 ”

阿水：“对象嘛，还不懂？所谓对象者，控件的具体表现形式也（把控件画出来放到窗口上就叫“对象”啊）。所谓面向对象嘛，就是说围绕“对象”为中心进行编程的一种方法。一般是指用具体的控件（即对象）来发出指令、接收指令、传送指令并反馈指令的一种编程方法，跟面向过程的编程方法比较，它更简单易懂。比如搞（至于怎样搞？，可以单击、双击或按下之类，“搞”即“事件”也）一下某个按钮（对象）就可以开始或结束一个程序，“搞”这个指令为某一个“事件”，点击后程序怎样运行（“移动”、“关闭”、“加入内容”之类）为“方法”，“过程”（包括结果）通常表现为对象的属性（变量或常量）的变化（如“编辑框3.内容（变为）=“bb88”）。也即说面向对象的编程方法主要是运用对象（一般表现为具体的控件，有时也不一定）的属性（实质就是变量或常量）、事件、方法（动作）和过程来完成程序的一种编程思想和方法。
比如：“宝贝哥哥穿着西装、拿着鲜花，跪下来向我求婚，我答应了”。这一“程序”中，“宝贝哥哥”和“我”都是对象（名词和宾词），“穿着西装、拿着鲜花”是宝贝哥哥的形象属性，“求婚”是事件动作（动词），“跪下来”也是是事件动作，“答应”是“我”的方法（答应()）或属性（我.答应=真）。
什么是面向过程，我还不知道，也没有见过。我只知道用面向对象的方法容易理解。易语言可以说运用的是面向对象的编程方法。在易语言中我们就经常提及“对象”，很少提到“过程”，这就是证明也。

 试举一例说明：

 子程序（VB称为“过程”）：_按钮1_被单击    (由对象名和事件名构成该名称)
 编辑框3.内容="林子森"       (将该对象的属性赋值为"林子森")
 如果(_按钮1_被单击=真)
 则  编辑框3.内容="bb88"    (该对象属性值变为"bb88")
 否则 返回                  (该对象属性值还是"林子森")

 以上例子通过"单击"事件触动"按钮1"对象发出指令,而"编辑框3"对象接收并反馈该指令,使其属性值发生变化,从而完成程序。
 再看下一例：

 子程序：_按钮1_被单击
 编辑框2.内容 ＝ 编辑框1.内容   （当单击按钮1时，把编辑框1的内容传给编辑框2）
 编辑框1.内容 ＝ “”           （然后再清空编辑框1，为下次输入内容作准备）

 在这一例中，“编辑框1”的内容属性值和“编辑框2”的内容属性值都不是固定的。没有固定值的属性我们就称为“变量”（即易语言所说的“容器”）。一般我们先要声明变量（即建立容器），以便跟常量区别开来，然后再赋予属性值（范围）。如果没有声明变量就运行程序，一般会提示：“对不起，没有找到相关容器”。就象你填履历表，如果你没有把你的属性（年龄、性别、学历等）填好填正确，上面就发下来让你重填，道理一样。
 但上面例子没有经过声明就可以赋予属性值（即“编辑框2.内容 ＝ 编辑框1.内容），这是为什么？什么时候要建立容器？什么时候不用建立容器？且听下一课分解

 本课例程下载：http://show4me.com/bbs/non-cgi/usr/5/5_40.e


㈠、本课所用程序例子：征服者多版本启动器2.0版。下载：http://show4me.com/bbs/non-cgi/usr/5/5_30.zip
 ㈡、简介：从某种意义上说，只有应用数据库的程序才算是真正的程序。我觉得桌面程序数据库的操作好象比网页数据库的操作方便得多。数据库是用来将资料信息记录下来保留到下次（或长期）用的。比如通讯录的数据库可以用来保存好友的姓名、通讯地址、电话等信息。
 ㈢、新建和编辑数据库。我们要在程序中运用数据库，就要先建立数据库。
 ...⑴、建立新数据库。运行易语言，在菜单中选“数据库→结构编辑器”来建立数据库。打开结构编辑器后填上字段信息的“名称”和“类型”等就可建立数据表的第一个字段，要建立第二个字段选“向后插入”，依此类推建立其他字段。按“保存”将新建数据库保存到程序所在目录中。从本课例子来说，是用数据库来存放三个版本程序的地址。一个简单的数据库就这样建立起来了。
 ...⑵、编辑数据库。运行易语言，在菜单中选“数据库→记录编辑器”，来添加、删除、修改各字段及各字段下的记录。就本课例子来说，就是设置好三个征服者游戏版本的地址。设置好后关闭记录编辑器就行了。
 ㈣、连接数据库。易语言连接数据库的语法非常简单。比如本课的例子，用下面的语法就可将数据库和程序连接起来：
             子程序名：__启动窗口_创建完毕
             打开 (#qidong数据库, , , , , , )
   这表示运行程序后，就可以连接一个名叫“qidong.edb”的数据库。但这还不是真正连接了数据库。还要进行其他设置。比如本课例子还要在常量表中添加数据库这个常量，方法：点程序编辑窗口左边叫“程序”的状态条，再点常量表，在常量名称中添加数据库的名称，比如qidong数据库，再定义好常量值，比如“qidong”（注意要加双引号）。
 ㈤、读取数据库。包括读取、添加、删除、修改等操作。
 ...⑴、读取。比如本课例子中，要运行某个版本的程序，可以用“运行 (读 (3), 假, )”之类的语法来读取某个版本的程序地址并运行该版本。“读 (3)”表示读取数据表中第三个字段的数据（即征服者C版的地址）。
 ...⑵、修改。本课程序有一个标题为“修改数据库”的菜单，它的名称是“修改”，于是我们建立一个叫“_修改_被选择”的子程序来修改数据库（设置三个游戏版本的地址）。语法是：
       子程序名：_修改_被选择
       编辑 （［标题］，［编辑方式］，［字段范围］，… ）
 用这个语法很简单地直接调用了易语言自带的记录编辑器。这个语法的意义可以参看易语言中的帮助文件，用关键词“数据库”来查找。

（题外话：多程序管理器的好处是精简桌面图标，集中管理相关程序，比如游戏类可以放在一起，通讯类放一起，工具类放一起，等等）

--------------------------------------------------------------------------------


有一个重要的窗口单元我们需要用到，就是时钟窗口单元（时钟控件），所以我们先把时钟控件绘制到窗口上，以表示“时钟1”这个要用到的对象。
 ㈠、本课例子程序下载：http://show4me.com/bbs/non-cgi/usr/5/5_32.e
 ㈡、在标签上显示时间示例：

      子程序名：_按钮1_被单击
      时钟1.时钟周期 ＝ 1000
      标签2.标题 ＝ 到文本 (取小时 (取现行时间 ())) ＋ “:” ＋ 到文本 (取分钟 (取现行时间 ())) ＋ “:” ＋ 到文本 (取秒 (取现行时间 ()))
      标签3.标题 ＝ 到文本 (取小时 (取现行时间 ())) ＋ “时” ＋ 到文本 (取分钟 (取现行时间 ())) ＋ “分” ＋ 到文本 (取秒 (取现行时间 ())) ＋ “秒”

 ㈢、用日期框显示示例：在窗口上加入一个日期框即成。

 ㈣、在画板上显示时间示例：

      子程序名：_按钮2_被单击
      画板1.滚动写行 (取现行时间 ())

 ㈤、启动窗口即显示时间：

     子程序名：__启动窗口_创建完毕
     时钟1.时钟周期 ＝ 100
     标签9.标题 ＝ “欢迎您！您进入本站的时间是：” ＋ 到文本 (取小时 (取现行时间 ())) ＋ “时” ＋ 到文本 (取分钟 (取现行时间 ())) ＋ “分” ＋ 到文本 (取秒 (取现行时间 ())) ＋ “秒”

  ㈥、动态显示时间：

     子程序名：_时钟1_周期事件
     时钟1.时钟周期 ＝ 100
     标签7.标题 ＝ 到文本 (取小时 (取现行时间 ())) ＋ “时” ＋ 到文本 (取分钟 (取现行时间 ())) ＋ “分” ＋ 到文本 (取秒 (取现行时间 ())) ＋ “秒”

  ㈦、菜鸟问题：我一开始想用“__启动窗口_创建完毕”来触发显示动态时间（即想用“__启动窗口_创建完毕”这个子程序来显示动态时间），发现不行。后来在“疯子”刘松的光辉指引下，用“_时钟1_周期事件”来触发显示动态时间成功。本菜鸟即是菜鸟，呵呵~~~另外“（时间）到文本”的意思即是要将时间的属性值转化为文本（文字）才能显示出来。


★、信息框的涵义。
  屏幕上弹出的小窗口一般是两种：信息框和输入框，两者又统称对话框。我们在使用程序时经常会发现弹出对话框，有时是给你反馈提示，如：“现在正在安装程序”、“你的操作有错”、“对不起，你没有权限进行此项操作”等；有时是向用户提问，如：“你真的要投降吗？”、“是否关闭窗口”之类。对话框有多种作用，如提醒注意、提示信息、反馈信息、给予程序操作反悔机会等。比如你不小心错按了“投降”按钮，但你并不是想投降，那么在弹出“你真的要投降吗？”的提示信息框时，你可以按其中的“否”按钮来反悔，但如果没有信息框，你想反悔也来不及了。
  尤其是商业应用，操作稍有不顺可能会造成无可估量的损失。所以一般商业软件的起码功能包括提示功能、操作确认、数据效验等都离不开对话框。
  初学者一般以为信息框在易语言中是一种窗口单元，但找来找去都找不到，这是因为信息框和输入框在易语言中都不是具体的窗口单元。
  那么我们怎样使程序弹出信息框？是用系统处理命令语句将其从系统中调出来，该语句形式是：信息框 （提示信息，按钮，［窗口标题］）。下面搬用易语言帮助文件里的解析：

      ㈠、在对话框中显示信息，等待用户单击按钮，并返回一个整数告诉用户单击哪一个按钮。该整数为以下常量值之一： 0、#确认钮； 1、#取消钮； 2、#放弃钮； 3、#重试钮； 4、#忽略钮； 5、#是钮； 6、#否钮。如果对话框有“取消”按钮，则按下 ESC 键与单击“取消”按钮的效果相同。
      ㈡、语法：  整数型  信息框 （提示信息，按钮，［窗口标题］）
      ㈢、参数名及描述：（也就是说信息框中有以下三个地方可以自己修改）
          ⑴、提示信息——必需的；通用型。提示信息只能为文本、数值、逻辑值或日期时间。如果提示信息为文本且包含多行，可在各行之间用回车符 (即“字符 (13)”)、换行符 (即“字符 (10)”) 或回车换行符的组合 (即：“字符 (13) + 字符 (10)”) 来分隔。
          ⑵、按钮——必需的；整数型，初始值为“0”。参数值由以下几组常量值组成，在将这些常量值相加以生成参数值时，每组值只能取用一个数字（第五组除外）： 第一组（描述对话框中显示按钮的类型与数目）： 0、#确认钮； 1、#确认取消钮； 2、#放弃重试忽略钮； 3、#取消是否钮； 4、#是否钮； 5、#重试取消钮 第二组（描述图标的样式）： 16、#错误图标； 32、#询问图标； 48、#警告图标； 64、#信息图标 第三组（说明哪一个按钮是缺省默认值）： 0、#默认按钮一； 256、#默认按钮二； 512、#默认按钮三； 768、#默认按钮四 第四组（决定如何等待消息框结束）： 0、#程序等待； 4096、#系统等待 第五组（其它）： 65536、#位于前台； 524288、#文本右对齐  。
           ⑶、窗口标题——可选的；文本型。参数值指定显示在对话框标题栏中的文本。如果省略，默认为文本“信息：”。

   ★、信息框的例程。
       第一步：规划用户界面
           设计一个程序，在窗口上放四个按钮，分别演示信息框的四种按钮类型（包括四种按钮图标）。界面如图所示。
       第二步、设置对象的属性值
           将四个按钮的名称分别设为“攻击按钮”、“投降按钮”、“病毒按钮”、“进军按钮”，标题分别为“攻击”、“投降”、“病毒”、“进军”。
       第三步、编写事件过程代码

           子程序：_投降按钮_被单击
           信息框 (“你真的要放下武器，退出战场吗？”, 36, “认输”)
               ※36=4（是否按钮）+32（询问图标）
           ------------------------------
           子程序：_攻击按钮_被单击
           信息框 (“对不起，你的宝剑被卡在剑鞘上，无法攻击~”, 21, “攻击失效”)           ※21=5（重试取消钮）+16（错误图标）
           ------------------------------
           子程序：_病毒按钮_被单击
           信息框 (“病毒警告：再向前走后果自负！不怕死就按[确定]，想做缩头乌龟就按[取消]”, 49, “病毒警告！”)
               ※49=1（确认取消钮）+48（警告图标）
           ------------------------------
           子程序：_进军按钮_被单击
           信息框 (“马蹄声声，铁流滚滚，大军在夕阳的映照下在无边的平原上慢慢向西蠕动”, 64, “开拨”)
               ※64=0（确认钮）+64（信息图标）

    ★、对信息框的按钮事件进行编程—函数的返回值的应用。

    ㈠、系统函数及其返回值的含义。
    所谓系统命令可以理解为对所提供的相关数据（即参数）进行处理（运算），不同的命令有不同的处理方式，比如“载入 （窗口1，，假）”，是对“窗口1”这个参数用载入的方式进行处理，又如“相加 （被加数，加数）”是对“被加数”和“加数”两个数据用相加的运算方式处理。
    有处理结果或运算结果（即能返回一个值）的命令我们就称为函数。不知这个“函数”跟数学的“函数”有什么异同？
    从上面对信息框涵义的解析我们可以看出，信息框命令也可以称为信息框函数，因为它有返回值。信息框函数的返回值有以下几个常量值：
    0、#确认钮； 1、#取消钮； 2、#放弃钮； 3、#重试钮； 4、#忽略钮； 5、#是钮； 6、#否钮
    比如当我们按下“确认钮”时，信息框函数值为0；若按下“取消钮”，信息框函数值为1......依此类推。

    ㈡、对信息框的按钮事件进行编程。
       信息框函数能返回一个值，用以决定程序的下一步动向。但当我们运行上面的例程时，为什么我们单击“确认钮”时，却没有反应？这是因为我们还没有对该按钮的事件进行编程，也即是没有对信息框函数返回给我们的数值进行编程。刚才我们已经知道，信息框函数返回什么样的数值，是根据我们按下的按钮来决定的。
       怎样对按下的按钮进行编程？比如我们对上面例程中的“投降按钮”编程之后，再进一步对其弹出的信息框的按钮进行编程，那么“投降按钮”完整的子程序代码如下：

         子程序：_投降按钮_被单击
         如果真 (信息框 (“你真的要放下武器，退出战场吗？”, 36, “认输”) ＝ 5)              ※我们已经知道返回值“5”表示按下#是钮
             信息框 (“严正声明：为了避免双方更大的伤亡，为了本国人民的尊严和体面地生活，虽然我们足够强大，但还是选择退出战场。”, 0, “认输”)
         如果真结束
         如果真 (信息框 (“你真的要放下武器，退出战场吗？”, 36, “认输”) ＝ 6)
             信息框 (“严正声明：如果你认为我们会投降，那你想错了，我们将战斗到最后一个老农！”, 0, “顽抗”)
         如果真结束

       —————例程下载：   http://www.91asp.com/bbs.nsf/0/953048518e5b6cc248256ba300489c0d/$FILE/xinxikuang.zip


[这个贴子最后由bb88在 2002/03/18 09:46pm 编辑]

   在上班之前再赶写一篇。
   在上一课我们说了系统程序怎样实现用户注册的功能，这一课接着说用户登陆功能的实现。前提是先要做好上一课所讲的用户注册功能。
   所谓用户登陆就是你要进入系统之前先要验证你是不是注册用户，如果不是不让进。在这个例子里有几点要验证：⑴、有没有填好姓名和密码，这两项都是必须的；⑵、验证注册用户里有没有这个名字；⑶、密码对不对。为什么用户名和密码一定要填？这是为了防止你没有填上验证项目就能登陆而设的。若验证没有通过，就不能登陆。
   要简单地实现用户登陆功能需要以下两个步骤即可：

  第一步：定义、声明变量（即建立容器）。包括给有关变量起名和确定变量类型。在这个例子里有两个属性值不是固定的，属于变量，即“用户名”和“密码”。这两个变量是局部变量，但为了使登陆的数据消息能够传递到下一窗口程序集，在这里我们定义为窗口程序集变量。我们可以这样理解容器（变量）——它是把输入的验证内容跟数据库联系起来的一道桥梁。下面建立如下的容器（变量）：

    窗口程序集：窗口程序集1

    程序集容器：用户名容器  数据类型：文本型
    程序集容器：密码容器    数据类型：文本型   （在这里把两个变量都定为文本型）
    程序集容器：积分容器    数据类型：文本型   （在这个例子里才会用到的）

  第二步：对验证登陆进行编程：即对“用户登陆”按钮（按钮1）进行编程。

      子程序：_按钮1_被单击

      打开 (#shi数据库, , , , , , )
      置当前库 (“shi”)
      如果 (编辑框1.内容 ＝ “” 或 编辑框2.内容 ＝ “”)
      信息框 (“用户名、密码不能为空，请填写完整的内” ＋ #换行符 ＋ “容后，再尝试登录！”, #警告图标, “登录错误”)
否则
          登陆者姓名 ＝ 删全部空 (编辑框1.内容)
          密码容器 ＝ 删全部空 (编辑框2.内容)
          积分 ＝ 读 (3)
      如果结束
      如果 (查找 (登陆者姓名 ＝ 到文本 (读 (1))))
          则如果 (查找 (密码容器 ＝ 到文本 (读 (2))))
            载入 (窗口2, , 真)              （若用户名和密码都通过验证，则可登陆“窗口2”）
               否则
               信息框 (“密码不对，请重输”, #警告图标, )
          如果结束
       否则
          信息框 (“没有此用户或没有完整填写”, #警告图标, )
       如果结束

        解析：
   ⑴、在上面的程序中，加上一句“积分 ＝ 读 (3)”是为了在登陆后能显示该记录的积分字段（其他程序不用）。
   ⑵、“登陆者姓名 ＝ 删全部空 (编辑框1.内容)”的意思是：将编辑框1的内容赋值给“登陆者姓名”这个变量，但姓名前后又不能有空格（即“删全部空”）。
   ⑶、这个登陆验证子程序只用到两个流程控制条件语句，但又比较复杂。我当初是先用白话设计好验证流程，再转化为代码的。白话的意思是这样：“第一步验证：是否填上用户名和密码，如果没有填上，就不能登陆，否则给变量赋值以便在下一步跟数据库的相关字段对照验证。下一步验证是：检查数据库，看用户名和密码是否相符，如果正确就通过验证，否则不能登陆”。

    ————课后练习：自己试着设计一个跟上面有所不同的登陆验证流程，转为代码并运行看看。
    ————本课例程下载：http://dgsdwz.8u8.com/record/tijiao.zip

[img]http://dgsdwz.8u8.com/record/denglu.jpg[/img]

--------------------------------------------------------------------------------
交流附件上传地址：http://www.91asp.com/


用户注册实质上就是添加新记录到数据库。下面例子事先要建立一个叫“shi”的数据库，包含“用户”、“密码”和“积分”三个字段。注册程序制作过程如下：

步骤一：设置程序界面。

   如图，“确认注册”即“按钮1”，“重写信息”即“按钮2”，“返回登陆”即“按钮3”。三个输入框分别为“编辑框1”、“编辑框2”、“编辑框3”。这个注册窗口名为“窗口1”。

步骤二：设置对象属性。在属性夹里将两个密码框的“输入方式”设为“密码输入”。

步骤三：编写各子程序（即带事件的对象）的代码。在本例中是对三个按钮进行编程。

    ⑴、先对该窗口进行编程，使载入注册窗口时打开并连接数据库：

        子程序：_窗口1_创建完毕
        打开 (#shi数据库, , , , , , )
        置当前库 (“shi”)       （如果只打开一个数据库，这行可不用）

    ⑵、对“确认注册”（“按钮1”）进行编程：

        子程序：_按钮1_被单击
        局部容器：容器1   数据类型：文本型
        局部容器：容器2   数据类型：小数型     （以上声明局部变量）

        容器1 ＝ 到文本 (编辑框1.内容)
        容器2 ＝ 文本到数值 (编辑框2.内容)     （以上给变量赋值）
        查找 (容器1 ＝ 读 (1))                 （查找“用户”和“密码”字段）
        查找 (容器2 ＝ 读 (2))
        如果 (编辑框1.内容 ＝ “” 或 编辑框2.内容 ＝ “” 或 编辑框3.内容 ＝ “”)
        信息框 (“用户名、密码不能为空，请填写完整的内容后，再” ＋ #换行符 ＋ “尝试登录！”, #警告图标, “登录错误”)
       否则
       如果 (编辑框2.内容 ≠ 编辑框3.内容)
       信息框 (“两次输入的密码不相同，请重新填写正确的内容后，再” ＋ #换行符 ＋ “尝试登录！”, #警告图标, “登录错误”)
       否则
       加记录 (容器1, 容器2)             （将两个输入框中的内容添加到数据库）
       替换 (, #积分, 读 (#积分) ＋ 1600)    （使每个用户的初始积分为1600）
       信息框 (“已成功添加为尾记录”, 0, “添加成功”)
       如果结束
         如果结束

  ⑶、对“重写信息”按钮进行编程：（清空三个输入框中的内容以便重填）

       子程序：_按钮2_被单击
       编辑框1.内容 ＝ “”
       编辑框2.内容 ＝ “”
       编辑框3.内容 ＝ “”

  ⑷、最后对“返回登陆”（即退出注册窗口）进行编程：

      子程序：_按钮3_被单击
     _启动窗口.可视 ＝ 真    （开始是使启动窗口不可视再进注册窗口的，现在还原为可视来回到登陆窗口（启动窗口）（若没有启动窗口当然就删除这一句）。
      销毁 ()

 制作完成后试注册一下，打开数据库记录编辑器看看注册是否成功。你还可以添加其他设置，比如不能有两个相同名字的注册用户。
 本课例程下载：http://show4me.com/bbs/non-cgi/usr/5/5_41.e
 下一课就说说注册后怎样登陆。

--------------------------------------------------------------------------------


㈠、简单讲解：就象我们可以在规定时间内自动关闭网页一样，我们也可以在编程中自动关闭窗口。
㈡、主要流程示例：
子程序名：__启动窗口_创建完毕
时钟1.时钟周期 ＝ 10000
子程序名：_时钟1_周期事件
销毁 ()
㈢、请在此处下载本课所编写的程序：http://show4me.com/bbs/non-cgi/usr/5/5_28.e


看了帮助文件里的教程，里面有比较多的关于画板这个窗口单元（控件）的运用，其中多是画板滚动显示信息的示例。我突然想到，聊天室的发言显示窗很可能是用画板做的（后来看其他聊天室的源程序发现的确如此）。于是我也试着想修改教程里面的例子做一个聊天室。由于没有连机聊天的条件，就先做一个自言自语聊天室。制作过程如下（运用了画板、组合框、容器、条件式流程控制等知识）：

㈠、使发言框的信息滚动地显示在画板上。由于编辑框里的内容是一个局部变量，于是在“_按钮1_被单击”的子程序下建立一个名为“容器1”的容器用来存放该变量，并将其类型设为与编辑框1的数据类型一致，以便接收来自编辑框1的文本信息。再用下面代码即可做到使发言框的信息滚动地显示在画板上：

         子程序名：_按钮1_被单击
         容器名：容器3       （声明变量）（易语言是用建立容器来代替声明变量）
         容器3 ＝ 编辑框1.内容     （给变量赋予属性值）
         画板1.滚动写行 (容器3)

 ㈡、发现发送谈话到发言显示区后，在发送区（编辑框1）仍然保留该发言信息，为了清除它，又在“_按钮1_被单击”子程序下加上一句“编辑框1.内容 ＝ ""”以在发言框里清除上一发言。程序如下：

         子程序名：_按钮1_被单击
         容器名：容器3
         容器3 ＝ 编辑框1.内容
         画板1.滚动写行 (容器3)
         编辑框1.内容 ＝ “ ”

㈢、为了使发言显示区显示发话人的用户名，于是又建立一个容器1，令“容器1 ＝ 标签2.标题”，以接收来自“编辑框2”的用户名，现在聊天程序变为这样：

         子程序名：_按钮1_被单击
         容器名：容器1
         容器名：容器3
         容器3 ＝ 编辑框1.内容
         容器1 ＝ 标签2.标题
         画板1.滚动写行 (容器1+容器3)
         编辑框1.内容 ＝ “ ”

㈣、为了使“编辑框2”的用户输入名通过“容器1”传送到“标签2.标题”里，又加下面程序：

         子程序名：_按钮2_被单击
         如果 (编辑框2.内容 ＝ “”)
         （则）标签2.标题 ＝ “”
         （否则）标签2.标题 ＝ “[” ＋ 编辑框2.内容 ＋ “]”
         （如果结束）

㈤、为了初步学习组合框（类似于网页中的下拉表单）的应用，再画一个表情组合框以发送聊天表情。建立“容器4”来存放组合框中的内容。画好组合框后就进行属性设置，在属性窗口里选“列表项目”将所用到的谈话表情加上去。于是新代码如下：

         子程序名：_按钮1_被单击
         容器名：容器1
         容器名：容器2
         容器名：容器3
         容器名：容器4
         容器1 ＝ 标签2.标题
         容器2 ＝ “对自己说：”
         容器3 ＝ 编辑框1.内容
         容器4 ＝ 组合框1.内容
         画板1.滚动写行 (容器1+容器2+容器4+容器3)
         编辑框1.内容 ＝ “ ”

㈥、一般聊天室都有登陆验证，没有名字的用户不能发话。于是再加上验证用户是否登陆，未登陆则不能发话：

         子程序名：_按钮1_被单击
         容器名：容器1
         容器名：容器2
         容器名：容器3
         容器名：容器4
         容器1 ＝ 标签2.标题
         容器2 ＝ “对自己说：”
         容器3 ＝ 编辑框1.内容
         容器4 ＝ 组合框1.内容
         如果 (标签2.标题 ＝ “”)       （即用户名为空）
         （则）载入 (窗口1, , 真)        （用来提示登陆）
         （否则）画板1.滚动写行 (容器1+容器2+容器4+容器3)
         编辑框1.内容 ＝ “ ”
         （如果结束）

 ㈦、有些聊天室禁止用户的发言内容为空，我也这样设置。这样就用到了区块式条件语句，用文字表达为：“如果用户名为空，则提示注册，否则如果发言内容为空，就提示不能发言，如果不是以上两者，就在画板显示发言内容”。最后“_按钮1_被单击”子程序的完整代码为：

         子程序名：_按钮1_被单击
         容器名：容器1
         容器名：容器2
         容器名：容器3
         容器名：容器4
         容器1 ＝ 标签2.标题
         容器2 ＝ “对自己说：”
         容器3 ＝ 编辑框1.内容
         容器4 ＝ 组合框1.内容
         如果 (标签2.标题 ＝ “”)
         （则）载入 (窗口1, , 真)        （用来提示登陆）
         （否则）如果 (编辑框1.内容 ＝ “”)
         （则）载入 (窗口2, , 真)        （用来提示发言不能为空）
         （若以上都不是，则）画板1.滚动写行 (容器1+容器2+容器4+容器3)
         编辑框1.内容 ＝ “ ”
         （如果结束）

  ㈧、设置一个“清屏”按钮，以清空发言显示区里的内容。前一句“画板1.可视 ＝ 假”表示清空内容，后一句“画板1.可视 ＝ 真”使画板重新可视以便显示下一句话，代码如下：

         子程序名：_按钮3_被单击
         画板1.可视 ＝ 假
         画板1.可视 ＝ 真

  后来发现用上面的代码并不能真正清屏，原因是用错画板对象的方法了，应该用“清除”方法，语法为：画板．清除 （［清除区左上角横坐标］，［清除区左上角纵坐标］，［清除区宽度］，［清除区高度］）。于是重写代码为：

         子程序名：_按钮3_被单击
         画板1.清除 (, , , )

  ㈨、在将该程序上传到交流区后又发现一个大问题，就是当切换到浏览器的其他窗口后，回到聊天室，发现所有发言信息都从画板里消失。经查帮助手册，发现将画板1“自动重画”（即将画板里的信息重新恢复。我觉得称为“自动重显”或“自动重写”还容易明白一点）的属性值设为真可以解决这个问题，于是重新上传覆盖原来的版本。

     从以上可以看出程序的完善并不是一件简单的事，编程可以说是苦中有乐啊。

 以上“聊天室”的制作完全没有看别人的代码，都是自己编写，所以可能还有不完善的地方。该程序下载：http://show4me.com/bbs/non-cgi/usr/5/5_37.e


选择夹通过各子夹的浮动条来快速切换到各子夹的界面，一个子夹就相当于一个窗口，但比窗口间的切换方便很多。正因为如此，选择夹在很多程序中都有应用。比如“Etp工作室管理软件”给人留下深刻印象的恐怕就是对选择夹的运用，结合其他控件来管理数据库感觉很轻松。又如应用在聊天室，可以在各聊天房间中快速切换，方便性不同寻常。
选择夹的设置也很简单，下面就建立一个非常简单的例程来说说选择夹的运用。

  在窗口上画上一个选择夹，然后在编辑窗口的属性夹里设置该选择夹的有关属性。比如我们设置三个子夹，分别叫“选择夹1”、“选择夹2”和“选择夹3”。
 ⑴、选“属性夹→子夹管理”，点击“子夹管理”弹出“子夹管理对话框”，分别设置三个子夹的名称为“选择夹1”、“选择夹2”和“选择夹3”。确定后返回。
 ⑵、切换到“选择夹1”界面，加一个标签，标题为：“这是选择夹1”。其余两个子夹也分别添加一个标签，标题分别为 “这是选择夹2”和“这是选择夹3”。
 ⑶、运行该程序，看看在各子夹间切换时的变化。

该程序虽然非常简单，但也提供下载：
http://show4me.com/bbs/non-cgi/usr/5/5_42.e


 [这个贴子最后由bb88在 2002/04/15 11:05pm 编辑]

   单位的事忙得有一个月连胡子也没有刮，现在终于有一点空继续写一些菜得让人笑掉大板门牙的课程了。
   我们会发现很多应用程序的一些窗口控制按钮（包括最大化按钮、最小化按钮和关闭按钮）不是原来的控制按钮，是用其他控件模拟做的。这样做对于控制窗口就有较大的自由度。那么用易语言能不能做这些控制按钮呢？也行。下面看看我的制作步骤：

   步骤一、当然是先设置界面了。
       我做的三个按钮中有一个跟一般的不同，就是“最大化按钮”被我改为“默认位置按钮”，可使窗口回到原来默认的固定位置（有点类似于最大化），以便使程序或窗口回复原来的结构布局。
       ⑴、设置启动窗口的边框为“普通可调边框”，“控制按钮”属性为假以便安放自制的控制按钮，“任意移动”属性为真。
       ⑵、在启动窗口右上角模仿窗口控制按钮分别画出三个小按钮，然后设置三个按钮的标题分别为“_”、“□”和“×”。三个按钮的名称分别为“最小化”、“默认位置”和“关闭”。
       ⑶、再画四个标签，设置它们为不可视。四个标签分别是用来记录窗口变动后的“左边”、“顶边”、“宽度”、“高度”这四个属性值的，当然用变量（容器）来记录也行

    步骤二、对相关的对象事件进行编程。
        ⑴、分别对三个控制按钮进行编程：

            子程序：_关闭_被单击

            _启动窗口.获取焦点 ()          (转移"关闭按钮"的焦点使之不会影响该按钮的美观)
            销毁 ()

            ------------------------------

           子程序：_最小化_被单击

           _启动窗口.获取焦点 ()
           _启动窗口.位置 ＝ 2                    （“2”代表“最小化”）

           ------------------------------

           子程序：_默认位置_被单击

           _启动窗口.获取焦点 ()
           如果 (默认位置.标题 ＝ “□”)
                _启动窗口.移动 (0, 103, 801, 481)          （到默认位置）
                默认位置.标题 ＝ “ㄢ”
                关闭.移动 (_启动窗口.宽度 － 关闭.宽度 － 8, 0, , )
                最小化.移动 (_启动窗口.宽度 － 最小化.宽度 － 26, 0, , )
                默认位置.移动 (_启动窗口.宽度 － 默认位置.宽度 － 44, 0, , )
                _启动窗口.边框 ＝ 2          （到默认位置时边框不可调）
                _启动窗口.随意移动 ＝ 假
           否则
                _启动窗口.移动 (文本到数值 (标签1.标题), 文本到数值 (标签2.标题), 文本到数值 (标签3.标题), 文本到数值 (标签4.标题))       （回到变动位置，通过接收下面两个子程序中的标签信息来实现）
                默认位置按钮.标题 ＝ “□”
                _启动窗口.随意移动 ＝ 真              （回复窗口可以自由移动）
                _启动窗口.边框 ＝ 1
           如果结束

   解悉：在上面的程序中，“关闭.移动 (_启动窗口.宽度 － 关闭.宽度 － 8, 0, , )”等三行代码是为了做到当窗口尺寸改变时，那三个控制按钮总是位于窗口的右上角。

        ⑵、分别对启动窗口的位置和尺寸变动事件进行编程，以便使上面的按钮事件能接受窗口变动的相关信息：

           子程序：__启动窗口_位置被改变

           如果 (_启动窗口.左边 ＝ 0 且 _启动窗口.顶边 ＝ 103 且 _启动窗口.宽度 ＝ 801 且 _启动窗口.高度 ＝ 481 或 _启动窗口.位置 ＝ 2)
                返回 ()       （是为了防止标签记录的是默认位置或最小化状态而不是新位置）
           否则
                标签1.标题 ＝ 到文本 (_启动窗口.左边)     (记录窗口位置的变动)
                标签2.标题 ＝ 到文本 (_启动窗口.顶边)
           如果结束

           ------------------------------

           子程序：__启动窗口_尺寸被改变

           如果 (_启动窗口.左边 ＝ 0 且 _启动窗口.顶边 ＝ 103 且 _启动窗口.宽度 ＝ 801 且 _启动窗口.高度 ＝ 481 或 _启动窗口.位置 ＝ 2)
                返回 ()        （是为了防止标签记录的是默认位置或最小化状态而不是新位置）
           否则
                标签3.标题 ＝ 到文本 (_启动窗口.宽度)
                标签4.标题 ＝ 到文本 (_启动窗口.高度)
                关闭.移动 (_启动窗口.宽度 － 关闭.宽度 － 8, 0, , )
                最小化.移动 (_启动窗口.宽度 － 最小化.宽度 － 26, 0, , )
                默认位置.移动 (_启动窗口.宽度 － 默认位置.宽度 － 44, 0, , )
            如果结束

     解悉：在上面的程序中，“关闭.移动 (_启动窗口.宽度 － 关闭.宽度 － 8, 0, , )”等三行代码是为了做到当窗口尺寸改变时，那三个控制按钮总是位于窗口的右上角。

     步骤三、测试、运行该程序。

     沉重宣告：由于8u8不知何故将我的网站删除了，所以本教程例程全部丢失无法下载，所以在这里也暂时无法为大家提供例程，等以后会将我的习作打包上传到新空间的。

--------------------------------------------------------------------------------
交流附件上传地址：http://www.91asp.com/

--------------------------------------------------------------------------------


单位的事忙得有一个月连胡子也没有刮，现在终于有一点空继续写一些菜得让人笑掉大板门牙的课程了。
 我们会发现很多应用程序的一些窗口控制按钮（包括最大化按钮、最小化按钮和关闭按钮）不是原来的控制按钮，是用其他控件模拟做的。这样做对于控制窗口就有较大的自由度。自制控制按钮是为了方便你设置有多个子窗口的程序界面。比如易语言的“窗口单元箱”的控制按钮大概是自制的，“工作与状态组合夹”的控制按钮大概也是自制的，“菜单条”的控制按钮大概还是自制的、、、它们是通过双击标题栏在默认位置和新位置之间切换。请比较一下这些按钮与一般固定的控制按钮有什么不同？假如没有用到自制的按钮，你看易语言的工作界面会怎样？是不是会杂乱无章？ 那自制控制按钮是不是对设置你的应用程序界面很有用？
  那么用易语言能不能做这些控制按钮呢？也行。下面看看我的制作步骤：

 步骤一、当然是先设置界面了。
     我做的三个按钮中有一个跟一般的不同，就是“最大化按钮”被我改为“默认位置按钮”，可使窗口回到原来默认的固定位置（有点类似于最大化），以便使程序或窗口回复原来的结构布局。
     ⑴、设置启动窗口的边框为“普通可调边框”，“控制按钮”属性为假以便安放自制的控制按钮，“任意移动”属性为真。
     ⑵、在启动窗口右上角模仿窗口控制按钮分别画出三个小按钮，然后设置三个按钮的标题分别为“_”、“□”和“×”。三个按钮的名称分别为“最小化”、“默认位置”和“关闭”。
     ⑶、再画四个标签，设置它们为不可视。四个标签分别是用来记录窗口变动后的“左边”、“顶边”、“宽度”、“高度”这四个属性值的，当然用变量（容器）来记录也行

  步骤二、对相关的对象事件进行编程。
      ⑴、分别对三个控制按钮进行编程：

          子程序：_关闭_被单击

          _启动窗口.获取焦点 ()          (转移"关闭按钮"的焦点使之不会影响该按钮的美观)
          销毁 ()

          ------------------------------

         子程序：_最小化_被单击

         _启动窗口.获取焦点 ()
         _启动窗口.位置 ＝ 2                    （“2”代表“最小化”）

         ------------------------------

         子程序：_默认位置_被单击

         _启动窗口.获取焦点 ()
         如果 (默认位置.标题 ＝ “□”)
              _启动窗口.移动 (0, 103, 801, 481)          （到默认位置）
              默认位置.标题 ＝ “ㄢ”
              关闭.移动 (_启动窗口.宽度 － 关闭.宽度 － 8, 0, , )
              最小化.移动 (_启动窗口.宽度 － 最小化.宽度 － 26, 0, , )
              默认位置.移动 (_启动窗口.宽度 － 默认位置.宽度 － 44, 0, , )
              _启动窗口.边框 ＝ 2          （到默认位置时边框不可调）
              _启动窗口.随意移动 ＝ 假
         否则
              _启动窗口.移动 (文本到数值 (标签1.标题), 文本到数值 (标签2.标题), 文本到数值 (标签3.标题), 文本到数值 (标签4.标题))       （回到变动位置，通过接收下面两个子程序中的标签信息来实现）
              默认位置按钮.标题 ＝ “□”
              _启动窗口.随意移动 ＝ 真              （回复窗口可以自由移动）
              _启动窗口.边框 ＝ 1
         如果结束

 解悉：在上面的程序中，“关闭.移动 (_启动窗口.宽度 － 关闭.宽度 － 8, 0, , )”等三行代码是为了做到当窗口尺寸改变时，那三个控制按钮总是位于窗口的右上角。

      ⑵、分别对启动窗口的位置和尺寸变动事件进行编程，以便使上面的按钮事件能接受窗口变动的相关信息：

         子程序：__启动窗口_位置被改变

         如果 (_启动窗口.左边 ＝ 0 且 _启动窗口.顶边 ＝ 103 且 _启动窗口.宽度 ＝ 801 且 _启动窗口.高度 ＝ 481 或 _启动窗口.位置 ＝ 2)
              返回 ()       （是为了防止标签记录的是默认位置或最小化状态而不是新位置）
         否则
              标签1.标题 ＝ 到文本 (_启动窗口.左边)     (记录窗口位置的变动)
              标签2.标题 ＝ 到文本 (_启动窗口.顶边)
         如果结束

         ------------------------------

         子程序：__启动窗口_尺寸被改变

         如果 (_启动窗口.左边 ＝ 0 且 _启动窗口.顶边 ＝ 103 且 _启动窗口.宽度 ＝ 801 且 _启动窗口.高度 ＝ 481 或 _启动窗口.位置 ＝ 2)
              返回 ()        （是为了防止标签记录的是默认位置或最小化状态而不是新位置）
         否则
              标签3.标题 ＝ 到文本 (_启动窗口.宽度)
              标签4.标题 ＝ 到文本 (_启动窗口.高度)
              关闭.移动 (_启动窗口.宽度 － 关闭.宽度 － 8, 0, , )
              最小化.移动 (_启动窗口.宽度 － 最小化.宽度 － 26, 0, , )
              默认位置.移动 (_启动窗口.宽度 － 默认位置.宽度 － 44, 0, , )
          如果结束

   解悉：在上面的程序中，“关闭.移动 (_启动窗口.宽度 － 关闭.宽度 － 8, 0, , )”等三行代码是为了做到当窗口尺寸改变时，那三个控制按钮总是位于窗口的右上角。

   步骤三、测试、运行该程序。

   沉重宣告：由于8u8不知何故将我的网站删除了，所以本教程例程全部丢失无法下载，所以在这里也暂时无法为大家提供例程，等以后会将我的习作打包上传到新空间的。
（新下载地址：http://eyuyan.com/non-cgi/usr/1/1_3257_8.e）


前言：对易语言的窗口单元（控件）的描述应包含以下几项内容：⑴、该控件的概念（主要着眼于用途方面）；⑵、该控件使用的简要说明；⑶、该控件的属性、方法和事件。在易语言的帮助里对各种控件的属性、方法和事件有较详细的解说，但对每样控件是什么东西却没有解析。对于编程一无所知的初学者来说，一开始可能连控件是什么都不清楚，更不必说每个具体的控件的含义及其用途了，因而我们有必要解析清楚每个控件是什么东西、有什么用途、怎样使用。
    建议：最好在帮助文件和提示窗口里将以下内容添加进去，比如选中某个对象时，会在提示窗口出现相应提示。

   ㈠、窗口（窗体）（FORM）。
       ⑴、功能：是一种包容型窗口单元（容器控件）。窗口是呈现在用户面前的应用程序的界面。我们的应用程序所使用的控件就是放在它的上面。
       ⑵、特点：一个应用程序可能只有一个窗口，也可能有多个窗口。
       ⑶、使用：在使用一个窗口时，如果把窗口的类型设置为“无边框”，运行程序时，就不能改变这个窗口的大小了，而且还要对这个窗口的关闭进行事件设置，比如“按钮1.被单击→销毁（）”或“鼠标右键被按下→销毁（）”之类。
   ㈡、编辑框（text）。
       ⑴、功能：它是易语言唯一能够进行文本（包括文字、数字等）输入的控件，故而又可称为文本框。它可以用来输入信息或显示信息，例如输入口令等，也可以作为信息输出、记录内容的窗口。
       ⑵、使用：编辑框中的文本可以编辑，也可以通过将输入方式的属性值设为只读而不可编辑。编辑框还可以实现多行显示、输入密码、自动换行以及滚动条等功能。它的“内容”属性（主功能属性）用来设置输入的文本，可以在属性窗口设置，也可以在运行程序时用代码加载，如：编辑框1.内容=“祖国，你好！”。
    ㈢、图片框（picture）。
       ⑴、功能：是一种包容型窗口单元。用来显示图形，包括位图、图标文件、.jpeg或.gif文件格式的图形。
       ⑵、使用：它的“图片”属性（主功能属性）用来设置装载的图形，可以在属性窗口设置，也可以在运行程序时用代码加载，如“图片框1.图片=关之琳.gif ”。
    ㈣、外形框（Shape）。
       ⑴、功能：用于显示矩形、正方形、椭圆、圆、圆角矩形、圆角正方形、横向线和纵向线这七种形状。
       ⑵、使用：可以在窗体、图片框或分组框（框架）等容器内使用形状控件，但是不能用形状控件作为容器，因它不是包容型窗口单元。它的“外形”属性（主功能属性）用来设置其形状，可以在属性窗口设置，也可以在运行程序时用代码加载，如“外形框1.外形=4”。
    ㈤、画板。
       ⑴、功能：是一种包容型窗口单元，用来在上面显示和绘制图片、形状、文字等。也用来分割窗口的区域，放置不同类型的控件，起到分类的作用。另外还可以作为一般控件的背景或是信息栏、状态栏。在vb中找不到与此功能接近的控件，可能是易语言将各种绘图函数构件化了。
       ⑵、使用：请参考《自言自语聊天室》、《世恒帮你学易 - 画板的使用》和《一步一步跟我学易语言》等。


㈥、分组框（Frame）。
       ⑴、功能：是一种包容型窗口单元，用来分割窗口的区域，放置不同类型的控件，起到分类的作用。虽然分组框也支持许多事件，但在大多数情况下，不必响应这些事件。
       ⑵、使用：把分组框作为其他控件对象的容器时，创建过程为：首先创建分组框，然后选中分组框再在其中创建其他控件。
       如果要把窗口上已有的控件用分组框进行分组，应先选中要分组的各个控件，将它们剪切到粘贴板上。然后，选中分组框，从粘贴板上把控件粘贴到分组框内。
    ㈦、标签（Label）。
       ⑴、功能：是最常用的输出信息控件之一，通常用于显示文本，但用户不能编辑这些文本。标签控件还常用来标识窗口及窗口上的对象，尤其是标识那些本身不具有“标题”属性的控件。例如可以用来为编辑框、列表框、组合框等控件添加描述性文字，或者作为窗口的说明文字。标签控件还用来显示处理结果、事件进程等信息。
       ⑵、使用：它的“标题”属性（主功能属性）用来设置显示的信息，可以在属性窗口设置，也可以在运行程序时用代码加载，如：标签框1.标题=“祖国，你好！”。
    ㈧、按钮（Command）。
       ⑴、功能：通常用于提供用户向计算机发送指令（事件驱动）、执行命令的接口。比如在程序运行时，用户单击按钮便可以触发事件并执行预定的程序功能。按钮是最常用的控件，同时也是最典型的控件，学习其他控件之前应先学好按钮控件的用法。
       ⑵、使用：对按钮对象的属性、方法和事件我们都要了解清楚。
    ㈨、选择框（Check）。
       ⑴、功能：又称“复选框”，该控件提供一组输入项目（“是/否”或者“真/假”选项），用户可以选择其中的一项或多项。当选定某选择框时，该控件左边的小方框内将以“√”符号标记。
       ⑵、使用：如果在同一窗口中有多组这样的输入项目，可以使用包容型窗口单元（容器控件）（如分组框或图片框）把它们分组，同一组的选择框放置在同一个容器控件中。
       ⑶、示例：
                   子程序：_选择框1_被单击

                   如果 (选择框1.选中 ＝ 真)
                        载入 (窗口1, , 真)
                   否则
                   如果结束
    ㈩、单选框（Option）。
       ⑴、功能：用于提供一组输入项目，用户只能选择其中之一。
       它与选择框的区别就是在同一组单选框控件中，同时只能选定一个选项，而在同一组选择框控件中同时可以选中任意多个选项。
       ⑵、使用：如果在同一窗口中有多组这样的输入项目，可以使用包容型窗口单元（容器控件）（如分组框或图片框）把它们分组，同一组的单选框放置在同一个容器控件中。
       ⑶、示例：（用法跟选择框差不多）

             子程序：_单选框1_鼠标左键被按下
             返回值类型：逻辑型

             参数：横向位置    数据类型：整数型
             参数：纵向位置    数据类型：整数型
             参数：功能键状态  数据类型：整数型

             载入 (窗口1, , 真)


（十一）、组合框（Combo）。
       ⑴、功能：组合框的功能类似列表框。它由文本框和列表框两部分组成，但是，组合框的列表通常是隐藏的，用户可以单击组合框的下拉按钮显示列表。当列表中的内容不能满足输入要求时，还可以直接从键盘输入信息。
       ⑵、使用：它的“列表项目”属性（主功能属性）用来设置组合框的列表选择项目，可以在属性窗口设置，也可以在运行程序时用下面的方法型语句加载：组合框．加入项目 （欲加入项目的文本，［与欲加入项目相关的数值］）。
        组合框有三种类型（附功能属性）可供选择：0、#可编辑列表式；1、#可编辑下拉式；2、不可编辑下拉式。
        在默认类型下，若要增加下拉列表的显示度，可增加列表框的高度（在属性区设置）。
   （十二）、列表框（list）。
       ⑴、功能：列表框提供一个项目列表，用户可以从中选择一个或多个项目。列表框跟上面介绍的组合框不同之处是选择项目全部显示。列表框在选择项目一次显示不完时，会自动增加滚动条。列表框具有数据绑定特性，能够访问大多数标准类型数据库的信息。
       ⑵、使用：它的“列表项目”属性（主功能属性）用来设置组合框的列表选择项目，可以在属性窗口设置，也可以在运行程序时用下面的方法型语句加载：列表框．加入项目 （欲加入项目的文本，［与欲加入项目相关的数值］）。
   （十三）、选择列表框（）。
       ⑴、功能：选择列表框在每个项目的文本前有个复选框,可以单项选择，可选择多项。而列表框也可选择多项，但可固定性不如选择列表框好。
       ⑵、使用：至于在每个项目的文本前有个复选框是怎样的，你对它的“列表项目”属性（主功能属性）进行设置就清楚了。
   （十四）、滚动条（Scroll）。
       ⑴、功能：滚动条的用途之一是在列有较长项目或者大量信息的地方，通过滚动条用户可以在小区域中查看到较多的信息、列表项目或较大的图形等；滚动条控件的用途之二作为数值调整的微调工具。主要用在那些不支持滚动的控件中，给它们提供滚动功能。
        在易语言中，滚动条分为横向滚动条（HScroll）和纵向滚动条（VScroll）。
       ⑵、使用：滚动条的主要属性是“最小位置”、“最大位置”和“位置”。试看下面例句：

    子程序：_横向滚动条1_位置被改变
    编辑框1.内容 ＝ “滚动条目前的位置是：” ＋ 到文本 (横向滚动条1.位置)
   （十五）、进度条（Progress）。
       ⑴、功能：进度条的功能跟滚动条有点相似，不同的地方是滚动条可以手工拖动位置，而进度条只能用代码设置其位置及变化。进度条是易语言系统提供的显示进度的工具之一。它通过颜色条在框中的步进速度以及数字百分比显示程序执行的进度。
       ⑵、使用：进度条的主要属性也是“最小位置”、“最大位置”和“位置”。试看下面例句：进度条1.位置 ＝ 进度条1.位置 ＋ 5。这个例句表示进度条的进度（位置变化）为每周期加5。


（十六）、滑块条（Slider）。
       ⑴、功能：滑块条跟上面介绍的滚动条和进度条相类似，它可以手工拖动位置，上面有刻度条用来确定位置。滑块条常用来控制程序的进程等量的属性，比如直接调整音量的大小。
       ⑵、使用：滑块条的主要属性也是“最小位置”、“最大位置”和“位置”。试看下面例句：滑块条1.位置 ＝ 进度条1.位置 ＋ 5。这个例句表示滑块条的进度（位置变化）为每周期加5。
 （十七）、选择夹（TabStrip）。
       ⑴、功能：是一种包容型窗口单元（容器型控件），选择夹通过各子夹的浮动条来快速切换到各子夹的界面，一个子夹就相当于一个窗口，但比窗口间的切换方便很多。
       ⑵、使用：选择夹的必用属性是“子夹管理”。选“属性夹→子夹管理”，点击“子夹管理”弹出“子夹管理对话框”，分别设置各个子夹的名称，确定后返回。
 （十八）、影像框（Image）。
       ⑴、功能：影像框的用法跟图片框差不多，不同之处有：①、影像框显示图片的时候，耗费的系统资源比图片框要少，而且它的绘图速度也比图片框快；②图片框一种容器型控件，它里面还可以放其他控件，移动图片框，里面的控件也会随之移动。而影像框就不一样了。
         易语言的影像框功能还有待加强完善。
       ⑵、使用：它的“文件名”属性（主功能属性）用来设置装载的图形、控件等，可以在属性窗口设置，也可以在运行程序时用代码加载，如“影像框1.文件名=关之琳.gif ”。
 （十九）、日期框（）。
       ⑴、功能：
       ⑵、使用：
 （二十）、月历（）。
       ⑴、功能：月历是易语言系统提供的一个具有实用性的查找日期的工具，它以列表的形式显示当前设置的日期。用户可以在月历中直接用鼠标修改当前的日期。
       ⑵、使用：利用月历，可以找×年×月的当前日期是星期几。


子程序：_按钮1_被单击

局部容器：文本数组      数据类型：文本型  数组：0
局部容器：数目    数据类型：整数型
局部容器：容器1   数据类型：整数型
局部容器：是否有启动密码      数据类型：逻辑型

※备注：下面的程序片段演示通过使用"取命令行"命令来校验程序启动密码的方法
取命令行 (文本数组)
数目 ＝ 取数组成员数 (文本数组)
计次循环首 (数目, 容器1)
   如果真 (文本数组 [容器1] ＝ “/password”)
    *备注：此处的"/password"可以用你自己的密码代替,如:"/123"
       是否有启动密码 ＝ 真
   如果真结束
计次循环尾 ()
如果真 (是否有启动密码 ＝ 假)
*备注：如果发现没有在命令行中附加密码参数,则直接退出
   信息框 (“您是非法用户!”, 0, )
   结束 ()
如果真结束
信息框 (“欢迎进入系统!”, 0, )

编辑框1.加入文本 (“当前程序运行目录: ” ＋ 取运行目录 () ＋ #换行符 ＋ #换行符)
编辑框1.加入文本 (“当前程序执行文件名: ” ＋ 取执行文件名 () ＋ #换行符 ＋ #换行符)
编辑框1.加入文本 (“环境变量PATH内容为: ” ＋ 读环境变量 (“PATH”) ＋ #换行符 ＋ #换行符)
写环境变量 (“PATH”, “C:\”)
*备注：将PATH环境变量写入新值,注意此改变只对本程序内部有效.
编辑框1.加入文本 (“环境变量PATH的新内容为: ” ＋ 读环境变量 (“PATH”) ＋ #换行符 ＋ #换行符)

**************************
程序下载地址: http://eyuyan.com/cmd-env.e


子程序：_按钮1_被单击

局部容器：容器1   数据类型：整数型

※备注：演示"如果"命令
如果 (1 ＋ 1 ＝ 2)
   画板1.滚动写行 (“如果命令演示: 1+1=2”)
否则
   画板1.滚动写行 (“如果命令演示: 1+1 ≠ 2”)
如果结束
※备注：演示"如果真"命令
如果真 (1 ＋ 1 ＝ 2)
   画板1.滚动写行 (“如果真命令演示: 1+1=2”)
如果真结束
※备注：演示"判断"命令
判断 (1 ＋ 1 ＝ 2)
   画板1.滚动写行 (“判断命令演示: 1+1=2”)
判断 (1 ＋ 1 ＝ 3)
   画板1.滚动写行 (“判断命令演示: 1+1=3”)
默认
   画板1.滚动写行 (“判断命令演示: 1+1=?”)
判断结束
※备注：演示"判断循环"命令
容器1 ＝ 1
判断循环首 (容器1 ＜ 3)
   画板1.滚动写行 (“判断循环演示: ” ＋ 到文本 (容器1))
   容器1 ＝ 容器1 ＋ 1
判断循环尾 ()

※备注：演示"循环判断"命令
容器1 ＝ 1
循环判断首 ()
   画板1.滚动写行 (“循环判断演示: ” ＋ 到文本 (容器1))
   容器1 ＝ 容器1 ＋ 1
循环判断尾 (容器1 ＜ 3)

※备注：演示"计次循环"命令
计次循环首 (3, 容器1)
   画板1.滚动写行 (“计次循环演示: ” ＋ 到文本 (容器1))
计次循环尾 ()

※备注：演示"容器循环"命令
容器循环首 (1, 3, 1, 容器1)
   画板1.滚动写行 (“正向容器循环演示: ” ＋ 到文本 (容器1))
容器循环尾 ()
容器循环首 (3, 1, -1, 容器1)
   画板1.滚动写行 (“逆向容器循环演示: ” ＋ 到文本 (容器1))
容器循环尾 ()

※备注：演示"到循环尾"命令
计次循环首 (10, 容器1)
   如果真 (容器1 ＞ 3)
    *备注：将所有3以后的数字显示屏蔽
       到循环尾 ()
   如果真结束
   画板1.滚动写行 (“到循环尾演示: ” ＋ 到文本 (容器1))
计次循环尾 ()

※备注：演示"跳出循环"命令
计次循环首 (10, 容器1)
   如果真 (容器1 ＞ 3)
    *备注：发现数值超过3就跳出循环
       跳出循环 ()
   如果真结束
   画板1.滚动写行 (“跳出循环演示: ” ＋ 到文本 (容器1))
计次循环尾 ()

※备注：演示"返回"命令
计次循环首 (10, 容器1)
   子程序1 (容器1)
计次循环尾 ()
画板1.滚动写行 (“子程序及返回命令演示: ” ＋ 到文本 (子程序2 ()))

※草稿：结束 ()
*备注：调用本命令将结束程序的执行,所以将其设置为草稿状态.

------------------------------

子程序：子程序1

参数：容器1       数据类型：整数型

如果真 (容器1 ＞ 3)
*备注：发现数值超过3就返回不显示.
   返回 ()
如果真结束
画板1.滚动写行 (“子程序及返回命令演示: ” ＋ 到文本 (容器1))

------------------------------

子程序：子程序2
返回值类型：整数型

返回 (4)

*****************************************************

程序下载地址: http://eyuyan.com/cmd-flow.e


子程序：_按钮1_被单击

※备注：演示"等于"命令
画板1.滚动写行 (“等于命令演示:” ＋ 到文本 (1 ＝ 1))
画板1.滚动写行 (“等于命令演示:” ＋ 到文本 (1 ＝ 2))

※备注：演示"不等于"命令
画板1.滚动写行 (“不等于命令演示:” ＋ 到文本 (1 ≠ 1))
画板1.滚动写行 (“不等于命令演示:” ＋ 到文本 (1 ≠ 2))

※备注：演示"小于"命令
画板1.滚动写行 (“小于命令演示:” ＋ 到文本 (1 ＜ 1))
画板1.滚动写行 (“小于命令演示:” ＋ 到文本 (1 ＜ 2))

※备注：演示"大于"命令
画板1.滚动写行 (“大于命令演示:” ＋ 到文本 (1 ＞ 1))
画板1.滚动写行 (“大于命令演示:” ＋ 到文本 (1 ＞ 2))

※备注：演示"小于或等于"命令
画板1.滚动写行 (“小于或等于命令演示:” ＋ 到文本 (1 ≤ 1))
画板1.滚动写行 (“小于或等于命令演示:” ＋ 到文本 (1 ≤ 2))

※备注：演示"大于或等于"命令
画板1.滚动写行 (“大于或等于命令演示:” ＋ 到文本 (1 ≥ 1))
画板1.滚动写行 (“大于或等于命令演示:” ＋ 到文本 (1 ≥ 2))
画板1.滚动写行 (“大于或等于命令演示:” ＋ 到文本 ([1973年11月15日] ≥ [1998年4月20日]))

※备注：演示"近似等于"命令
画板1.滚动写行 (“近似等于命令演示:” ＋ 到文本 (“易语言” ≈ “易”))
画板1.滚动写行 (“近似等于命令演示:” ＋ 到文本 (“易” ≈ “易语言”))

※备注：演示"并且"命令
画板1.滚动写行 (“并且命令演示:” ＋ 到文本 (1 ＝ 1 且 2 ＝ 1))
画板1.滚动写行 (“并且命令演示:” ＋ 到文本 (1 ＝ 1 且 2 ＝ 2))

※备注：演示"或者"命令
画板1.滚动写行 (“或者命令演示:” ＋ 到文本 (1 ＝ 1 或 2 ＝ 1))
画板1.滚动写行 (“或者命令演示:” ＋ 到文本 (1 ＝ 3 或 2 ＝ 3))

※备注：演示"取反"命令
画板1.滚动写行 (“取反命令演示:” ＋ 到文本 (取反 (1 ＝ 1)))
画板1.滚动写行 (“取反命令演示:” ＋ 到文本 (取反 (1 ＝ 2)))

*************************
程序下载地址: http://eyuyan.com/cmd-bool.e


子程序：_查询按钮_被单击

局部容器：文本数组      数据类型：文本型  数组：0
局部容器：成员数  数据类型：整数型
局部容器：容器1   数据类型：整数型

列表框1.清空 ()
复制数组 (文本数组, 取所有发音 (编辑框1.内容))
成员数 ＝ 取数组成员数 (文本数组)
计次循环首 (成员数, 容器1)
   列表框1.加入项目 (文本数组 [容器1], )
计次循环尾 ()
标签4.标题 ＝ “发音数目: ” ＋ 到文本 (取发音数目 (编辑框1.内容))
标签5.标题 ＝ “拼音: ” ＋ 取拼音 (编辑框1.内容, 1)
标签6.标题 ＝ “声母: ” ＋ 取声母 (编辑框1.内容, 1)
标签7.标题 ＝ “韵母: ” ＋ 取韵母 (编辑框1.内容, 1)

------------------------------

子程序：_比较发音按钮_被单击

如果 (发音比较 (编辑框1.内容, 编辑框2.内容, 选择框1.选中, ))
   信息框 (“比较成功!”, 0, )
否则
   信息框 (“比较失败!”, 0, )
如果结束

------------------------------

子程序：_输入字比较按钮_被单击

※备注：有关输入字的知识请参见知识库中对此命令的解释
如果 (输入字比较 (编辑框3.内容, 编辑框1.内容, 选择框1.选中, ))
   信息框 (“比较成功!”, 0, )
否则
   信息框 (“比较失败!”, 0, )
如果结束

*************************
程序下载地址: http://eyuyan.com/cmd-py.e


子程序：_按钮1_被单击

局部容器：容器1   数据类型：整数型
局部容器：容器2   数据类型：整数型

※备注：易语言中的"容器"等同于其它语言中的"变量",可以用作存储数据.
容器1 ＝ 123
画板1.滚动写行 (“赋值命令演示: ” ＋ 到文本 (容器1))

连续赋值 (345, 容器1, 容器2)
*备注："连续赋值"命令可以同时为一批容器赋值.
画板1.滚动写行 (“连续赋值命令演示: 容器1 = ” ＋ 到文本 (容器1))
画板1.滚动写行 (“连续赋值命令演示: 容器2 = ” ＋ 到文本 (容器2))

参考 (容器1, 容器2)
容器2 ＝ 567
画板1.滚动写行 (“参考命令演示: 容器1 = ” ＋ 到文本 (容器1))
画板1.滚动写行 (“参考命令演示: 容器2 =  ” ＋ 到文本 (容器2))
参考 (容器1, )
画板1.滚动写行 (“参考命令演示: 容器1 = ” ＋ 到文本 (容器1))
画板1.滚动写行 (“参考命令演示: 容器2 =  ” ＋ 到文本 (容器2))

**************************
程序下载地址: http://eyuyan.com/cmd-var.e


子程序：_按钮1_被单击

局部容器：数组1   数据类型：整数型  数组：3
局部容器：数组2   数据类型：日期时间型    数组：2,2
局部容器：数组3   数据类型：日期时间型    数组：0
局部容器：成员数  数据类型：整数型
局部容器：容器1   数据类型：整数型
局部容器：容器2   数据类型：整数型

数组1 ＝ { 1, 2, 3 }
*备注：单维数组的初始化
数组2 ＝ { [1995年5月6日], [2001年6月8日], [1990年2月1日], [1992年3月5日] }
*备注：多维数组的初始化

成员数 ＝ 取数组成员数 (数组1)
*备注：演示单维数组的访问方式
计次循环首 (成员数, 容器1)
   画板1.滚动写行 (数组1 [容器1])
计次循环尾 ()

※备注：演示以多维索引的方式访问多维数组
计次循环首 (取数组下标 (数组2, 1), 容器1)
   计次循环首 (取数组下标 (数组2, 2), 容器2)
       画板1.滚动写行 (数组2 [容器1] [容器2])
   计次循环尾 ()
计次循环尾 ()

成员数 ＝ 取数组成员数 (数组2)
*备注：演示以单维索引的方式访问多维数组
计次循环首 (成员数, 容器1)
   画板1.滚动写行 (数组2 [容器1])
计次循环尾 ()

复制数组 (数组3, 数组2)
*备注：演示复制数组命令
成员数 ＝ 取数组成员数 (数组3)
计次循环首 (成员数, 容器1)
   画板1.滚动写行 (数组3 [容器1])
计次循环尾 ()

清除数组 (数组3)
*备注：演示清除数组命令的使用方法
画板1.滚动写行 (取数组成员数 (数组3))
加入成员 (数组3, [1973年11月15日])
*备注：演示加入成员命令的使用方法
插入成员 (数组3, 1, [1998年4月20日])
*备注：演示插入成员命令的使用方法
成员数 ＝ 取数组成员数 (数组3)
计次循环首 (成员数, 容器1)
   画板1.滚动写行 (数组3 [容器1])
计次循环尾 ()
删除成员 (数组3, 1, 1)
*备注：演示删除成员命令的使用方法
画板1.滚动写行 (取数组成员数 (数组3))

数组排序 (数组1, 假)
*备注：演示数组排序命令的使用方法
成员数 ＝ 取数组成员数 (数组1)
计次循环首 (成员数, 容器1)
   画板1.滚动写行 (数组1 [容器1])
计次循环尾 ()
数组排序 (数组1, 真)
成员数 ＝ 取数组成员数 (数组1)
计次循环首 (成员数, 容器1)
   画板1.滚动写行 (数组1 [容器1])
计次循环尾 ()

*************************
程序下载地址: http://eyuyan.com/cmd-ary.e


子程序：_按钮1_被单击

※备注：演示"相乘"命令
画板1.滚动写行 (“相乘命令演示:” ＋ 到文本 (2 × 3))

※备注：演示"相除"命令
画板1.滚动写行 (“相除命令演示:” ＋ 到文本 (5 ÷ 2))

※备注：演示"整除"命令
画板1.滚动写行 (“整除命令演示:” ＋ 到文本 (5 ＼ 2))

※备注：演示"求余数"命令
画板1.滚动写行 (“求余数命令演示:” ＋ 到文本 (5 ％ 2))

※备注：演示"相加"命令
画板1.滚动写行 (“相加命令演示:” ＋ 到文本 (5 ＋ 2))

※备注：演示"相减"命令
画板1.滚动写行 (“相减命令演示:” ＋ 到文本 (5 － 2))

※备注：演示"负"命令
画板1.滚动写行 (“负命令演示:” ＋ 到文本 (－(5 － 2)))

※备注：演示"取符号"命令
画板1.滚动写行 (“取符号命令演示:” ＋ 到文本 (取符号 (5)))
画板1.滚动写行 (“取符号命令演示:” ＋ 到文本 (取符号 (0)))
画板1.滚动写行 (“取符号命令演示:” ＋ 到文本 (取符号 (-5)))

※备注：演示"取绝对值"命令
画板1.滚动写行 (“取绝对值命令演示:” ＋ 到文本 (取绝对值 (-2)))

※备注：演示"取整"命令
画板1.滚动写行 (“取整命令演示:” ＋ 到文本 (取整 (-7.8)))

※备注：演示"绝对取整"命令
画板1.滚动写行 (“绝对取整命令演示:” ＋ 到文本 (绝对取整 (-7.8)))

※备注：演示"四舍五入"命令
画板1.滚动写行 (“四舍五入命令演示:” ＋ 到文本 (四舍五入 (1007.85, 1)))
画板1.滚动写行 (“四舍五入命令演示:” ＋ 到文本 (四舍五入 (1007.85, 0)))
画板1.滚动写行 (“四舍五入命令演示:” ＋ 到文本 (四舍五入 (1007.85, -1)))

※备注：演示"求次方"命令
画板1.滚动写行 (“求次方命令演示:” ＋ 到文本 (求次方 (2, 3)))

※备注：演示"求平方根"命令
画板1.滚动写行 (“求平方根命令演示:” ＋ 到文本 (求平方根 (2)))

※备注：演示"求正弦"命令
画板1.滚动写行 (“求正弦命令演示:” ＋ 到文本 (求正弦 ((90 × #pi) ÷ 180)))

※备注：演示"求余弦"命令
画板1.滚动写行 (“求余弦命令演示:” ＋ 到文本 (求余弦 (#pi)))

※备注：演示"求正切"命令
画板1.滚动写行 (“求正切命令演示:” ＋ 到文本 (求正切 (#pi)))

※备注：演示"求反正切"命令
画板1.滚动写行 (“求反正切命令演示:” ＋ 到文本 (求反正切 (1)))

※备注：演示"求自然对数"命令
画板1.滚动写行 (“求自然对数命令演示:” ＋ 到文本 (求自然对数 (2)))

※备注：演示"求反对数"命令
画板1.滚动写行 (“求反对数命令演示:” ＋ 到文本 (求反对数 (2)))

※备注：演示"是否运算正确"命令
画板1.滚动写行 (“是否运算正确命令演示:” ＋ 到文本 (是否运算正确 (求反对数 (10))))
画板1.滚动写行 (“是否运算正确命令演示:” ＋ 到文本 (是否运算正确 (求反对数 (1000))))

※备注：演示"置随机数种子"及"取随机数"命令
置随机数种子 (10)
画板1.滚动写行 (“置随机数种子及取随机数命令演示:” ＋ 到文本 (取随机数 (10, 20)))
画板1.滚动写行 (“置随机数种子及取随机数命令演示:” ＋ 到文本 (取随机数 (10, 20)))
置随机数种子 (10)
*备注：从下面可以看出: 同样的种子将产生同样的随机数系列
画板1.滚动写行 (“置随机数种子及取随机数命令演示:” ＋ 到文本 (取随机数 (10, 20)))
画板1.滚动写行 (“置随机数种子及取随机数命令演示:” ＋ 到文本 (取随机数 (10, 20)))

******************************
程序下载地址: http://eyuyan.com/cmd-calc.e


易语言系统内定义的网络通信类命令有四个：取主机名、通信测试、转换为主机名、转换为IP地址。示范代码如下：

            窗口程序集：窗口程序集1

------------------------------

子程序：__启动窗口_创建完毕

标签1.标题 ＝ “㈠、欢迎你登陆bb88的IP获取教程，你的主机名是：” ＋ #换行符 ＋ 取主机名 () ＋ #换行符 ＋ #换行符 ＋ “㈡、你的IP是：” ＋ #换行符 ＋ 转换为IP地址 (取主机名 ())
标签2.标题 ＝ “㈢、测试你自己的计算机是否正常通讯：” ＋ 到文本 (通信测试 (取主机名 (), ))
如果 (标签2.标题 ＝ “㈢、测试你自己的计算机是否正常通讯：” ＋ “-1”)
   标签3.标题 ＝ “你的机器还没有正常通讯，因为返回值为-1”
否则
   标签3.标题 ＝ “你的机器的通讯响应时间为：” ＋ 到文本 (通信测试 (取主机名 (), )) ＋ “毫秒”
如果结束
标签4.标题 ＝ “㈣、转换为主机名：” ＋ 转换为主机名 (转换为IP地址 (取主机名 ()))

   问题：只能ping自己机器的IP及主机名，不能ping远程机器的IP及主机名。比如“标签4.标题 ＝转换为IP地址 (61.111.222.333)”会提示“错误(20026): 现行容器或参数的数据类型与传递给它的数据的类型不一致”。不知在你们的机上是不是这样？
   有关网络通信类命令的详细解析请参看浪花的《易语言网络功能详解》。

--------------------------------------------------------------------------------


子程序：_按钮1_被单击

※备注：演示"位取反"命令
画板1.滚动写行 (“位取反命令演示:” ＋ 到文本 (位取反 (0)))
画板1.滚动写行 (“位取反命令演示:” ＋ 到文本 (位取反 (-1)))

※备注：演示"位与"命令
画板1.滚动写行 (“位与命令演示:” ＋ 到文本 (位与 (1, 2)))
画板1.滚动写行 (“位与命令演示:” ＋ 到文本 (位与 (1, 3)))

※备注：演示"位或"命令
画板1.滚动写行 (“位或命令演示:” ＋ 到文本 (位或 (1, 2)))
画板1.滚动写行 (“位或命令演示:” ＋ 到文本 (位或 (1, 3)))

※备注：演示"位异或"命令
画板1.滚动写行 (“位异或命令演示:” ＋ 到文本 (位异或 (1, 2)))
画板1.滚动写行 (“位异或命令演示:” ＋ 到文本 (位异或 (1, 3)))
画板1.滚动写行 (“位异或命令演示:” ＋ 到文本 (位异或 (100, 位异或 (1, 100))))
*备注：任何数值与其他相同数值连续异或两次就会恢复原值,这种算法可以用作进行简单的数据加密.

**********************
程序下载地址: http://eyuyan.com/cmd-bit.e


子程序：_按钮1_被单击

局部容器：文本    数据类型：文本型
局部容器：文本数组      数据类型：文本型  数组：0
局部容器：成员数  数据类型：整数型
局部容器：容器1   数据类型：整数型

文本 ＝ “飞扬工作室”
编辑框1.加入文本 (“取文本长度: ” ＋ 到文本 (取文本长度 (文本)) ＋ #换行符)
编辑框1.加入文本 (“取文本左边: ” ＋ 取文本左边 (文本, 4) ＋ #换行符)
编辑框1.加入文本 (“取文本右边: ” ＋ 取文本右边 (文本, 6) ＋ #换行符)
编辑框1.加入文本 (“取文本中间: ” ＋ 取文本中间 (文本, 5, 4) ＋ #换行符)
编辑框1.加入文本 (“字符: ” ＋ 字符 (65) ＋ #换行符)
编辑框1.加入文本 (“取代码('中'字的代码): ” ＋ 到文本 (取代码 (文本, 1)) ＋ “, ” ＋ 到文本 (取代码 (文本, 2)) ＋ #换行符)
编辑框1.加入文本 (“寻找文本: ” ＋ 到文本 (寻找文本 (文本, “工”, 1, 真)) ＋ #换行符)
编辑框1.加入文本 (“倒找文本: ” ＋ 到文本 (倒找文本 (文本, “工”, 10, 真)) ＋ #换行符)
编辑框1.加入文本 (“到大写: ” ＋ 到大写 (“abc”) ＋ #换行符)
编辑框1.加入文本 (“到小写: ” ＋ 到小写 (“ABC”) ＋ #换行符)
编辑框1.加入文本 (“到全角: ” ＋ 到全角 (“ABC”) ＋ #换行符)
编辑框1.加入文本 (“到半角: ” ＋ 到半角 (“ＡＢＣ”) ＋ #换行符)
编辑框1.加入文本 (“文本到时间: ” ＋ 到文本 (文本到时间 (“19491001”)) ＋ #换行符)
编辑框1.加入文本 (“文本到数值: ” ＋ 到文本 (文本到数值 (“123”)) ＋ #换行符)
编辑框1.加入文本 (“删首空: ” ＋ 删首空 (“     飞扬工作室”) ＋ #换行符)
编辑框1.加入文本 (“删尾空: ” ＋ 删尾空 (“飞扬工作室     ”) ＋ #换行符)
编辑框1.加入文本 (“删首尾空: ” ＋ 删首尾空 (“      飞扬工作室     ”) ＋ #换行符)
编辑框1.加入文本 (“删全部空: ” ＋ 删全部空 (“      飞  扬  工  作  室     ”) ＋ #换行符)
编辑框1.加入文本 (“文本替换: ” ＋ 文本替换 (“飞扬室”, 5, 0, “工作”) ＋ #换行符)
编辑框1.加入文本 (“子文本替换: ” ＋ 子文本替换 (“电脑编程，电脑”, “电脑”, “计算机”, , , 真) ＋ #换行符)
编辑框1.加入文本 (“子文本替换: ” ＋ 子文本替换 (“电脑编程，电脑”, “电脑”, “计算机”, , 1, 真) ＋ #换行符)
编辑框1.加入文本 (“取空白文本: ” ＋ 取空白文本 (5) ＋ 文本 ＋ #换行符)
编辑框1.加入文本 (“取重复文本: ” ＋ 取重复文本 (3, 文本) ＋ #换行符)
编辑框1.加入文本 (“文本比较: ” ＋ 到文本 (文本比较 (“ABC”, “abc”, 假)) ＋ #换行符)
复制数组 (文本数组, 分割文本 (“工具##程序##游戏”, “##”, ))
成员数 ＝ 取数组成员数 (文本数组)
计次循环首 (成员数, 容器1)
   编辑框1.加入文本 (“分割文本: ” ＋ 文本数组 [容器1] ＋ #换行符)
计次循环尾 ()

**********************************
程序下载地址: http://eyuyan.com/cmd-text.e


【每日例程 - 所有文本操作类命令演示】
例程下载：http://www.91asp.com/bbs.nsf/0/89ecc49f38247d3a48256baf004ea2e5/$FILE/_92f5vi4ujq09sth0jm6v17cmp2fbve4u0s09s7v0jo7n17im22f0fq_.e

子程序：_按钮1_被单击

标签1.标题 ＝ 到文本 (取文本长度 (“祖国您好”))
   ※备注：演示“文本长度”命令
   ※备注：取“祖国您好”的文本长度，返回“8”
   ※备注：每一个字的长度是2字节，两个字共4字节，四个字就是8字节（如上例）
标签2.标题 ＝ 到文本 (取文本左边 (“欲取其部分的文本”, 4))
   ※备注：演示“取文本左边”命令
   ※备注：取“欲取其部分的文本”左边的四个字符的文本，返回“欲取”
标签3.标题 ＝ 到文本 (字符 (3))
   ※备注：演示“字符”命令
   ※备注：取字符代码“3”的字符，返回“「”
标签4.标题 ＝ 到文本 (取代码 (“欲取字符代码的文本”, 3))
   ※备注：演示“取代码”命令
   ※备注：取“欲取字符代码的文本”第三个位置的字符代码，返回“200”
标签5.标题 ＝ 到文本 (寻找文本 (“被搜寻的文本”, “文本”, , 真))
   ※备注：演示“寻找文本”命令
   ※备注：取“被搜寻的文本”中“文本”最先出现的位置，返回“9”
标签6.标题 ＝ 到文本 (倒找文本 (“被搜寻的文本，被搜寻的文本”, “文本”, , 真))
   ※备注：演示“倒找文本”命令
   ※备注：取“文本”字符在上面文本中最后出现的位置，返回“23”
标签17.标题 ＝ 到文本 (到大写 (“abcdefg”))
   ※备注：演示“到大写”命令
   ※备注：将小写英文字母“abcdefg”变换为大写，返回“ABCDEFG”
标签19.标题 ＝ 到文本 (到全角 (“abcd 1234”))
   ※备注：演示“到全角”命令
   ※备注：将上面文本中的全角字母、空格或数字变换为半角，返回“ａｂｃｄ　１２３４”
标签21.标题 ＝ 到文本 (文本到时间 (“1973-11-15-12:30:25”))
   ※备注：演示“文本到时间”命令
   ※备注：将指定文本“1973-11-15-12:30:25”转换为时间，返回“1973年11月15日12
时30分25秒”
标签23.标题 ＝ 到文本 (取现行时间 ())
   ※备注：演示“到文本”命令
   ※备注：将现行时间转换为文本以便在标签上显示
标签35.标题 ＝ 到文本 (删首空 (“  欲删除空格的文本”))
   ※备注：演示“删首空”命令
   ※备注：将“  欲删除空格的文本”的首部空格删除，返回“欲删除空格的文本”
标签38.标题 ＝ 到文本 (删全部空 (“ 欲删除 空格 的文本 ”))
   ※备注：演示“删全部空”命令
   ※备注：将“ 欲删除 空格 的文本 ”的全部空格删除，返回“欲删除空格的文本”
标签41.标题 ＝ 到文本 (文本替换 (“sub”, 1, 6, “子程序：”))
   ※备注：演示“文本替换”命令
   ※备注：将文本“sub ”替换为文本“子程序：”，返回“子程序：”
标签1.标题 ＝ 到文本 (子文本替换 (“vb是我们编程入门的最好语言”, “vb”, “易语言”, , , 真))
   ※备注：演示“子文本替换”命令
   ※备注：将上面一段文本中的“vb”替换为“易语言”，返回“易语言是我们编程入门的最好语言”
标签3.标题 ＝ “哈哈” ＋ 到文本 (取空白文本 (3)) ＋ “嘻嘻”
   ※备注：演示“取空白文本”命令
   ※备注：在“哈哈”和“嘻嘻”间加上重复三次的空白文本，返回“哈哈   嘻嘻”
标签6.标题 ＝ 到文本 (取重复文本 (3, “待重复文本”))
   ※备注：演示“取重复文本”命令
   ※备注：将“待重复文本”重复三次，返回“待重复文本待重复文本待重复文本”
标签14.标题 ＝ 到文本 (文本比较 (“待比较文本”, “待比较文本二”, 真))
   ※备注：演示“文本比较”命令
   ※备注：比较“待比较文本”与“待比较文本二”的大小，返回“-1”
※草稿：标签17.标题 ＝ 到文本 (分割文本 (“，，，，，，，，23，34，234，， ”, “,”, 数组容器))
标签21.标题 ＝ 到文本 (文本到数值 (“待转换的文本”))
   ※备注：演示“文本到数值”命令
   ※备注：返回包含于文本“待转换的文本”内的数值，返回值为“0”

   文本操作类命令还有“取文本右边”、“取文本中间”、“到小写”、“到半角”、“删尾空”、“删首尾空”，分别与上面列举的某个命令相类似，就不一一列举了。
    思考题：上面“分割文本”命令还没有完成，谁来举一个无错例句？三天后上交作业。没有完成作业的打屁屁。


所有其它类命令示例      作者：飞雪

   ■、其它

   1、载入
   示例：以_启动窗口作为父窗口，载入窗口1

    载入 (窗口1, _启动窗口, 真)

   2、选择
   示例：返回较大值的子程序

   子程序：取较大值
   返回值类型：整数型

   参数：数值1       数据类型：整数型
   参数：数值2       数据类型：整数型

   返回 (选择 (数值1 ＞ 数值2, 数值1, 数值2))

   3、多项选择
   示例：随机执行“&程序1”至“&程序3”的子程序

   子程序：随机执行子程序

   局部容器：被执行程序    数据类型：子程序指针

   置随机数种子 ()
   被执行程序 ＝ 多项选择 (取随机数 (1, 3), &程序1, &程序2, &程序3)
   被执行程序 ()

   4、是否为空
   示例：计算次方的子程序

   子程序：计算次方
   返回值类型：长整数型

   参数：底数  数据类型：字节型
   参数：次方  数据类型：字节型  <可空>

   局部容器：计算结果      数据类型：长整数型

   计算结果 ＝ 1
   如果真 (是否为空 (次方))
       次方 ＝ 1
   如果真结束
   容器循环首 (1, 次方, 1, )
       计算结果 ＝ 计算结果 × 底数
   容器循环尾 ()
   返回 (计算结果)

   5、是否已创建
   示例：如果窗口1未创建，则创建它

   如果真（是否已创建（窗口1）=假）
       载入（窗口1，，真）
   如果真结束

   6、取数据类型尺寸
   示例：返回双精度小数型数据所占字节数

   返回（取数据类型尺寸 （#双精度小数型））

   7、取颜色值
   例：设置_启动窗口的底色

   _启动窗口.底色 ＝ 取颜色值 (125, 111, 200)

   8、取事件单元
   常与“事件转移”命令联合使用。
   示例：响应标签鼠标左键被按下事件

   子程序：__启动窗口_创建完毕

   事件转移 (标签2, 标签1)
   事件转移 (标签3, 标签1)
   事件转移 (标签4, 标签1)
   事件转移 (标签5, 标签1)

   ------------------------------

   子程序：_标签1_鼠标左键被按下
   返回值类型：逻辑型

   参数：横向位置    数据类型：整数型
   参数：纵向位置    数据类型：整数型
   参数：功能键状态  数据类型：整数型

   局部容器：响应标签      数据类型：标签

   响应标签 ＝ 取事件单元 ()
   响应标签.标题 ＝ “被单击”

   9、事件转移
   常与“事件转移”命令联合使用。
   示例：响应标签鼠标左键被按下事件

   子程序：__启动窗口_创建完毕

   事件转移 (标签2, 标签1)
   事件转移 (标签3, 标签1)
   事件转移 (标签4, 标签1)
   事件转移 (标签5, 标签1)

   ------------------------------

   子程序：_标签1_鼠标左键被按下
   返回值类型：逻辑型

   参数：横向位置    数据类型：整数型
   参数：纵向位置    数据类型：整数型
   参数：功能键状态  数据类型：整数型

   局部容器：响应标签      数据类型：标签

   响应标签 ＝ 取事件单元 ()
   响应标签.标题 ＝ “被单击”

   10、复制窗口单元
   示例：从标签1复制一个标签，并显示在标签1的下方：

   程序集容器：复制标签    数据类型：标签

   复制窗口单元 (标签1, 复制标签)
   复制标签.可视 ＝ 真
   复制标签.移动 (标签1.左边, 标签1.顶边 ＋ 标签1.高度, , )

   11、处理事件
   示例：计算连加的子程序

   子程序：连加
   返回值类型：长整数型

   参数：最小数      数据类型：整数型
   参数：最大数      数据类型：整数型

   局部容器：容器1   数据类型：整数型
   局部容器：计算结果      数据类型：长整数型

   容器循环首 (最小数, 最大数, 1, 容器1)
       处理事件 ()
        *备注：如果没有加入本命令，在计算未完成前，将对任何操作无响应（如
         移动窗口的操作）。加入了本命令，则程序会暂停计算，响应外部事件。
         调试时请把最小数与最大数之间差距设为较大，以延长系统计算时间，观
         看本命令效果。
       计算结果 ＝ 计算结果 ＋ 容器1
   容器循环尾 ()
   返回 (计算结果)

   12、载入图片
   示例：载入图片1.bmp后，在画板上画出。

   局部容器：图片号  数据类型：整数型

   图片号 ＝ 载入图片 (“1.bmp”)
   画板1.画图片 (图片号, 10, 10, , , )

   13、卸载图片
   示例：卸载不再需要的图片

   卸载图片 (图片号)

   14、指针是否有效
   示例：用子程序指针调用某一子程序

   程序集容器：调用程序    数据类型：子程序指针

   如果 (指针是否有效 (调用程序))
       调用程序 ()
   否则
       信息框 (“找不到相应子程序！”, 0, )
   如果结束

   15、取硬盘特征字

   编辑框1.内容=到文本（取硬盘特征字 （））


             所有数值转换命令示例    作者：（暂未知）

1.数值到大写

示例:把双精度小数123.45转换为简体大写形式.

文本容器=数值到大写(123.45,真)

文本容器中存放的就是124.45的简体大写形式: 一百二十三点四六.

2.数值到人民币

示例:在编辑框1中显示123.37的人民币繁体形式.

编辑框1.内容=数值到人民币(123.37,假)

如果要转换的数值有多于3位小数,则自动四舍五入为2位小数.

3.数值到格式文本

示例:把1234567.8912保留两位小数并进行千分位分割.

数值到格式文本(1234567.8912,2,真)

4.取十六进制文本

示例:把数值12转换为十六进制文本.

取十六进制文本(12)

5.取八进制文本

示例:把数值12 转换为八进制文本.

取八进制文本(12)


所有文件读写命令示例     作者：（暂未知）

说明：文件读写例程中部分示例书写采用以下规则：
返回值 = 命令名（参数一， //参数一的注释
参数二） //参数二的注释
以此类推。

1、打开文件

在文件处理中，最重要的操作之一就是打开文件了。通过不同的打开标志，你可以指定文件的打开方式。你可以创建一个新文件，或者打开一个已经存在的文件，根据需要在调用打开文件（）命令时加不同的参数控制。
示例：如果我们要打开d:\e++\readme.txt,应使用:
打开文件（“d:\e++\readme.txt”， //文件名
#读写， //打开方式，缺省为 #读写
#禁止读写） //限制其它进程操作此文件的方式，缺省为#无限制
也可以使用 #读入、#写出 参数，视打开的目的而定。
也可以直接打开当前目录（程序运行的目录）下的文件：打开文件（“readme.txt”，#读写）
如果使用了 #重写、#改写、#改读 这三个参数的话，若原来的文件不存在，则会先创建一个文件，再打开。尤其是 #重写 参数要注意，若使用了 打开文件（“readme.txt”，#重写）这一命令，则无论readme.txt存不存在，有什么内容，其中数据都会被删除掉，生成一个新文件。使用 #改写、#改读 的区别请参考例程 dkwj.e。

2、打开内存文件

在内存中建立一个文件，能够像普通文件一样读写。由于在内存中，处理速度比普通文件快许多，但最重要的一点，如果在程序退出前不把内存文件的内容写入磁盘文件，退出后内容就会丢失。
示例：建立内存文件请使用：打开内存文件（）

3、关闭文件

当你不再需要对一个文件进行读写时，应该使用关闭文件命令，以便释放打开文件所占用的内存。此命令对打开的磁盘文件，内存文件都有效。
示例：文件号=打开文件（“readme.txt”，#读写，）
关闭文件（文件号）
（文件号（整数类型）是打开文件命令的返回值，是以后用来操作该文件的唯一标示）

4、关闭所有文件

此命令作用同关闭文件，不同的是，这条命令直接关闭所有已打开的文件，不用再指定文件号。注意：程序退出时会自动关闭所有本程序打开的文件。
示例：关闭所有文件（）

5、锁住文件

当有若干个进程（形象一些，可以当作若干个程序）同时要访问一个文件的时候，使用本命令可以使其他用户（或程序）不能访问此文件的部分或全部内容（可以打开，但看不到内容，也不能保存）。
示例：锁住文件（文件号，
0， //欲加锁或解锁的位置，位置值从 0 开始。
1000， //欲加锁或解锁的长度，本例为1000字节？
0） //加锁重试时间，本例为 0 ，即一旦失败立即返回。如果为 -1 ，则 反复进行重试，直到加锁成功为止。
也可以使用取文件长度（）命令锁住整个文件
示例：锁住文件（文件号，0，取文件长度（文件号），-1）
使用 加锁重试时间 参数时请注意，请在第两次使用-1参数调用锁住命令前使用 解锁文件 命令解锁，否则会死循环。

6、解锁文件

解开由 锁住文件 命令锁住的文件，需要注意的是，加解锁两命令的参数（前三个参数）要一致，否则会出错。
示例：解锁文件（文件号，0，取文件长度（文件号））

7、移动读写位置

每一个打开的文件都有一个当前读写位置，使用读或写命令时都会从当前位置开始操作。我们可以使用移动读写位置，把当前位置移动到任何我们想要读写的地方。
示例：移动读写位置（文件号，
#现行位置， //起始移动位置，缺省为 #文件首
10） //移动距离，可以为负，向前移动

8、移到文件首

移动当前读写位置到指定文件首。
示例：移到文件首（文件号）
请参见 yddxwz.e 例程

9、移到文件尾

移动当前读写位置到指定文件尾。
示例：移到文件尾（文件号）
请参见 yddxwz.e 例程

10、读入字节集

关于什么是字节集类型，请参阅 系统基本数据类型，本命令是从指定文件当前位置起读取指定长度的字节集（如图片，声音等）。
示例：读入字节集 （文件号，
取文件长度（文件号）） //欲读入数据的长度

11、写出字节集

本命令是从指定文件中当前位置起写出指定长度的字节集。
示例：写出字节集 （文件号，
1000） //欲写出数据的长度

12、读入文本

使用本命令可以从指定文件中当前位置起读取部分或全部文本。
示例：读入文本（文件号，1000）

13、写出文本

使用本命令可以向指定文件中当前位置起写出部分或全部文本。
示例：写出文本（文件号，1000）

14、读入一行

本命令也是从文件中等当前位置读取文本，但与读入文本的不同之处是，本命令只读入一行文本，遇到行末的回车及换行符将会停止。与 读入字节集 一样要注意的是，如果读入失败，将返回一个空数据并且自动将当前文件读写位置移到文件尾部。
示例：读入一行（文件号）

15、写文本行

本命令自动在写入的文本行后加上回车及换行符。要注意的是，本命令执行成功后，并不将当前读写位置移到文本行后，再次使用本命令时应该先使用移到文件尾（）命令。参见 dkwj.e。
示例：写文本行（文件号，
“欲写入的文本”） //可以为任何可转成文本的类型，如123等。

16、读入数据

使用本命令可以从指定文件中读取数据到指定容器中。
示例：读入数据（文件号,容器1)

17、写出数据

使用本命令可以向指定文件中写出数据。
示例：写出数据（文件号,
容器1) 参数数据可以同时提供数组或非数组数据。如果被写出数据的数据类型为用户自定义或库定义数据类型，命令将会失败。

18、是否在文件尾

检测读写位置是否在文件尾。
示例：是否在文件尾（文件号，
假） //是否判断文本已读完

19、取读写位置

返回文件的当前读写位置，值从0开始，-1为失败。
示例：取读写位置（文件号）

20、取文件长度

本命令能够返回一个已打开的文件的长度。
示例：取文件长度（文件号）

21、插入字节集

本命令与 写出字节集 不同的地方在于插入的字节集不会把后面的内容覆盖，而写出字节集将会把当前读写位置后面的内容覆盖掉。（请注意文件的大小变化,参见 zjjcz.e。)
示例：插入字节集（文件号，画板1.底图）

22、插入文本

插入文本到当前读写位置。与插入字节集类似，参见 wbcz.e。
示例：插入文本（文件号，“你好”）

23、插入文本行

插入文本行到当前读写位置。
示例：插入文本行（文件号，“你好”）

24、删除数据

删除从当前位置开始的指定字节数的一段数据。
示例：删除数据（文件号，1000） 删除1000字节的数据

问题
1、使用打开内存文件时，使用写入文本或写文本行命令，再读入文件内容就会出错，内容只有一个“8”。

2、锁住文件命令，无论开始位置和长度参数如何定义，都会锁住所有文件内容。

3、移动读写位置，读入字节集等命令中的长度参数的单位是什么？字节？

4、读入数据命令中，参数可为容器或数组，数组参数如何使用？例如读入数据 (打开文件 (“readme.txt”, , ), 数组 [1], 数组 [2])中，数组 [2]内容为空。

5、打开文件后会返回文件号，为何在第二次调用读入字节集（文件号，10000）时，会返回空字节集？文件号为程序集容器。只能使用读入字节集（打开文件（“文件名”），10000）。

6、在出现文本类型不能与其他类型相加错误时，易会没有响应？命令如下：画板1.定位写出 (, , “文件长度：” ＋ 取文件尺寸 (“findme.jpg”))

7、寻找文件命令寻找*.txt，第二次调用不带参数的命令，返回空文本？ 如：编辑框1.内容 ＝ 寻找文件 (“*.txt”, ) //有内容 编辑框1.内容 ＝ 寻找文件 (, ) //此时编辑框1.内容为空


                  所有字节集操作命令示例      作者：（暂未知）

字节集用作记录一段字节型数据。字节集与字节数组非常相似，它们之间可以互相转换。
字节数组的使用方法，譬如用中括号对（“[]"）加索引数值引用字节成员，使用数组型
数值数据进行赋值等等，都可以被字节集所使用。两者之间唯一的不同是字节集可以变长，
因此可把字节集看作可变长的字节数组。

1. 取字节集长度

即计算字节集包含多少个字节.由于字节集可于字节数组互相转换,也可以说是计算字节集有多少个成员.
示例:

字节集容器={12,255,15,27}
取字节集长度(字节集容器) 将返回整数4

2. 转换为字节集
3. 取字节集左边

从指定字节集的左边起,取指定个数的字节.

示例:
取字节集左边({12,45,255,147,23,89,},3)

将返回字节集{12,45,255}
这里用数组数值数据代替字节集,效果完全一样.

4. 取字节集右边

于 取字节集这边() 类似,只是是从右边起取指定个数的字节.

5. 取字节中间

于 取字节左边() 取字节右边() 类似,只是指定了起始取出位置.
示例;取指定字节集的3,4,5 个字节

取字节集中间({1,2,3,4,5,6,7,8,9,0},3,3)

返回字节集{3,4,5}

6. 寻找字节集

返回一字节集在另一字节集中最先出现的位置，位置值从 1 开始。
如果未找到，返回 -1。

示例:寻找字节集{22,22}在字节集{12,45,1,22,22,89,56,22,22}最先出现的位置.

寻找字节集({12,45,1,22,22,89,56,22,22},{22,22})

将返回整数4.

7. 倒找字节集

返回一字节集在另一字节集中最后出现的位置，位置值从 1 开始。
如果未找到，返回 -1.于寻找字节集类似.
示例:
倒找字节集({12,45,1,22,22,89,56,22,22},{22,22})

将返回整数8.(注意,是8不是1!)

8. 字节集替换

将指定字节集的某一部分用其它的字节集替换。
示例:
字节集替换({1,2,3,4,5,6,7},3,2{0})

将返回字节集{1,2,0,5,6,7}.
其中的{3,4},即从第3个起,长度为2的子字节集,被替换成{0}
若最后一个参数省略,则是删除成员.

9. 子字节集替换

示例:把字节集{ 1, 2, 3, 4, 1, 2, 6, 7 ,1,2}的中从左起第二个{1,2}替换成{0},进行所有可能的替换.

子字节集替换({ 1, 2, 3, 4, 1, 2, 6, 7 ,1,2},{1,2},{ 0 }, 2, )

返回字节集{1,2,3,4,0,6,7,0}
次命令比8多了个参数:替换次数(最后一个),可省略,省略表示进行所以可能的替换.

10.取空白字节集

返回具有特定数目 0 字节的字节集。
示例:
取空白字节集(4)

将返回字节集{0,0,0,0}

11.取重复字节集

返回一个字节集，其中包含指定次数的字节集重复结果.
示例:

取重复字节集(3,{1,2})

将返回字节集{1,2,1,2,1,2}
{1,2}被重复了3次.

12.分割字节集


                   所有程序调试命令   作者：飞雪

   ■、程序调试：

   1、输出调试文本
   示例：在E语言的提示窗口内显示当前日期

   输出调试文本 (时间到文本 (取现行时间 (), #日期部分))

   2、暂停
   示例：在程序任一位置插入本命令，调试时将在此处暂停

   暂停（）

   3、检查
   示例：在易程序里重启动系统，调试时终止

   检查 (是否为调试版 () ＝ 假)
   运行 (“rundll.exe user.exe,exitwindowsexec”, 假, )

   程序调试时，将在检查语句处中断。易语言提示窗口内会出现相关语句：
   * 执行“检查”命令时不能满足检查条件。

   4、是否为调试版
   示例：在易程序里重启动系统，调试时只显示“系统重启动”信息框

   如果 (是否为调试版 ())
       信息框 (“系统重启动！”, 0, )
   否则
       运行 (“rundll.exe user.exe,exitwindowsexec”, 假, )


                      所有媒体播放命令  --  作者：飞雪

   ■、媒体播放：

   1、播放音乐
   示例：循环播放程序运行目录下的example.mid

   播放音乐（“example.mid"，真）

   2、停止播放
   示例：停止播放当前播放的音乐

   停止播放（）

   3、播放mid
   示例：连续循环播放程序运行目录下的1.mid、2.mid、3.mid

   播放mid（-1，0，“1.mid”，“2.mid”，“3.mid”）

   4、播放mp3
   示例：连续播放程序运行目录下的mp3文件1.mp3、2.mp3两次

   播放mp3(2，“1.mp3”，“2.mp3”）


还有五类命令没有全部示例：磁盘操作、数据库、易向导、系统处理、字节集操作。
    其中磁盘操作、系统处理、字节集操作有较多的示例，但还不全，希望作者补充完整。

                   ■、以下为系统处理命令示例
1、运行

示例：在易程序里运行Windows记事本，并最大化窗口 运行 (“c:\windows\notepad.exe”, 假, 4)

2、取剪辑板文本

示例：用编辑框1读入剪辑板中的文本内容

编辑框1.内容 = 取剪辑板文本（）

3、置剪辑板文本

示例：将编辑框1中的内容放入剪辑板

置剪辑板文本（编辑框1.内容）

4、剪辑板中可有文本

示例：若剪辑板中有文本，则读入至编辑框1中

如果真（剪辑板中可有文本（））
编辑框1.内容 = 取剪辑板文本（）
如果真结束

5、清除剪辑板

示例：如果剪辑板中有内容，则清除之

如果真（剪辑板中可有文本（））
清除剪辑板（）
如果真结束

6、取屏幕宽度

示例：设置_启动窗口的宽度为屏幕宽度，高度为屏幕高度

_启动窗口.移动（ 0 ，0 ，取屏幕宽度（），取屏幕高度（））

7、取屏幕高度

示例：设置_启动窗口的宽度为屏幕宽度，高度为屏幕高度

_启动窗口.移动（ 0 ，0 ，取屏幕宽度（），取屏幕高度（））

8、取鼠标水平位置

示例：标签1鼠标左键被按下时，显示鼠标相对于桌面左边的位置

子程序：_标签1_鼠标左键被按下
返回值类型：逻辑型

参数：横向位置 数据类型：整数型
参数：纵向位置 数据类型：整数型
参数：功能键状态 数据类型：整数型

信息框 (取鼠标水平位置 (), 0, )

9、取鼠标垂直位置

示例：标签1鼠标左键被按下时，显示鼠标相对于桌面顶边的位置

子程序：_标签1_鼠标左键被按下
返回值类型：逻辑型

参数：横向位置 数据类型：整数型
参数：纵向位置 数据类型：整数型
参数：功能键状态 数据类型：整数型

信息框 (取鼠标垂直位置 (), 0, )

10、取颜色数

示例：弹出当前显示方式最大颜色显示数目的信息框

信息框 (取颜色数 (), 0, )

11、输入框

示例：显示要求输入用户名字的输入框，并用输入内容作为_启动窗口标题

子程序：__启动窗口_创建完毕

局部容器：用户 数据类型：文本型

如果真 (输入框 (“请输入用户姓名：”, “用户登录”, “超级用户”, 用户, 1))
_启动窗口.标题 ＝ 用户
如果真结束

12、信息框

示例：删除一个记录

如果真 (信息框 (“确定要删除该记录吗？”, #信息图标 ＋ #确认取消钮, “删除记录”) ＝ #确认钮)
删除 ()
彻底删除 ()
如果真结束

13、鸣叫

示例：如果在尾记录，鸣叫提示，否则，记录向后移动

跳过 (1)
如果真 (尾记录后 ())
鸣叫 ()
到尾记录 ()
如果真结束

14、取启动时间

示例：将系统启动时间读入编辑框1

编辑框1.内容 = 取启动时间（）

15、置等待鼠标

示例：计算连加

局部容器：结果 数据类型：长整数型
局部容器：容器 数据类型：整数型

置等待鼠标 ()
容器循环首 (1, 10000, 1, 容器)
结果 ＝ 结果 ＋ 容器
容器循环尾 ()
恢复鼠标 ()
画板1.滚动写行 (结果)

16、恢复鼠标

示例：计算连加

局部容器：结果 数据类型：长整数型
局部容器：容器 数据类型：整数型

置等待鼠标 ()
容器循环首 (1, 10000, 1, 容器)
结果 ＝ 结果 ＋ 容器
容器循环尾 ()
恢复鼠标 ()
画板1.滚动写行 (结果)

17、延时

示例：在连续执行的程序语句之间停顿3秒

程序语句1
延时（3000）
程序语句2
延时（3000）
……

18、取文本注册表项、取数值注册表项、取字节集注册表项

这三个命令用法基本一样，根据“写注册表项”写入的数据类型，分别用这三个
命令取出写入的值。

示例：从E语言的 #现行用户（也即 HKEY_CURRENT_USER 键）中取出“E记事本”
的常用文件1

局部容器：结果 数据类型：文本型

结果 ＝ 取文本注册表项 (“E 记事本”, “常用文件”, “1”, “没找到”)
画板1.滚动写行 (结果)

19、写注册表项

示例：在E语言的 #现行用户（也即 HKEY_CURRENT_USER 键）中建立子键“E记事
本”-“常用文件”-“1”的值，数据类型为文本型

写注册表项（“E 记事本”, “常用文件”, “1”, “c:\autoexec.bat”)

20、删除注册表项

示例：删除E语言的 #现行用户（也即 HKEY_CURRENT_USER 键）中“E记事本”的
常用文件1

删除注册表项 (“E 记事本”, “常用文件”, “1”)

21、取文本注册项、取数值注册项、取字节集注册项

这三个命令用法基本一样，根据“写注册项”写入的数据类型，分别用这三个
命令取出写入的值。

示例：从E语言中的 #所有用户（即 HKEY_USERS 键）的“.Default\Software”
键下取出“E记事本”的常用文件1

局部容器：结果 数据类型：文本型

结果 ＝ 取文本注册项 (#所有用户, “.Default\Software\E 记事本\常用文件\2”, “没找到”)
画板1.滚动写行 (结果)

22、写注册项

根目录 是指WINDOWS系统中注册表的几个主根键。
E语言中的 #根类 是指 HKEY_CLASSES_ROOT 键
E语言中的 #现行设置 是指 HKEY_CURRENT_CONFIG 键
E语言中的 #现行用户 是指 HKEY_CURRENT_USER 键
E语言中的 #本地机器 是指 HKEY_LOCAL_MACHINE 键
E语言中的 #所有用户 是指 HKEY_USERS 键

示例：在E语言中的“#所有用户”的“.Default\Software”键下写出“E记事
本”的“常用文件”—“1”的值，数据类型为文本型

写注册项 (#所有用户, “.Default\Software\E 记事本\常用文件\1”, “c:\autoexe.bat”)

23、删除注册项

示例：删除E语言中的“#所有用户”的“.Default\Software”键下“E记事本”
的“常用文件”—“1”项

删除注册项 (#所有用户, “.Default\Software\E 记事本\常用文件\1”)

24、注册项是否存在

示例：删除E语言中的“#所有用户”的“.Default\Software”键下“E记事本”
的“常用文件”—“1”项

如果 (注册项是否存在 (#所有用户, “.Default\Software\E 记事本\常用文件\1”))
删除注册项 (#所有用户, “.Default\Software\E 记事本\常用文件\1”)
否则
信息框 (“没找到该注册表项”, 0, )
如果结束

                 ■、以下为字节集操作命令示例

字节集用作记录一段字节型数据。字节集与字节数组非常相似，它们之间可以互相转换。
字节数组的使用方法，譬如用中括号对（“[]"）加索引数值引用字节成员，使用数组型
数值数据进行赋值等等，都可以被字节集所使用。两者之间唯一的不同是字节集可以变长，
因此可把字节集看作可变长的字节数组。

1. 取字节集长度

即计算字节集包含多少个字节.由于字节集可于字节数组互相转换,也可以说是计算字节集有多少个成员.
示例:

字节集容器={12,255,15,27}
取字节集长度(字节集容器) 将返回整数4

2. 转换为字节集
3. 取字节集左边

从指定字节集的左边起,取指定个数的字节.

示例:
取字节集左边({12,45,255,147,23,89,},3)

将返回字节集{12,45,255}
这里用数组数值数据代替字节集,效果完全一样.

4. 取字节集右边

于 取字节集这边() 类似,只是是从右边起取指定个数的字节.

5. 取字节中间

于 取字节左边() 取字节右边() 类似,只是指定了起始取出位置.
示例;取指定字节集的3,4,5 个字节

取字节集中间({1,2,3,4,5,6,7,8,9,0},3,3)

返回字节集{3,4,5}

6. 寻找字节集

返回一字节集在另一字节集中最先出现的位置，位置值从 1 开始。
如果未找到，返回 -1。

示例:寻找字节集{22,22}在字节集{12,45,1,22,22,89,56,22,22}最先出现的位置.

寻找字节集({12,45,1,22,22,89,56,22,22},{22,22})

将返回整数4.

7. 倒找字节集

返回一字节集在另一字节集中最后出现的位置，位置值从 1 开始。
如果未找到，返回 -1.于寻找字节集类似.
示例:
倒找字节集({12,45,1,22,22,89,56,22,22},{22,22})

将返回整数8.(注意,是8不是1!)

8. 字节集替换

将指定字节集的某一部分用其它的字节集替换。
示例:
字节集替换({1,2,3,4,5,6,7},3,2{0})

将返回字节集{1,2,0,5,6,7}.
其中的{3,4},即从第3个起,长度为2的子字节集,被替换成{0}
若最后一个参数省略,则是删除成员.

9. 子字节集替换

示例:把字节集{ 1, 2, 3, 4, 1, 2, 6, 7 ,1,2}的中从左起第二个{1,2}替换成{0},进行所有可能的替换.

子字节集替换({ 1, 2, 3, 4, 1, 2, 6, 7 ,1,2},{1,2},{ 0 }, 2, )

返回字节集{1,2,3,4,0,6,7,0}
次命令比8多了个参数:替换次数(最后一个),可省略,省略表示进行所以可能的替换.

10.取空白字节集

返回具有特定数目 0 字节的字节集。
示例:
取空白字节集(4)

将返回字节集{0,0,0,0}

11.取重复字节集

返回一个字节集，其中包含指定次数的字节集重复结果.
示例:

取重复字节集(3,{1,2})

将返回字节集{1,2,1,2,1,2}
{1,2}被重复了3次.

12.分割字节集

                 ■、以下为磁盘操作命令示例

1、取磁盘总空间

本命令返回指定磁盘总空间，单位为1024字节（KB）。
示例：取磁盘总空间（“C”） //仅接受字符串参数的第一个字符。若忽略，则为当前驱动器。

2、取磁盘剩余空间

返回指定磁盘的剩余空间。类似于 取磁盘总空间 命令。
示例：取磁盘剩余空间（“C”）

3、取磁盘卷标

磁盘卷标是磁盘的标示，本命令可以返回指定的磁盘卷标。
示例：取磁盘卷标（“C”）

4、置磁盘卷标

本命令与上一条命令对应，可以设置指定磁盘的卷标。
示例：置磁盘卷标（“C”，
“Win98”） //卷标内容

5、改变驱动器

使用本命令把当前默认驱动器改为指定的驱动器。以上磁盘操作参见 cpcz.e。
示例：改变驱动器（“D”） //把 D 盘设为默认驱动器

6、改变目录

类似于 改变驱动器 命令，作用是改变当前的目录。需要注意的是本命令不会改变默认驱动器。
示例：改变目录（“C:\Windows”） //也可以不指定盘符，在默认的驱动器上改变目录（若目录不存在会失败，不做改变）。

7、取当前目录

使用本命令返回当前默认的目录。
示例：编辑框1.内容 = 取当前目录（）

8、创建目录

创建一个新的目录，相当于 DOS 下的 MD 命令。
示例：创建目录（“C:\DOS”）
创建目录（“DOS”） //在当前目录下创建

9、删除目录

删除磁盘上的一个目录，要注意的是，同 DOS 命令 RD 一样，要求此目录下没有任何文件或子目录。
示例：删除目录（“DOS”）

10、复制文件

把某个文件从一个地方复制到另一个地方。
示例：复制文件（“C:\Msdos.sys”， //源文件名
“Msdos.sys”） //目标文件名
注意：文件名可以使用绝对路径，也可以使用相对路径（即当前目录下），但是如果目标文件所在父目录不存在，复制将失败。
示例：复制文件（“C:\Msdos.sys”，“D:\AAA\Msdos.sys”）
若 D:\AAA 不存在，复制将会失败。

11、移动文件

把某个文件从一个地方移动到另一个地方。可参考 复制文件 命令。
示例：移动文件（“readme.txt”,“C:\1.txt”）
移动文件（“readme.txt”,“readme1.txt”） //本命令相当于文件改名。

12、文件更名

重新命名一个文件或目录。对文件操作来说，无论从用法还是效果上，都和 移动文件 命令一致。
示例：文件更名（“readme.txt”,“readme1.txt”）
文件更名（“readme.txt”,“C:\1.txt”） //本命令相当于文件移动。

13、删除文件

删除指定的文件。注意：删不掉系统正在使用的文件。
示例：删除文件（“readme.txt”）

14、文件是否存在

检测指定的文件是否存在。
示例：文件是否存在（“readme.txt”）

15、寻找文件

使用本命令可以返回符合要求名字和属性都匹配的文件或目录名。本命令可以使用通配符“*”和“？”来指定各种文件名。需要注意的是，本命令调用一次，只返回一个匹配的文件名。再次调用没有文件名参数的 寻找文件 命令会返回下一个匹配的文件名，直到找不到匹配的文件，会返回空文本。这时必须再次使用带文件名参数的命令才能进行下次查找。
示例：寻找文件（“readme.txt”， //匹配的文件名
#只读文件） //匹配的属性，默认为除子目录外的所有文件
寻找文件（，#只读文件） //返回和上一条命令相同条件的下一个匹配的文件名
寻找文件（“*.txt”，） //返回第一个扩展名为 .txt 的文件名
寻找文件（“???.txt”，)

16、取文件时间

返回指定文件的创建或是最后一次被修改的时间。注意：如果文件不存在的话，将返回系统现行时间。
示例：编辑框1.内容 = 到文本（取文件时间（“readme.txt”）） //到文本（）命令将时间类型转换为文本类型，以便 编辑框1.内容 接受。

17、取临时文件名

返回一个在指定目录中确定不存在的 .TMP 全路径文件名称。
示例：取临时文件名（“C:\”）
取临时文件名（） //默认将使用系统的标准临时目录

18、读入文件

读入文件中的所有数据，返回的类型为字节集（可用于图片，声音的读入）。
示例：画板1.底图 = 读入文件（“candy.jpg”）

19、写到文件

把字节集类型的所有数据写到文件中（可用于图片，声音的写出）。
示例：写出文件（“candy.jpg”，画板1.底图）


★、我建立了启动窗口，并添加了一个连接到数据库的按钮，想连接到自己建的数据库上。 在写命令是是抄袭例程的。输入“如果真 (外部数据库1.打开 (, ))”， 但系统提示无此容器，怎么解决？应该在什么位置定义容器？
    西风：外部数据库是一个控件，你得先添加到窗口中去。
 ★、我的数据库中有10000条记录，如果创建索引的话，能加快记录的查找速度吗？
    西风：绝对能。尤其是对记录数很多的数据库，那速度对比绝对非常明显的。注意创建索引后，要用“索引查找（）”，如果继续用“查找（）”，那…………
你可以在数据库打开时就打开索引，至于创建索引么，随你什么时候了。用易的数据库编辑器都可以。 反正你要做的就是保证在需要用索引的时候，它已经创建并打开。
 ★、请问数据库常量中的用户习惯是什么意思？
    小米虫：就是你最后一次打开的数据库。
 ★、我在写记录的时候遇到下面的问题,麻烦给我讲一下是为什么呢?
1:        计次循环首 (图片列表框.取项目数 (), 图片数目)
          加记录 (图片列表框.取项目文本 (图片数目 － 1))
      计次循环尾 ()
2:        计次循环首 (图片列表框.取项目数 (), 图片数目)
          写 (图片数目,图片列表框.取项目文本 (图片数目 － 1))
      计次循环尾 ()
3:        计次循环首 (图片列表框.取项目数 (), 图片数目)
          写字段(图片数目,,图片列表框.取项目文本 (图片数目 － 1))
      计次循环尾 ()
除了第一句以外.后面两个操作都没有加入记录,是为什么呢?我的当前数据库里面有记录的。
    世恒：加纪录（）在操作时加入一条纪录
写（）必须对已存在的纪录操作，不能加入纪录，可以先加入空纪录，再用写操作
写字段（）用法同“写（）” 。
 ★、我在写记录的时候遇到下面的问题,麻烦给我讲一下是为什么呢?
1:        计次循环首 (图片列表框.取项目数 (), 图片数目)
        加空记录（）
        写 (图片数目，图片列表框.取项目文本 (图片数目 － 1))
      计次循环尾 ()
为什么只能写一个记录呢？
    猛子：
计次循环首 (列表框1.取项目数 (), 图片数目)
  加空记录 ()
  写 (1, 列表框1.取项目文本 (图片数目 － 1))
计次循环尾 ()
〈逻辑型〉 写 （字段名称或位置，［欲写入数据］）第一个参数是字段名,不是行号 。
 ★、我想做一个数据库浏览器，可以象列表一样一行行的列出来，而且当前位置可以反色。 我应该有什么方法？或者有什么列程吗？大家一定要帮帮忙呀，我先谢了！
     Candy：使用表格，数据源，数据库提供者控件实现，可以看E自带的表格教程。
 ★、表格的数据源如何确定和如何打印表格？譬如一个“易”数据库，如何把它作为表格显示在窗口上？又如何打印出来?
     猛子：表格1.打印预览
     飞扬工作室：看一下"易之表"里面的对应代码。
 ★、易语言的数据库用记事本就可以打开，并且可以修改数据。虽然格式不同于记事本，感觉这样不很安全。 能否在以后做上一些加密措施？
     tianyu1398：现在可以自己加密呀.我昨天解决好了这个问题,把源程序帖在论坛了http://eyuyan.com/cgi-bin/lb5000/topic.cgi?forum=1&topic=3240&show=25
 ★、我要做一个客房管理的东东，是一个房间做一个库好还是全部房间都用一个库，或者还有其他的方法，能不能指点一下？
     世恒：那就根据实际情况，但一般来说建一个库就差不多了。
 ★、怎要怎样把数据表格里的记录按符合条件记录重新显示在表格里？
     西风：易的表格目前好象不支持条件筛选的。只能显示库中所有记录。笨办法是：先对数据库进行条件筛选，生成另外一个临时数据库，再在表格中显示临时数据库的内容。
     世恒： 下载“世恒婚介管理系统“看看，里面有相关方法！
 ★、 易程序的表格文件能否转化为其他文件，比如edb文件，txt文件，mdb文件，xls文件。如果能够转化，应该如何转化，我认为至少应该可以转化我edb文件，以及txt文件，这样我才能够将表格文件转化我其他支持txt文件转化的文件格式，比如mdb文件。
     飞扬工作室：所有数据提供者之间的数据格式都可以互相转换。比如将表格文件转换为edb,你可以通过将通用提供者中的数据添加到数据库提供者中即可。
 ★、在已有数据的表格里，怎样把表格里的数据清除后，再把数据库里符合条件的记录一条一条的加在表格里？
      猛子：去看看《学生管理系统2.1》，那里边就有。


★、将所有局部容器都设置为全局容器，这样可以随时调用，对程序运行有影响吗？
     bb88：有影响，比如你找一个空间存放运行你的程序，假如全局变量过多，空间商会取消你的空间。
     西风：占用的内存资源： 全局容器>程序集容器>局部容器。不到万不得已，还是用局部容器好。
     jak：太多的全局变量会使程序运行缓慢，比如说循环一个有50个字段10000条记录的数据库，呵呵。尽量使用局部变量或者程序集变量，可以不使用变量的最好就不使用。
 ★、请问如何查找一个字? 也就是说要查找一个字,第一个字,第二个字的项目也要列出。
     xuexiyi：请参考《区号邮编易查询》。
 ★、子程序：__启动窗口_创建完毕

     打开 (#shi数据库, , , , , , )
     判断循环首 (取反 (尾记录后 ()))
         列表框1.加入项目 (读 (1), 取记录号 ())
         跳过 ()
    判断循环尾 ()
    ※就是讲一下，它的运行方法，和作用，我没有理解到。谢谢。

    电脑狂：我下面的子程序跟你那个子程序是等效的，只是各人使用的习惯不一样罢了，建议最好使用你说的那个， 因为可以不用定义局部容器，她的好处都明白了？

         子程序2
         局部容器：容器1   数据类型：整数型

         容器1 ＝ 1
         计次循环首 (取记录数 (), 容器1)
             跳到 (容器1)
             列表框1.加入项目 (读 (1), 容器1)
         计次循环尾 ()
         ※再来解释“判断循环首 (取反 (尾记录后 ()))”这一句：
  判断循环首（条件）：
  本命令根据提供的逻辑参数的值，来决定是否进入循环。如果提供的逻辑参数值为真，程序顺序执行下一条命令进入循环，否则跳转到本命令所对应的“判断循环尾”命令的下一条命令处以跳出循环。
  取反 （被反转的逻辑值）：
  如果参数值为真则返回假，如果参数值为假则返回真。
  尾记录后 （）：
  如果当前数据库的当前记录指针已在尾记录的后面，返回真，否则返回假。
判断循环首 (取反 (尾记录后 ()))：
  意思是：如果当前记录指针没有在尾记录的后面，就执行循环。
例如：库中共有50条记录，现在当前记录指针指向第30号记录，那么，“尾记录后 ()”就等于“假”，而“取反 (尾记录后 ())”就等于“真”，执行循环体。OK?

     西风：呵呵，“判断循环首（取反（尾记录后（）））”的意思就是：“判断循环首（尾记录后（）=假）” 。就是判断当前记录是否已到了数据库尾。各人的喜欢而已，我就比较喜欢用后者。
 ★、"将数据通过数据源导出到通用提供者中"，请大虾说说如何实现？谢谢！
     pingwind：易之表例程中的"浏览数据库"就是那么做的。直接运行E，选该例程，或者打开E目录下的“egrid.e”即可。
 ★、如何能实现“数据库”的排序？
     西风：易语言自己就有数据库排序命令，其实我觉得易语言知识库对我帮助还是挺大的，去找一找吧。
 ★、请教易语言的数据库中有没有象VFP中的LIST命令，或者类似的，能直接完整的
显示数据库的内容的命令或方法？
     大伟：数据库提供者1.数据库文件名 ＝ “xxx.edb”这句话算不算？
     jak：呵呵，“表格”控件就是LIST吧。
 ★、哪位大侠写过打印数据库程序的请给小弟推荐一个？不是打印表格，是按记录一个一个打印。
     电脑狂：《通用库管理器28》，交流园地和我的主页上都有。
 ★、下面一段程序是删除当前记录的。请问为什么要在后面加“数据库提供者1.数据库文件名 ＝ “chj.edb”才能真正删除该数据库中的当前记录？当后面没有这一句时，不会删除当前记录，而是变当前记录为空记录。程序如下：

        子程序名：_删除按钮_被单击
        删除 ()
        彻底删除 ()
        编辑框1.内容 ＝ “”           （清除该字段的内容）
        编辑框2.内容 ＝ “”
        编辑框3.内容 ＝ “”
        编辑框1.获取焦点 ()
        数据库提供者1.数据库文件名 ＝ “chj.edb”

     大伟：数据库提供者1.数据库文件名 ＝ “chj.edb” 是对数据库进行重新刷新。程序中处理完记录后，采用此此语句可使记录得到同步更新，在对表格进行操作时，这种现象最明显。用按钮来删除跟“数据源”中的一个删除功能没有冲突。
 ★、我的程序有下面句子：

             打开 (#aaa数据库, , , , , , )
             运行 (读 (地址1), 假, )

      但“运行 (读 (地址1), 假, )”并不执行，提示“错误(20003)：现行容器或参数不能接受空数据”，为什么？
     世恒：问题是你没有定义常量值,却又调用常量。比如没有在常量表中将qidong数据库的常量值命名为“qidong”之类，所以就成了所谓的“空数据”。 我在其中加入的标签是用来验证是否读取了数据库,你可以删掉,并将代码中所有有标签1的地方删去。
 ★、不好意思，哪位老师请告诉我，怎样全部显示数据库的内容？请给例程。
     世恒：例程 http://www.zgjg.com/download/help/data.zip


★、软件中用到了数据库，我想让它在数据库更新以后马上刷新读取。所以用了（当窗口激活）的子程序，但是不知为何没有作用，现在只能变通的用一个时钟来让它定时刷新。谁能够帮帮我。
     浪花：刷新我觉得好象没有用的。最正确的你应该是先关闭数据库，然后再打开，这样，比你用刷新的效果肯定要好得多。
     湖海书生：用“写出缓存”。有时刚录入的数据就查询修改的话，可能数据库中没有。
 ★、怎么跳到数据库中的任意记录？ 例如：数据库中有100条记录，当选择了跳到第5条记录后，数据库自动显示第5条记录。
     iceroy ：http://eyuyan.com/non-cgi/icon/zip.gif
 ★、怎样插入数据库记录？ 例如：数据库中有5条记录，我想在2-3之中插入一条记录，使这记录号等于3，而原来的记录向后移一位， 等于4。以后的记录以此类推。
     电脑狂：通用库管理器28中，你想要的都有。
 ★、有谁知道, 怎样用命令行方式直接存取备注字段(不用易自带的记录编辑器)? 谢谢!
     Candy：字节集操作应该自动存取备注段。
 ★、为什么我在进行任一范围内复制记录时，复制后的库中会有空记录，（检查后发现是有一些记录没有复制上。）我的语句是这样写的：复制记录 (“库”,取记录数()-取记录号 ()<=30,)
     世恒：
              判断循环首(到尾纪录后())
                  复制记录 (“库”,取记录数()-取记录号 ()<=30,)
                  跳过(1)
              判断循环尾()
     ————————————————————————————
     雨点：
              打开（数据库1，，，，，，） *此数据库为欲查找内容的库*
              置当前库（数据库1）
              复制结构（数据库2，所需字段） *此数据库为查找后的库*
              打开（数据库2，，，，，，）
              置当前库（数据库2）
              清空（）
              添加（数据库1，条件语句，所需字段)
     电脑狂：复制记录 (“库.edb”, 取记录号 () ≥ 2 且 取记录号 () ≤ 4, )
“取记录数()-取记录号 ()<=30”这条语句有问题，分析一下不难看出，执行后始终复制的是最后30个记录。
 ★、我的程序中有个将（数据库1）中例如以“单位”为字段，其中有“单位A”96个记录，“单位B”148个记录，“单位C”78个记录，“单位D”39个记录，这些记录都是穿插输入的。假如我以查找“单位B”且将“单位B”的所有记录复制到（数据库2）中，记录数148个是对的，可在后面有很多是空白记录。请各位高手们指点该如何处理。
     iceroy：
             判断循环首（到尾记录后（））
                 复制记录（“库”，取记录数（）-取记录号（）<=30）
                 跳过（1）
             判断循环尾（）

   另外，你可用一个编辑框和一个通用对话框。编辑框的内容=通用对话框的文件名然后再用复制记录（） 命令，当然编辑框的内容（通用对话框的文件名）就是“数据库2”，这样就能将数据库复制。
      电脑狂：
             排序 (“数据库2.edb”, “单位”, , , )
             打开 (“数据库2”, , , , , , )
             置当前库 (“数据库2”)
             删除 (读 (“单位”) ≠ “单位B”)
             彻底删除 ()
             编辑 (, , )
 ★、易数据库没有自动列表功能吗？就像电子表格一样的一个字段占一列的样子。怎么办哪？
     雨点：
          我给个例程于你试试,
窗口程序集：窗口程序集1

程序集容器：横线  数据类型：文本型
程序集容器：左线  数据类型：文本型
程序集容器：右线  数据类型：文本型
程序集容器：十线  数据类型：文本型
程序集容器：上左  数据类型：文本型
程序集容器：上右  数据类型：文本型
程序集容器：中左  数据类型：文本型
程序集容器：中右  数据类型：文本型
程序集容器：z     数据类型：文本型
程序集容器：倒丁  数据类型：文本型
程序集容器：丁线  数据类型：文本型
程序集容器：x     数据类型：文本型
程序集容器：w     数据类型：文本型

子程序：_按钮1_被单击

对话框.类型 ＝ 0
对话框.初始目录 ＝ 取当前目录 ()
打开 (对话框.文件名, “XS”, , , , , )
显示 ()

------------------------------

子程序：显示

局部容器：n       数据类型：整数型
局部容器：y       数据类型：文本型

编辑框2.内容 ＝ “”
置当前库 (“XS”)
到首记录 ()
表格 ()
计次循环首 (取记录数 (), n)
  y ＝ y ＋ 中右 ＋ 取重复文本 (取字段尺寸 (1) ÷ 2, 横线) ＋ 十线 ＋ 取重复文本 (取字段尺寸 (2) ÷ 2, 横线) ＋ 十线 ＋ 取重复文本 (取字段尺寸 (3) ÷ 2, 横线) ＋ 十线 ＋ 取重复文本 (取字段尺寸 (4) ÷ 2, 横线) ＋ 十线 ＋ 取重复文本 (取字段尺寸 (5) ÷ 2, 横线) ＋ 十线 ＋ 取重复文本 (取字段尺寸 (6) ÷ 2, 横线) ＋ 十线 ＋ 取重复文本 (取字段尺寸 (7) ÷ 2, 横线) ＋ 中左 ＋ #换行符 ＋ “│” ＋ 读 (1) ＋ 取空白文本 (取字段尺寸 (1) － 取文本长度 (读 (1))) ＋ “│” ＋ 读 (2) ＋ 取空白文本 (取字段尺寸 (2) － 取文本长度 (读 (2))) ＋ “│” ＋ 读 (3) ＋ 取空白文本 (取字段尺寸 (3) － 取文本长度 (读 (3))) ＋ “│” ＋ 读 (4) ＋ 取空白文本 (取字段尺寸 (4) － 取文本长度 (读 (4))) ＋ “│” ＋ 读 (5) ＋ 取空白文本 (取字段尺寸 (5) － 取文本长度 (读 (5))) ＋ “│” ＋ 读 (6) ＋ 取空白文本 (取字段尺寸 (6) － 取文本长度 (读 (6))) ＋ “│” ＋ 读 (7) ＋ 取空白文本 (取字段尺寸 (7) － 取文本长度 (读 (7))) ＋ “│” ＋ #换行符
  跳到 (n ＋ 1)
计次循环尾 ()
x ＝ x ＋ 右线 ＋ 取重复文本 (取字段尺寸 (1) ÷ 2, 横线) ＋ 丁线 ＋ 取重复文本 (取字段尺寸 (2) ÷ 2, 横线) ＋ 丁线 ＋ 取重复文本 (取字段尺寸 (3) ÷ 2, 横线) ＋ 丁线 ＋ 取重复文本 (取字段尺寸 (4) ÷ 2, 横线) ＋ 丁线 ＋ 取重复文本 (取字段尺寸 (5) ÷ 2, 横线) ＋ 丁线 ＋ 取重复文本 (取字段尺寸 (6) ÷ 2, 横线) ＋ 丁线 ＋ 取重复文本 (取字段尺寸 (7) ÷ 2, 横线) ＋ 左线 ＋ #换行符
w ＝ w ＋ “│” ＋ 取空白文本 ((取字段尺寸 (1) － 取文本长度 (取字段名 (1))) ÷ 2) ＋ 取字段名 (1) ＋ 取空白文本 ((取字段尺寸 (1) － 取文本长度 (取字段名 (1))) ÷ 2) ＋ “│” ＋ 取空白文本 ((取字段尺寸 (2) － 取文本长度 (取字段名 (2))) ÷ 2) ＋ 取字段名 (2) ＋ 取空白文本 ((取字段尺寸 (2) － 取文本长度 (取字段名 (2))) ÷ 2) ＋ “│” ＋ 取空白文本 ((取字段尺寸 (3) － 取文本长度 (取字段名 (3))) ÷ 2) ＋ 取字段名 (3) ＋ 取空白文本 ((取字段尺寸 (3) － 取文本长度 (取字段名 (3))) ÷ 2) ＋ “│” ＋ 取空白文本 ((取字段尺寸 (4) － 取文本长度 (取字段名 (4))) ÷ 2) ＋ 取字段名 (4) ＋ 取空白文本 ((取字段尺寸 (4) － 取文本长度 (取字段名 (4))) ÷ 2) ＋ “│” ＋ 取空白文本 ((取字段尺寸 (5) － 取文本长度 (取字段名 (5))) ÷ 2) ＋ 取字段名 (5) ＋ 取空白文本 ((取字段尺寸 (5) － 取文本长度 (取字段名 (5))) ÷ 2) ＋ “│” ＋ 取空白文本 ((取字段尺寸 (6) － 取文本长度 (取字段名 (6))) ÷ 2) ＋ 取字段名 (6) ＋ 取空白文本 ((取字段尺寸 (6) － 取文本长度 (取字段名 (6))) ÷ 2) ＋ “│” ＋ 取空白文本 ((取字段尺寸 (7) － 取文本长度 (取字段名 (7))) ÷ 2) ＋ 取字段名 (7) ＋ 取空白文本 ((取字段尺寸 (7) － 取文本长度 (取字段名 (7))) ÷ 2) ＋ “│” ＋ #换行符
z ＝ z ＋ 上右 ＋ 取重复文本 (取字段尺寸 (1) ÷ 2, 横线) ＋ 倒丁 ＋ 取重复文本 (取字段尺寸 (2) ÷ 2, 横线) ＋ 倒丁 ＋ 取重复文本 (取字段尺寸 (3) ÷ 2, 横线) ＋ 倒丁 ＋ 取重复文本 (取字段尺寸 (4) ÷ 2, 横线) ＋ 倒丁 ＋ 取重复文本 (取字段尺寸 (5) ÷ 2, 横线) ＋ 倒丁 ＋ 取重复文本 (取字段尺寸 (6) ÷ 2, 横线) ＋ 倒丁 ＋ 取重复文本 (取字段尺寸 (7) ÷ 2, 横线) ＋ 上左
编辑框2.内容 ＝ x ＋ w ＋ y ＋ z
x ＝ “”
w ＝ “”
z ＝ “”

子程序：表格

横线 ＝ “─”
左线 ＝ “┐”
右线 ＝ “┌”
十线 ＝ “┼”
上左 ＝ “┘”
上右 ＝ “└”
中左 ＝ “┤”
中右 ＝ “├”
倒丁 ＝ “┴”
丁线 ＝ “┬”

其中字段可根据自己的需要而设


多记录浏览在数据库应用程序中是常常用到的，它给数据的查询、统计、汇总等带来方便。
   这一讲仍然以一个简单的学生成绩总表来作例程，让大家了解如何整齐地显示所有数据。
   ★、第一步：规划用户界面。

   ⑴、画一个大大的编辑框用来显示所有记录。
   ⑵、在编辑框上方排一行5个标签。
   ⑶、画一个按钮。

   ★、第二步：设置对象属性。

   五个标签的标题分别是“学号”、“姓名”、“语文”、“数学”、“英语”，五个标签的宽度与编辑框等宽，均匀地排列在编辑框上方。按钮的标题是“显示”。将编辑框设置纵向滚动条。

   ★、第三步：编写事件过程代码。

子程序：_按钮1_被单击

局部容器：容器1   数据类型：整数型
局部容器：容器2   数据类型：整数型

打开 (#chj数据库, , , , , , )
置当前库 (“chj”)
标签2.标题 ＝ 到文本 (取记录数 ())
标签4.标题 ＝ 到文本 (取字段数 ())
计次循环首 (取记录数 (), 容器1)
   计次循环首 (取字段数 (), 容器2)
       编辑框1.加入文本 (取文本左边 (到文本 (读字段 (容器2, )) ＋ 取空白文本 (12), 12))
   计次循环尾 ()
   编辑框1.加入文本 (#换行符)
   跳过 ()
计次循环尾 ()
关闭 (#chj数据库)
按钮1.禁止 ＝ 真

   ※、程序解析：这一子程序用到了较复杂的区块循环（循环之内又有循环），其流程如下——
   ⑴、先执行的是下面这个循环：

   计次循环首 (取字段数 (), 容器2)
       编辑框1.加入文本 (取文本左边 (到文本 (读字段 (容器2, )) ＋ 取空白文本 (12), 12))
   计次循环尾 ()

   上面的循环的意思是：
   先在编辑框加上首记录的字段1的文本，再进入循环依次加入字段2、字段3、字段4、字段5的文本，循环次数等于字段总数。
   ⑵、为了使各字段整齐地显示出来，用这个代码：编辑框1.加入文本 (取文本左边 (到文本 (读字段 (容器2, )) ＋ 取空白文本 (12), 12)) 。它的意思是每次循环（每加入一个字段的文本）加入的文本总字符数是12字节（包括空白字符），加入的空白字符数最多是12字节，这样即使该字段没有文字，其所占的位置仍然是12字节。这样各字段的文本就会整齐地显示在编辑框里。
   ⑶、添加完某记录的各字段文本后再换行，然后用“跳过 ()”指向下一记录再进入大循环，即依次循环到下一记录（循环次数等于记录总数），再依次添加各字段文本。

   ★、第四步：运行测试程序。

   假设用“编辑框1.加入文本 (到文本 (读字段 (容器2, )))”代替上面“编辑框1.加入文本 (取文本左边 (到文本 (读字段 (容器2, )) ＋ 取空白文本 (12), 12))
”，试比较一下显示效果会怎样。

--------------------------------------------------------------------------------


我们说过用数据提供者、数据源等控件配合可以自动生成记录显示的程序界面，虽然很方便，但它们能实现的功能还是有限的，灵活性也不够。比如，删除数据就直接删了，连个提示信息都没有，而正规一点的程序都应先弹出一个警告框，问你是否真的要删除数据。
   所以这一讲，我们就来看看不用数据源、报表等控件怎样实现记录的显示、增删与跳转。我们会给删除按钮补充一个信息框，先询问你是否真的要删除数据，“添加”按钮给补充一个获得焦点语句使其在确认添加后能将焦点（这里指的就是光标）移到第一个编辑框上。这样就使数据的输入变得方便了。下面我们就来看看所需要的功能是如何实现的，继续沿用前面课程的学生成绩管理库（“chj.edb”）作为例库。

   ★、界面设计

   在启动窗口上放上名称分别为“学号编辑框”、“姓名编辑框”、“语文编辑框”、“数学编辑框”和“英语编辑框”这五个编辑框（数据处理者），用来输入数据或显示记录的各个字段。再在下方放上标题为“添加”、“删除”、“更新”、“退出”、“首记录”、“向前”、“向后”、“尾记录”这八个按钮，名称分别是“添加按钮”、“删除按钮”、“更新按钮”、“退出按钮”、“首记录按钮”、“向前按钮”、“向后按钮”、“尾记录按钮”。

   ★、功能实现

   ㈠、数据记录的显示

   我们在这里先设置载入程序界面时就显示首记录，并且使第一个编辑框获得焦点。子程序如下：

              子程序：__启动窗口_创建完毕

              打开 (#chj数据库, , , , , , )
                  ※ 打开数据库时默认（初始）的记录指针在首记录上
              置当前库 (“chj”)
              学号编辑框.获取焦点 ()
              填充 ()

    具体实现首记录的显示要调用填充子程序。为什么要把首记录的显示另外放一个子程序呢？直接在“__启动窗口_创建完毕”子程序里放置显示记录的代码不就行了吗？原因是在其他子程序里也要显示运行后的结果（显示当前记录），所以我们把显示记录的代码另外做一个模块（子程序），以供各个子程序调用，也方便以后的修改维护。尤其是大型程序，当多个子程序都有相同的代码的时候，我们最好把这些代码另组模块来调用。在软件工程中，模块分析和建立是非常重要的，在这里我们也要学习一下。显示数据记录的子程序如下：

             子程序：填充

             如果真 (首记录前 () 或 尾记录后 ())
                 ※ 判断记录指针是否到了首记录前面或超过了尾记录
                 连续赋值 (“”, 学号编辑框.内容, 姓名编辑框.内容, 语文编辑框.内容, 数学编辑框.内容, 英语编辑框.内容)
                 返回 ()
            如果真结束
            学号编辑框.内容 ＝ 到文本 (读 (1))
                ※用编辑框来显示记录字段
            姓名编辑框.内容 ＝ 读 (2)
            语文编辑框.内容 ＝ 到文本 (读 (3))
            数学编辑框.内容 ＝ 到文本 (读 (4))
            英语编辑框.内容 ＝ 到文本 (读 (5))

   ㈡、数据记录的删除

   在删除记录的子程序中，我们要做几样工作：先给要删除的记录加上删除标记，再彻底删除，然后清空该记录显示，再使第一个编辑框获得焦点以方便再次输入数据，在删除之前给予提醒，让你决定是否真的删除。子程序如下：

             子程序：_删除按钮_被单击

             如果真 (信息框 (“警告！你真的要删除该数据吗？删除了就不可恢复，造成严重经济损失本人概不负责，望三思！”, 52, “警告！”) ＝ 5)
                 删除 ()      ※ 给要删除的记录加上删除标记
                 彻底删除 ()
                 连续赋值 (“”, 学号编辑框.内容, 姓名编辑框.内容, 语文编辑框.内容, 数学编辑框.内容, 英语编辑框.内容)
                 学号编辑框.获取焦点 ()
             如果真结束

   ㈢、修改数据记录

   修改记录的命令格式是：修改 （［修改数据］，… ）。子程序如下：

                 子程序：_更新按钮_被单击

                 如果 (修改 (文本到数值 (学号编辑框.内容), 姓名编辑框.内容, 文本到数值 (语文编辑框.内容), 文本到数值 (数学编辑框.内容), 文本到数值 (英语编辑框.内容)) ＝ 假)
                      信息框 (“修改失败！”, 4, “失败”)
                 否则
                      信息框 (“修改成功！”, 4, “成功”)
                 如果结束

   ㈣、到首记录（将记录指针移到首记录）

   到首记录的语句是：到首记录 （）。子程序如下：

                 子程序：_首记录按钮_被单击

                 到首记录 ()
                 填充 ()     ※ 显示首记录各字段
   ㈤、到尾记录

                 子程序：_尾记录按钮_被单击

                 到尾记录 ()
                 填充 ()     ※ 显示尾记录各字段

   ㈥、向前

   将当前数据库中当前记录指针向前移动一条记录，并显示。移动记录的语句是：跳过 （［欲跳过的记录数］）。该命令的默认值为 1 ，即向后移动一条记录。子程序如下：

                 子程序：_向前按钮_被单击

                 如果真 (取记录号 () ＞ 1)
                         ※ 使记录指针不要移到首记录之前
                     跳过 (-1)
                         ※ “-1”表示指针向前移动一条记录
                     填充 ()
                         ※  显示指针移动的记录的各个字段
                 如果真结束

   ㈦、向后

                  子程序：_向后按钮_被单击

                  如果真 (取记录号 () ＜ 取记录数 ())
                         ※ 使记录指针不会超出尾记录
                      跳过 ()
                         ※ 该命令的默认值为 1 ，即向后移动一条记录
                      填充 ()
                  如果真结束

   ㈧、添加数据记录

   为了不用多开一个窗口来添加记录，我们加上判断：当添加按钮的标题为“添加”时就清空编辑框以便输入添加的数据，然后使添加按钮的标题变为“保存”。当添加按钮的标题变为“保存”时就添加记录。添加记录也最好加上提示信息。子程序如下：

                 子程序：_添加按钮_被单击

                 如果 (添加按钮.标题 ＝ “添加”)
                     添加按钮.标题 ＝ “保存”
                     学号编辑框.获取焦点 ()
                     连续赋值 (“”, 学号编辑框.内容, 姓名编辑框.内容, 语文编辑框.内容, 数学编辑框.内容, 英语编辑框.内容)
                否则
                    如果 (加记录 (文本到数值 (学号编辑框.内容), 姓名编辑框.内容, 文本到数值 (语文编辑框.内容), 文本到数值 (数学编辑框.内容), 文本到数值 (英语编辑框.内容)) ＝ 假)
                        信息框 (“添加记录失败！”, 0, “添加失败”)
                    否则
                        信息框 (“已成功添加为尾记录”, 0, “添加成功”)
                    如果结束
                如果结束

   （例程下载：http://www.91asp.com/bbs.nsf/c53885e4b38488454825681f0035243d/88fbcd16567942de48256bef0024560c/$FILE/_l2f5fq4turk9svl0jpav0_.zip   ）


用DSN连接比较麻烦，下面是一些数据库的接连代码，希望对大家有用。

MS Access ODBC DSNless 连接
Driver={Microsoft Access Driver (*.mdb)};Dbq=c:\somepath\dbname.mdb;Uid=Admin;Pwd=pass;

dBase ODBC DSNless 连接
Driver={Microsoft dBASE Driver (*.dbf)};DriverID=277;Dbq=c:\somepath\dbname.dbf;

Oracle ODBC DSNless 连接
Driver={Microsoft ODBC for Oracle};Server=OracleServer.world;Uid=admin;Pwd=pass;

MS SQL Server DSNless 连接
Driver={SQL Server};Server=servername;Database=dbname;Uid=sa;Pwd=pass;

MS Text Driver DSNless 连接
Driver={Microsoft Text Driver (*.txt; *.csv)};Dbq=c:\somepath\;Extensions=asc,csv,tab,txt;Persist Security Info=False;

Visual Foxpro DSNless 连接
Driver={Microsoft Visual FoxPro Driver};SourceType=DBC;SourceDB=c:\somepath\dbname.dbc;Exclusive=No;

MySQL DSNless 连接
driver={mysql}; database=yourdatabase;uid=username;pwd=password;option=16386;


 1。 在窗体上放表格、数据源、外部数据提供者各一个；
2。 设置 表格1.数据源=数据源1
        数据源1.数据提供者=外部数据提供者1；
3。 点击外部数据提供者1的“连接文本”属性，将弹出配ODBC置对话框，选择相应的*.dsn文件（如果没有，要新建一个，方法详见“ACCESS数据库使用详解.doc”）；
4。 设置 外部数据提供者1.查询SQL=“select * from books”（这里books是表名，依数据库而定）；
5。 运行。

这样就完成了用表格控件显示Microsoft Access数据库的任务。
千万注意：数据源的删除记录按钮不可随便点击。该操作是不可逆的。


窗口程序集：窗口程序集1

程序集容器：编辑框内容已改变

------------------------------

子程序：显示

局部容器：容器1   数据类型：整数型
局部容器：容器2   数据类型：整数型

打开 (编辑框2.内容, , , , , , )
置当前库 (编辑框2.内容)
计次循环首 (取记录数 (), 容器1)
   计次循环首 (取字段数 (), 容器2)
       编辑框1.加入文本 (取文本左边 (到文本 (读字段 (容器2, )) ＋ 取空白文本 (12), 12))
   计次循环尾 ()
   编辑框1.加入文本 (#换行符)
   跳过 ()
计次循环尾 ()
关闭 (编辑框2.内容)

------------------------------

子程序：_选择数据库_被单击

通用对话框1.打开 ()
编辑框2.内容 ＝ 通用对话框1.文件名
显示 ()

------------------------------

子程序：_转换_被单击

保存文件 ()

------------------------------

子程序：_选择保存名_被单击

通用对话框2.打开 ()
编辑框3.内容 ＝ 通用对话框2.文件名

------------------------------

子程序：保存文件
返回值类型：逻辑型

参数：文件名      数据类型：文本型  <可空>

局部容器：文件号  数据类型：整数型
局部容器：现在文件名    数据类型：文本型  <静态>
局部容器：rq66    数据类型：整数型

现在文件名 ＝ “”
现在文件名 ＝ 选择 (是否为空 (文件名), 现在文件名, 文件名)
如果真 (现在文件名 ＝ “”)
   现在文件名 ＝ 编辑框3.内容 ＋ “.txt”
如果真结束
文件号 ＝ 打开文件 (现在文件名, #重写, )
如果 (文件号 ≠ 0)
   写出文本 (文件号, 编辑框1.内容)
   关闭文件 (文件号)
   信息框 (“保存文件成功”, 0, )
   编辑框内容已改变 ＝ 0
否则
   信息框 (“保存文件失败”, #警告图标, )
如果结束
关闭 (编辑框2.内容)


易本身的数据库操作有时较麻烦，比如合并或分解易数据库，要在两个数据库之间往返手工操作，所以用代码加载较方便一点。但一般的用代码操作易数据库的合并或分解，只针对固定的数据库文件名、固定的记录条件和字段范围。为了使这两项的操作更方便，下面提供比较通用的合并和分解易数据库的例程。
   由于嫌麻烦，这里只提供例程代码，先不作解说，等以后再慢慢补充：

 窗口程序集：窗口程序集1

------------------------------

子程序：_按钮1_被单击

载入 (窗口1, , 真)

------------------------------

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

载入 (窗口2, , 真)

窗口程序集：复制记录程序集

------------------------------

子程序：_按钮1_被单击

局部容器：记录号范围1   数据类型：整数型
局部容器：记录号范围2   数据类型：整数型
局部容器：数据名称      数据类型：文本型
局部容器：复制条件      数据类型：文本型
局部容器：字段范围      数据类型：文本型
局部容器：当前数据库    数据类型：文本型

当前数据库 ＝ 编辑框4.内容
打开 (当前数据库, , , , , , )
数据名称 ＝ 编辑框3.内容
记录号范围1 ＝ 文本到数值 (编辑框1.内容)
记录号范围2 ＝ 文本到数值 (编辑框2.内容)
复制记录 (数据名称, 取记录号 () ＞ 记录号范围1 且 取记录号 () ＜ 记录号范围2, 字段范围)
如果真 (复制记录 (数据名称, 取记录号 () ＞ 记录号范围1 且 取记录号 () ＜ 记录号范围2, 字段范围) ＝ 真)
   信息框 (“复制成功！”, 0, “操作成功”)
如果真结束

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

通用对话框1.打开 ()
编辑框4.内容 ＝ 通用对话框1.文件名

窗口程序集：添加记录程序集

------------------------------

子程序：_按钮1_被单击

局部容器：记录号范围1   数据类型：整数型
局部容器：记录号范围2   数据类型：整数型
局部容器：数据名称      数据类型：文本型
局部容器：复制条件      数据类型：文本型
局部容器：字段范围      数据类型：文本型
局部容器：当前数据库    数据类型：文本型

当前数据库 ＝ 编辑框4.内容
打开 (当前数据库, , , , , , )
数据名称 ＝ 编辑框3.内容
记录号范围1 ＝ 文本到数值 (编辑框1.内容)
记录号范围2 ＝ 文本到数值 (编辑框2.内容)
添加 (数据名称, 取记录号 () ＞ 记录号范围1 且 取记录号 () ＜ 记录号范围2, 字段范围)
如果真 (添加 (数据名称, 取记录号 () ＞ 记录号范围1 且 取记录号 () ＜ 记录号范围2, 字段范围) ＝ 真)
   信息框 (“添加成功！”, 0, “操作成功”)
如果真结束

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

通用对话框1.打开 ()
编辑框4.内容 ＝ 通用对话框1.文件名


                解决ODBC数据库连接问题教程   作者：Wind Promise

这几天已经有许多人联系我，问如果解决数据库连接问题，现把方法写给大家：

要连接已经有数据库，注意不是第一次连接，以后就会自己打开的那种，而是在程序中已经进行关联了，而且会随程序和数据库的位置改变而改变。方法是：

外部数据库.打开（［ODBC数据源连接文本］，［是否只读］）

这样就可以成功的打开数据库了，数据库联接文本指的是什么呢？就是和数据库联接时要操作的数据库参数，那么要如何知道联接文本呢？应该是什么呢？下面就是联接本文的内容：

ODBC;DBQ=d:\Downloads\e21\MSAccess.mdb;DefaultDir=d:\Downloads\e21;Driver={Microsoft Access Driver (*.mdb)};DriverId=25;FIL=MS Access;FILEDSN=C:\Program Files\Common Files\ODBC\Data Sources\a.dsn;MaxBufferSize=2048;MaxScanRows=8;PageTimeout=5;SafeTransactions=0;Threads=3;UID=admin;UserCommitSync=Yes;

结合命令起来就是：

外部数据库.打开（"ODBC;DBQ=d:\Downloads\e21\MSAccess.mdb;DefaultDir=d:\Downloads\e21;Driver={Microsoft Access Driver (*.mdb)};DriverId=25;FIL=MS Access;FILEDSN=C:\Program Files\Common Files\ODBC\Data Sources\a.dsn;MaxBufferSize=2048;MaxScanRows=8;PageTimeout=5;SafeTransactions=0;Threads=3;UID=admin;UserCommitSync=Yes;
"，）

（注意哦不要忘了""号）

现在具体说明一下，这里头的参数：

ODBC;DBQ=d:\Downloads\e21\MSAccess.mdb；  （指数据库所在位置）
DefaultDir=d:\Downloads\e21；             （指数据库所在目录）
Driver={Microsoft Access Driver (*.mdb)}；（指数据库何种类型）
FILEDSN=C:\Program Files\Common Files\ODBC\Data Sources\a.dsn （DSN文件位置）
UID=admin  （数据库可访问的用户名，如果你没有设置用户安全设置，就不起作用）
PASS=admin  （你设置访问密码后，UID就会生效，注意要先用ACESS里设置密码，这个功能可自行使用）
其它参数可以不用去管他，当然是有它们的意义，以后再说啦，参数并不单只有这些还很多。

当然大家还要问，上面的文件路径就只能死死的定义吗？如果我的文件位置改变了，不就不能使用了吗？其实你只要把上面的路径改成活动的就行了，如用取当前目录命令，当然前提是所有程序及数据库都在同一目录下，还有的是DSN和MDB文件都应该是事先已经建立好的。大家可以使用  易语言附的文件格式转换程序来建立，建立后那个转换的窗口就不要管他啦，当然你也可以用  LIGO的全面操作Access数据库这个程序来建立，建立完其它的就不管他，就只管取出刚建立的那两个文件来利用就行了。

就先说到这里吧，如果你还有什么问题，就跟贴啦！

顺便说一下，LIGO的全面操作Access数据库有个认识上的错误，就是数据库是允许接受空字符的，而不需要在程序中对空字符进行赋值！！！这种做法，大家可以想像如果我有一百个字段，那不是要死人，一百个都要判断是否是空字符，如果是还要赋值！！！解决方法是在建立数据库字段的时候，将字段允许接受空字符属性设置为是。就可以了。


窗口程序集：窗口程序集1

------------------------------

子程序：_插入行_被单击

如果真 (编辑框1.内容 ≠ “”)
   打开 (编辑框1.内容, , , , , , )
   复制记录 (“haha1.edb”, 取记录号 () ＜ 表格1.取光标行号 (), )
   复制记录 (“haha2.edb”, 取记录号 () ≥ 表格1.取光标行号 (), )
   打开 (“haha1”, , , , , , )
   置当前库 (“haha1”)
   加空记录 ()
   打开 (“haha2”, , , , , , )
   置当前库 (“haha1”)
   添加 (“haha2”, , )
   置当前库 (编辑框1.内容)
   清空 ()
   添加 (“haha1”, , )
   关闭 (“haha1”)
   关闭 (“haha2”)
   删除文件 (“haha1.edb”)
   删除文件 (“haha2.edb”)
   数据库提供者1.数据库文件名 ＝ 编辑框1.内容
   数据源1.添加 (数据库提供者1, , )
   关闭 (编辑框1.内容)
如果真结束

------------------------------

子程序：_选择数据库_被单击

通用对话框1.打开 ()
编辑框1.内容 ＝ 通用对话框1.文件名
数据库提供者1.数据库文件名 ＝ 通用对话框1.文件名
数据源1.添加 (数据库提供者1, , )
打开 (编辑框1.内容, , , , , , )
标签2.标题 ＝ 到文本 (取记录数 ())
标签4.标题 ＝ 到文本 (取字段数 ())
关闭 (编辑框1.内容)

------------------------------

子程序：__启动窗口_创建完毕

通用对话框1.初始目录 ＝ 取当前目录 ()

------------------------------

子程序：_删除行_被单击

置当前库 (编辑框1.内容)
数据源1.删除行 (表格1.取光标行号 (), )
关闭 (编辑框1.内容)


“用ODBC操纵MS_Access数据库”

演示用ODBC操纵MS_Access数据库。
关键是“外部数据库”组件的使用，提供了详细的解说,且附带一个Word帮助文档。

以下是全部源代码：

//----------------------------------------------------------------------------
窗口程序集：窗口程序集1

程序集容器：记录集句柄  数据类型：整数型

------------------------------

子程序：_连接外部数据库按钮_被单击

如果真 (外部数据库1.打开 (, ))
   记录集句柄 ＝ 外部数据库1.查询 (“select * from books”)
    *备注：books: 是数据库中“表”的名称，表的名称在设计数据库时就已经决定了。“select * from books”是一个SQL语句，意思就是选择(select)"表books"中的所有字段。
   如果 (记录集句柄 ＝ 0)
       信息框 (“查询失败！”, 0, )
   否则
       外部数据库1.到首记录 (记录集句柄)
       读取并显示当前记录 ()
       ※备注：连接成功之后，立即显示第一条记录。
   如果结束
如果真结束

------------------------------

子程序：__启动窗口_将被销毁

外部数据库1.关闭记录集 (记录集句柄)
外部数据库1.关闭 ()
※备注：两者都要关闭！别忘了！

------------------------------

子程序：_查看连接文本按钮_被单击

信息框 (外部数据库1.取连接文本 () ＋ #换行符 ＋ #换行符 ＋ “以上仅供参考。Liigo向各位问好！”, 0, “当前ODBC数据源连接文本（由” ＋ #左引号 ＋ “取连接文本()” ＋ #右引号 ＋ “获得）：”)
※备注：调用命令“取连接文本 ()”以获取数据源连接文本。获取的文本只是让大家有一些感性认识，此处不用。

------------------------------

子程序：_查看前一记录按钮_被单击

外部数据库1.到前一记录 (记录集句柄)
如果 (外部数据库1.首记录前 (记录集句柄))
   信息框 (“前面已无记录！”, 0, )
   外部数据库1.到首记录 (记录集句柄)
否则
   读取并显示当前记录 ()
如果结束

------------------------------

子程序：_查看后一记录按钮_被单击

外部数据库1.到后一记录 (记录集句柄)
如果 (外部数据库1.尾记录后 (记录集句柄))
   信息框 (“后面已无记录！”, 0, )
   外部数据库1.到尾记录 (记录集句柄)
否则
   读取并显示当前记录 ()
如果结束

------------------------------

子程序：_首记录按钮_被单击

外部数据库1.到首记录 (记录集句柄)
读取并显示当前记录 ()

------------------------------

子程序：_尾记录按钮_被单击

外部数据库1.到尾记录 (记录集句柄)
读取并显示当前记录 ()

------------------------------

子程序：读取并显示当前记录
备注：这是自定义子程序

编辑框1.内容 ＝ 到文本 (外部数据库1.读 (记录集句柄, 1))
编辑框2.内容 ＝ 外部数据库1.读 (记录集句柄, 2)
编辑框3.内容 ＝ 外部数据库1.读 (记录集句柄, 3)
编辑框4.内容 ＝ 外部数据库1.读 (记录集句柄, 4)
编辑框5.内容 ＝ 外部数据库1.读 (记录集句柄, 5)
编辑框6.内容 ＝ 到文本 (外部数据库1.读 (记录集句柄, 6))
编辑框7.内容 ＝ 外部数据库1.读 (记录集句柄, 7)

※备注：以上7行分别读取数据库中的7个字段信息，并显示到对应的编辑框中。
※备注：命令“读（）”所返回的数据的数据类型，就是设计数据库时确定的数据类型（不确切，但可以这么理解）。因为要把它们显示到编辑框中，所以不是“文本型”的要进行类型转换。
※备注：命令“读（）”的第二个参数也可以是字段名称。如上面的第一行就等价于： 编辑框1.内容 ＝ 到文本 (外部数据库1.读 (记录集句柄, “编号”))。 “编号”是什么？数据库的第一个字段的名称呀！是设计数据库时就确定的。
※备注：有人问，你Liigo怎么知道这个数据库有7个字段？你又怎么知道的各字段的数据类型和名称？哈哈，我设计的数据库，我当然知道了！（如果要操纵别人设计的数据库，也必须事先了解这些信息。）
※备注：您的朋友Liigo祝你生活愉快！ Liigo@chinaren.com       2002/3/20

------------------------------

子程序：_退出按钮_被单击

销毁 ()

/////////////////////////////////////////////////////////////源代码结束。

另注：用“外部数据库．执行（）”可以处理其它SQL语句如：Insert Update Delete...


从这一讲开始讲解与数据库密切相关的控件的使用方法。
   ㈠、数据源控件和数据库提供者控件的含义和使用。
   数据源控件（Data控件）是一个功能强大的数据访问软件。使用数据源控件我们可以做到不编写任何代码或只编写少量代码，就能对数据库中的数据进行查询、添加、删除、更新等基本操作。数据源控件的主功能属性是“数据提供者”，用于指定提供数据的一方。
   数据源用作在数据处理者和数据提供者之间起协调和数据桥接的作用：
    1、为所有基于本数据源的数据处理者提供来自数据提供者的数据；
    2、将数据处理者处理后的数据写回到数据提供者中；
    3、如果更换数据提供者或数据提供者内的数据发生改变，将自动通知所有基于本数据源的数据处理者。
   怎样运用数据源控件？比如我们在窗口上只画上一个数据源控件，想设置它的“数据提供者”属性值，发现无法设置，原因是易语言数据源控件无法直接连接数据库，要通过其他控件导入数据库，再通过导人数据的控件设置“数据提供者”的属性值，为此我们还需要配合导人数据的控件来使用。易语言导人数据库的控件是“数据库提供者”控件。
   用易语言数据框架图来表示一下与数据库相关的控件的使用关系就是：
              数据库→数据提供者→数据源→数据处理者
    数据提供者仅仅负责为数据源提供数据的获取和存储方法，即数据操作接口。目前有“通用提供者”和“数据库提供者”两种，以后还要继续增加，譬如“远程数据提供者”等等。
    数据提供者的主功能属性是“数据库文件名”，用来设置需要连接的数据库。
    各类数据提供者所支持的数据操作接口可能不相同，下面列出目前两种数据提供者的相关情况：
    1、通用提供者：
      使用内存作为数据的存储仓库，全面支持所有数据操作接口。因此必要时可以将其它类型数据提供者内的数据导入到此类型中，以全面发挥数据源对数据的操纵能力。
    2、数据库提供者：
    使用数据库作为数据的存储仓库，不支持以下数据操作接口：
       1、置行高； 2、置类型； 3、置文本色； 4、置背景色； 5、置字体名； 6、置字体尺寸；  7、置字体属性； 8、置边距； 9、置文本输入格式； 10、置对齐方式； 11、置密码方式； 12、合并； 13、分解； 14、加线条； 15、删线条； 16、初始尺寸时同时改变列数； 17、在中间插入行； 18、插入列； 19、删除列。
     如果想对数据进行以上操作，应该先将数据通过数据源导出到通用提供者中。

   ㈡、数据源控件和数据库提供者控件的使用例程：学生成绩管理。
   本实例就是通过数据源控件来访问“学生成绩.edb”这个数据库，对该数据库进行顺序查询，并将所得的数据记录通过“学号”、“姓名”、“数学”、“语文”、“英语”对应的编辑框（用来作为数据处理者）显示出来。
   这五个编辑框怎样才能作为数据处理者？需要对这五个编辑框设置两个重要的属性，一个是“数据源”属性，用于指定所使用的数据访问控件，即数据源控件；一个是“数据列”属性，用于绑定数据库中的相应字段，比如“编辑框1”用来显示“学号”字段，“编辑框2”用来显示“姓名”字段、、、这样绑定之后，我们所做的程序界面就可以和数据库端保持同步了，也就是数据库端所做的改变不仅会在我们这个程序界面中反映出来，而且我们在程序界面所做的变动也会使数据库端的数据发生相应的变动。

   步骤一：创建程序界面及学生成绩数据库。
       创建五个编辑框，分别用五个标签起名为“学号”、“姓名”、“数学”、“语文”、“英语”。
       创建一个数据库提供者控件，一个数据源控件。
       创建学生成绩数据库，包括“学号”、“姓名”、“数学”、“语文”、“英语”五个字段。
   步骤二：设置各控件的主功能属性值。
       ⑴、设置数据库提供者控件的主功能属性“数据库文件名”的属性值为你目录下的数据库文件名，即“学生成绩.edb”。
       ⑵、设置数据源控件主功能属性“数据库文件名”的属性值为“数据库提供者1”。
       ⑶、设置五个编辑框的“数据源”属性值为“数据源1”，再设置这五个编辑框的数据列属性的属性值分别为“学号”、“姓名”、“数学”、“语文”、“英语”，以使编辑框绑定数据库的相关字段，可在下拉列表中选择。
   步骤三、编写下列简单的代码（这一步不用也行）：

子程序：__启动窗口_创建完毕

打开 (“#学生成绩数据库”, , , , , , )
标签8.标题 ＝ “学生总人数: ” ＋ 到文本 (取记录数 ()) ＋ “人”

   步骤四、运行程序。
   对数据源控件进行操作。数据源控件的六个按钮从左到右排列分别是“到首记录”、“向前”、“向后”、“到尾记录”、“添加空记录”、“删除”。也就是说我们可以运用数据源控件，不用编写代码就可以进行六种操作。


教你几招（一）

   ㈠、如果你嫌打开易语言时的“新建工程”对话框碍事，可以将左下角的“启动后不再显示此对话框”选中，这样，以后再启动易语言时就会自动帮你创建一个新程序了。
   ㈡、可以对同类或不同类控件进行批量操作，以减少有关设置的时间。比如你想把界面中所有的编辑框控件的背景颜色属性值都定为蓝色，可以选定所有编辑框进行操作。方法是按住“shift”键，再一一用鼠标左键选中所有编辑框，然后在工作夹中的属性区设置背景颜色为蓝色。又如想将界面所有控件进行居中对齐，用以上方法选中所有控件，再在工具栏中选择居中对齐按钮。又如删除多个控件的方法也是一样。
   ㈢、在windows里，关闭任何一个当前的程序都可按[Alt]+[F4]，关闭易语言当然也不例外。
   ㈣、如果我们想打开不久前刚打开过或刚创建好的程序，较快的方法就是选易系统中的“程序”菜单，再在“编译版本”子菜单和“退出”子菜单之间的子菜单选择你要打开的程序。
   ㈤、很多菜单的操作都有对应的快键方式，如选中“文件”菜单，再按[o]键，即可弹出“新建”对话框。
   ㈥、我们要删除某个控件，只需选中它，按下[Delete]键即可。
   ㈦、要删除图片框中的图片，可在属性设置夹里找到该图片框的“图片”属性，删除里面所设置的属性值即可。
   ㈧、可以一次性创建多个同样的控件：先按住[Shift]键不放，再点中要使用的控件，好了，你可以在窗口随便画多个同类控件了。什么时候画完了，松开[Shift]即可。
   ㈨、选中某一控件，再按住[Shift]+[方向键]，可以改变该控件的大小尺寸。
   ㈩、要使弹出的信息框自动消失，按[Esc]键即可取消其显示。

              （下期再续）


注：下面这几招都很菜，非新手不要看。
   （十一）、如果想要在编辑框里实现首行缩进，只要在输入文本时先按下空格键将前两个空格空出，再输入文字即可。
   （十二）、如果我们将窗口的“控制按钮”属性设为真，那么窗口标题栏上的最大化、最小化和关闭按钮都会消失，连最左边的控制栏图标都不见了，只剩下窗口的标题文字了，自己试试看吧。
   （十三）、如果我们想使窗口出现最大化按钮和最小化按钮，只要将窗口的“最大化按钮”和“最小化按钮”的属性值设置为真即可。
   （十四）、有三种方法可以从代码编辑窗口返回到界面设计窗口，第一种方法是用[Ctrl]+[Tab]键来切换，第二种方法是选“工作夹→程序子夹→窗口→[想打开的窗口]”，第三种方法是分别切换到界面编辑区和代码编辑区，再分别在菜单项中选“窗口→层叠或平铺”，这样界面编辑区和代码编辑区都显现出来。
   （十五）、当我们要在代码编辑窗口内或两个代码编辑窗口之间复制、粘贴代码时，可用快捷键进行上述编辑，复制代码的快捷方式是：选中要复制的代码，然后按[Ctrl]+[C]键，即可将代码复制，粘贴的快捷键是[Ctrl]+[V]。
   （十六）、当我们用编辑框来显示数据字段时，如果不想使编辑框能输入文本，以便使我们能正确浏览编辑框内显示的数据，可以将编辑框“禁止”属性设为真，或将“输入方式”的属性值设为只读方式。
   （十七）、如果我们想扩充编辑区的纵向面积，可在菜单中选“查看→工具条→工作与状态组合夹”，那么占领整个下方的状态组合夹就会被挤到左下角，与工作夹连在一起。
   （十八）、如何复制、粘贴代码？ 对于这个来说，现在的易语言版本没有解决这个问题，但也不是没有办法的。有两法： ⑴、如果是将代码从这个编辑窗复制到另一个编辑窗，可用shift键选中要复制的部分，然后再复制粘贴到另一代码编辑窗，或者可用“全选”，再复制、粘贴该窗口所有码。⑵、如果是要复制到其他地方（比如记事簿），在复制好后，在菜单栏中选“编辑→复制程序文本”，再粘贴到相关地方。
   （十九）、如果嫌用中文输入代码不够快，可用简拼输入。如果你习惯用英文输入，易语言的代码编写也可以只用英文。可以使用“程序 -> 系统配置 - 输入夹 - 默认输入法”菜单功能修改当前默认输入法。若要用英文输入，将在当前默认输入法设为“首拼及全拼输入法”即可。
   （二十）、查询易语言的帮助文件有两法：⑴、在菜单项中选“帮助->易语言知识库”；⑵、如欲对系统中各运行支持库内的命令、库定义数据类型、库定义常量、对象属性等等知识进行查找，请在易系统启动后，直接在工作夹内的支持库夹中单击对应的所欲查找其信息的项目，此时所有的相关信息将会显示在系统的提示夹或者状态行中。
    第二种方法不但可以单项显示易语言知识库里的所有信息，还包括中文编程语言与英文编程语言的单项对照。


下面的臭招还没有写完，积到有10个臭招本贴才算写完：

   ★、如何把非启动窗口改为启动窗口？方法：把原"_启动窗口"改为别的名字，把要设置为启动窗口的窗口名改为"_启动窗口" 。如何输入“启动窗口”前的那条下画线？ 用英文输入法+"shift"+"-"就出来了。
   ★、窗口标题的功能跟标签差不多，都是用来显示文本，所以有很多时候用到标签的地方我们也可以用窗口标题来代替，如：_启动窗口.标题 ＝ 到文本 (取现行时间 ())


一、何为易模块？

    易模块实际上是一个特殊的易程序，它是供其他程序调用的外部易程序，即将外部程序制成模块，导入易语言系统后供其他程序调用。易模块对于扩展易系统命令、增强易语言的功能具有深远的意义。它与普通的易程序相比，有以下特点：

    １、必须具有程序名称（通过“程序->程序配置”菜单设置），此名称代表模块名称；

    ２、必须具有“_启动子程序”，此子程序负责进行易模块的初始化；

    ３、必须具有名为“_接口程序集”的程序集，此程序集用作公开此易模块的对外接口，其中的所有子程序均可由外部程序直接调用。

   二、如何调用易模块？

   在某个程序中调用易模块的步骤可以归结为“两次导入、一次调用”，即先将下载的易模块导入易语言系统中，再将该模块导入到你要调用该模块的程序中（即“创建接口程序集”），然后调用模块中的子程序。具体步骤如下：

   1、将易模块导入易系统
      选择易语言主菜单“程序->易模块管理”，在弹出的“易模块管理对话框”中，单击左下角的“导入新模块”按钮，然后从磁盘中选择你要导入的易模块文件即可。（导入易模块只需一次，以后再使用就不必导入了。）
      另外需要提出的是，一些易模块作者在提供易模块下载时，会附带该模块的使用例程，我们在自己的机内运行该例程时，也仍然要先将该易模块导入易系统内，否则会出现找不到易模块的提示，如：打开程序“D：//易程序下载/×××.ec”失败。
   2、创建易模块的接口程序集（将该模块导入到你要调用的程序中）
      首先打开或新建一个普通的易程序，然后选择易语言主菜单“程序->易模块管理”，在弹出的“易模块管理对话框”中的左侧列表框中选中已导入的易模块，单击“创建接口程序集”按钮后，确定即可。
   3、使用易模块的接口函数（调用接口子程序）
      模块程序集创建完毕后，就可以直接使用该程序集中的子程序（接口子程序）了，就如同这些子程序是自己所编写的一样。在编译易程序时所有被使用的易模块会自动被一起编译进去。
      调用接口子程序（外部命令）跟调用系统命令（系统函数）差不多，只不过由于易模块并非易系统原有的，所以要经过“两次导入”才能被调用。
      调用系统命令的格式是：
               命令（参数1，参数2，...）
               如：信息框 （提示信息，按钮，［窗口标题］）
      而调用易模块中的子程序（接口子程序）的格式也一样：
               接口子程序（参数1，参数2，...）
               如：信息提示框 （提示文本）
      怎样知道你要调用的接口子程序的参数有哪些？很简单，选“工作夹→程序→程序数据→模块”，找到该模块中要调用的子程序，由于建立子程序用到的是表格型代码，表格中包含子程序名、参数、容器等数据，你找到该子程序表格有哪些参数就行了。
     或者选菜单“程序→易模块管理→创建接口程序集”，在相关接口子程序的信息提示中就有调用格式的提示，如：“调用格式：〈无返回值〉 信息提示框 （提示文本）”。

     至于怎样制作自己的易模块，下一次讲。


源程序如下：

子程序：_启动子程序
返回值类型：整数型
备注：本子程序在程序启动后最先执行

cmd ＝ 读环境变量 (“ComSpec”)

子程序：执行dos命令行
返回值类型：文本型

参数：参数  数据类型：文本型

局部容器：文件长度
局部容器：文件号
局部容器：句柄

句柄 ＝ 执行 (主窗口.取窗口句柄 (), “open”, cmd, “ /c ” ＋ 参数 ＋ “>” ＋ 临时文件名, 当前目录, 0)
延时 (1000)
如果真 (句柄 ＝ 0)
   返回 (转换为字节集 (“执行命令行失败！”))
如果真结束
文件号 ＝ 打开文件 (临时文件名, #读入, )
文件长度 ＝ 取文件长度 (文件号)
延时 (250)
判断循环首 (文件长度 ≠ 取文件长度 (文件号))
*备注：等待命令行运行完毕
   文件长度 ＝ 取文件长度 (文件号)
   延时 (250)
判断循环尾 ()
返回信息 ＝ 读入文本 (文件号, )
关闭文件 (文件号)
写到文件 (临时文件名, {;  };)
*备注：清除文件内容
返回 (返回信息)

本来有更好的方法调用DOS的，那就是匿名管道技术。但因为易语言在自定义数据类型和DLL的一些限制，没有办法实现。
现在或者方法只是将DOS命令输出到文本，然后再读取来取回命令的返回信息。
这样有两个缺点：
1.命令行中不能够再有“<”、“>”字符
2.不能够得到错误信息的输出


子程序：寻找窗口
返回值类型：文本型

局部容器：窗口标题      数据类型：文本型
局部容器：窗口句柄      数据类型：整数型
局部容器：标题长  数据类型：整数型

返回信息 ＝ “窗口句柄          窗口标题” ＋ 换行符 ＋ “===========================================================” ＋ 换行符
窗口句柄 ＝ 取窗口句柄 (GetDesktopWindow (), 5)
判断循环首 (窗口句柄 ≠ 0)
   标题长 ＝ GetWindowTextLength (窗口句柄)
   如果 (标题长 ≤ 0)
       窗口标题 ＝ “”
   否则
       窗口标题 ＝ 取空白文本 (标题长)
       标题长 ＝ GetWindowText (窗口句柄, 窗口标题, 标题长 ＋ 1)
   如果结束
   如果真 (窗口标题 ≠ “” 且 窗口标题 ≠ “DDE Server Window” 且 窗口标题 ≠ “Default IME” 且 窗口标题 ≠ “OleMainThreadWndName” 且 窗口标题 ≠ “Program Manager”)
    *备注：过滤无标题窗口和一部分系统窗口
       返回信息 ＝ 返回信息 ＋ “  ” ＋ 到文本 (窗口句柄) ＋ 取重复文本 (10 － 取文本长度 (到文本 (窗口句柄)), “-”) ＋ 窗口标题 ＋ 换行符
   如果真结束
   窗口句柄 ＝ 取窗口句柄 (窗口句柄, 2)
判断循环尾 ()
返回 (返回信息 ＋ “===========================================================” ＋ 换行符)


包括从十进制到其他进制和从其他进制到十进制

子程序：十转其他
返回值类型：文本型

参数：需转换数值  数据类型：长整数型
参数：进制

局部容器：余数    数据类型：长整数型
局部容器：循环容器
局部容器：返回容器      数据类型：文本型

循环判断首 ()
   余数 ＝ 需转换数值 ％ 进制
   如果 (余数 ＜ 10)
       返回容器 ＝ 到文本 (余数) ＋ 返回容器
   否则
       返回容器 ＝ 字符 (55 ＋ 余数) ＋ 返回容器
   如果结束
   需转换数值 ＝ 需转换数值 ＼ 进制
循环判断尾 (需转换数值 ≠ 0)
返回 (返回容器)

------------------------------

子程序：其他转十
返回值类型：长整数型

参数：文本  数据类型：文本型
参数：进制

局部容器：字符    数据类型：文本型
局部容器：返回容器      数据类型：长整数型
局部容器：循环容器

计次循环首 (取文本长度 (文本), 循环容器)
   字符 ＝ 到大写 (取文本中间 (文本, 循环容器, 1))
   如果 (取代码 (字符, ) ＜ 58)
       返回容器 ＝ 返回容器 ＋ 文本到数值 (字符) × 求次方 (进制, 取文本长度 (文本) － 循环容器)
   否则
       返回容器 ＝ 返回容器 ＋ (取代码 (字符, ) － 55) × 求次方 (进制, 取文本长度 (文本) － 循环容器)
   如果结束
计次循环尾 ()
返回 (返回容器)


大家好，我叫宝贝哥哥，是你们的新朋友，也是你们学习易语言的好伙伴。
   那什么是易语言呢？
   易语言是由飞扬工作室出品的 Windows 环境下的全中文实用电脑程序编写语言，她支持现今所有的 Windows 32 位操作系统，即：Windows 9X、ME、2000、NT 等，提供了中国电脑用户开发 Windows 应用程序最方便直观、快捷实用的方法，适合于初中级别电脑用户使用。尤其是根本不懂英文或者英文了解很少的初级用户，可以通过使用本语言极其快速地进入 Windows 程序编写的大门。
   大家一听说编程就头大哦，易语言其实并不可怕，在这本书里，我会带你们一步一步地走进易语言其乐无穷的世界。
   同学们，你们一定对编程既神往又望而生畏吧？有很多人想学编程，但他们一看到满屏都是英文，通常的反映就是：“呵，还要学英文哪？”、“为什么用‘如果...就...’就可以表达清楚的意思却非要用‘if...then...’呢？”，基本上就放弃了。不是他们不想学，实在是门槛太高。我由衷地希望易语言能够在这方面帮助大家。另外易语言对于在校学生尤其合适，因为他们基本上没有或者很少有计算机专业英语能力，但在这方面的求知欲又非常强，易语言能够完全满足他们在这方面的需要，培养他们的兴趣，引导他们入门，以期得到更大的发展。易语言里面提供流程图功能很大意义上就是基于这个用户群体。还有很多DOS程序员未能成功地转向Windows，易语言对于他们也非常合适。
   易语言与其他编程语言相比，更值得我们国内大多数编程爱好者学习，可以说是学习编程最好的入门语言之一。学好了易语言，再学其他编程语言，你就会感觉很容易明白了，但是对于一般人来说，你如果先去学其他编程语言，会感觉非常困难，很容易就放弃。对于国内爱好者来说，易语言最通俗易懂、最易学，并且程序开发效率也最高。
   为什么这么说？因为易语言与其它编程语言相比，具有以下主要优点：
   一、全可视化支持。
    一般的可视化编程语言，仅支持图形用户界面的可视化设计操作，而易语言除了支持此类可视化，还支持程序流程的即时可视化呈视。即：用户在编写程序的过程中，可以即时看到当前程序的运行流程及路线，以助于培养编程思路，提高解决编程问题的能力；
   二、全中文支持。
   作为一款由中国人自己设计的编程语言，易语言在中文处理方面做了大量的工作。用户在编写程序的过程中如果愿意，可以不接触任何英文。根本不懂英文或者英文了解很少的用户可以直接使用本语言来编写程序，不存在任何障碍。
   <1>、中文名称的快速录入。易语言内置四种名称输入法：首拼、全拼、双拼、英文。三种拼音输入法均全面支持南方音。使用这些输入法用户能够以英文语句的录入速度来录入全中文程序语句。
   <2>、程序全部以中文方式显示，运算符号全部显示为对应的中文符号，日期时间以中文格式呈现，以便于我国用户理解、阅读程序。
   <3>、以中文作为编程语言可以做到望文生义、望文知义，非常接近于自然语言，并且汉语的语法、逻辑在中文编程中可以得到充分的体现，更加适合中国人使用。对其它计算机编程语言的学习，总会感到某种限制，首先是语言环境的限制，也许熟练的英文能够多少得到一点补偿，但很多英文却总是有点半懂不懂，因为受语言本身的限制，英文已经无法表达清楚，只好用一些单词的部分字头进行组合，实际上早已失掉了本身的含义，从字母本身的组合上来看已经完全没有意义，只不过是一种强行的规定而已。初学者对此可能不清楚，英文编程语言中有很多术语是英文单词中原本没有的，如“IDTExtensibility”之类，单看字面我们无法知道这个术语的意思。这种脱离人类自然语言的东西不可避免地为我们理解编程造成无法解决的困难。
   <4>、语言中专门提供了适合中国国情的命令，如中文格式日期时间处理、汉字发音处理、全半角字符处理、人民币金额处理等等。以后此方面将会继续得到大量扩充及增强。
   三、易语言由基本系统和运行支持库两部分组成，两者之间通过使用飞扬工作室自行定义的接口技术进行协作。运行支持库内提供了易语言的所有语言要素，如：命令、窗口和报表单元数据类型、普通数据类型、常量等等，还可以通过提供“加入（AddIn）”功能来扩充易语言基本系统。运行支持库可以被随意增减、抽换或升级，基本系统对运行支持库提供了详细的版本控制。本技术给用户带来的最大好处是：
   <1>、用户可以根据行业或自身需要定制易语言；
   <2>、由于运行支持库的不断增多、升级，易语言的功能将被迅速扩充；
   <3>、由于运行支持库可以仅包含声明而不包含实际的运行支持代码，并且可以随时被更新或抽换，这样可使人们通过国际互联网与服务器进行远程易语言交流（譬如复杂型电子商务、远程控制等等）成为可能，此是以后易语言互联网版本的发展方向。
   四、即时编译并自动规范格式的语句录入方式。
    在输入程序的过程中，每条程序语句被录入后，都将被立即进行初步编译，一些通常的语法错误，将及时得到报告并要求进行修改。所录入语句被自动规范为统一格式后存放，因此任何人所编写的任何程序其呈现格式都完全一致。对于应用程序的协作开发、交流和维护非常有利。
   五、系统内置的自动名称管理器能够对用户所定义的各类名称进行跟踪管理。
    譬如：假设程序中现存在一个名为“取最大值”的子程序，而且在很多地方都调用了该子程序。现在用户根据需要想把该子程序更改为另外一个名称，在传统的编程语言中，用户需要先更改该子程序的名称，然后搜寻整个应用程序，逐一找到使用了该子程序的地方，把名称相应地改变过来。在易语言中，用户只需更改子程序名称即可，程序中其它所有使用了该子程序的地方，其名称都将被自动快速地更改过来。
   六、贯穿全程的即时且全面的信息帮助。
   用户在进行任何操作的过程中，均能够在状态行上或提示夹中获得有关当前操作位置的详细相关信息。譬如：如果用户移动光标到某程序行，马上就能够得到此程序行上所有命令的定义、参数、使用方法等等信息。
   哇啦啦，易语言的出现，使我们用中文进行编程不再是梦想啦。易学易懂的易语言，其产生和发展具有深远的意义 。它将极大地推动中国信息业的发展，造就无数的就业机会；改变计算机教育现状，把跟随西方的计算机教育，改变为自主创新的教育；在商业应用上能够加快软件开发周期，创造更多的利润。
   同学们，为了祖国的未来，努力吧！
   在本书中，我们将通过实例，讲述易语言的基础知识和实际应用，介绍一些常用的操作方法和实用技巧。
   同学们，学习任何一种新知识，都会遇到困难，希望你们拿出“明知山有虎，偏向虎山行”的勇气来，克服一切困难，学好用好易语言。
   也许你会说：“编写程序很高深吧，我可怕学不成”。宝贝哥哥我要对你说：“别怕别怕，跟着宝贝哥哥慢慢来吧”。只要你肯学，不难的，相信我吧，因为宝贝哥哥当初学易语言时，也是对编程一无所知，但很快就能编写一些小程序了。利用易语言，几分钟你就能做出一些简单、实用的小程序，宝贝哥哥不会骗你的。
   在学习编写第一个小程序之前，先跟宝贝哥哥稍为了解一下易语言的编辑环境怎样？大家一起来吧！


易语言之所以叫做全可视化编程语言，就是因为它的开发界面和DOS界面下的一般编程界面相比，是图形化的；它所制作的应用程序图形，就是日后运行时看到的程序界面。整个编程过程都是可视的，可以称之为“所见即所得”。下面，我们就启动易语言的画面，来验证一下。
   易语言目前的版本都是测试版，可到http://www.ccfly.com/查看易语言的版本变动信息。安装后直接执行 E.EXE 文件即可运行。点击安装目录下的E.EXE ，启动易语言，程序启动后出现图1.1的画面。
   在“新建”对话框中，选择“程序”，再单击“确定”，将自动建立一个新程序，该程序可在保存时命名。如图1.2所示。
   初学者可能会说：哗，怎么界面这么复杂啊。其实你如果接触过word等办公软件或网页编辑工具，易语言的界面是不难理解的，因为里面的元素都是差不多的。下面，本书将为你一一解说在这个界面上出现的东西。
   程序窗口由上往下依次是标题栏、菜单栏和工具栏。这3个栏和所有的windows应用程序都是一样的，不必多说。
   中间的窗口称为“界面窗口”，也可以称之为“设计窗口”，因为我们的应用程序的界面就在此设计。如果中间那个窗口称为“_启动窗口”，就是该程序的主窗口。
   右边为“窗口单元工具箱”，又可称“控件工具箱”。这是一个很重要的窗口，通常在这里往应用程序的界面上添加各种控件。
   左边为“工作夹”，在工作夹中包括三个子夹，名为：“支持库”、“程序”、“属性”。这三个子夹的功能如下：⑴、我们通常在“支持库”里查看易语言的相关指令；⑵、在“程序夹”中可以查看到当前程序的所有组成部分，双击某项目可以跳转到该项目所对应的程序部分。在某项目上单击鼠标右键可以弹出一个跳转、插入或删除对应程序项目的菜单；⑶、“属性夹”用作显示当前被选中窗口单元的属性表。在属性夹的顶部有一个组合框，用作选择当前设计窗口中的某窗口单元。在属性夹的底部也有一个“事件组合框”，用作自动加入或跳转到当前被选择窗口单元的某事件处理子程序。
   下边为“状态夹”，在状态夹中包括三个子夹，名为：“提示”、“输出”、“调用表”。这三个子夹的功能如下：⑴、“提示夹”中始终具有针对于当前用户操作的提示，比如你在“属性夹”里点击“高度”属性，在“提示夹”里会出现提示：“本属性记录当前窗口的高度，单位为像素点。”；⑵、“输出夹”中提供当前系统输出给用户的信息。比如编译易程序的全过程；⑶、“调用表夹”中提供调试时当前被中断运行的易程序的子程序调用过程记录。
   我们在新建一个程序之后，首先进入的画面为“界面编辑窗口”，若想切换到“代码编辑窗口”，选中并双击中间的窗口即可。“代码编辑窗口”如图1.3所示。


1.3.1    易语言的菜单栏

   易语言目前共有九个菜单项，下面我们逐一作简单的介绍，至于深入的理解，还要通过日后的练习来多加熟悉。
   ★、“程序”菜单。
   相当于其他应用程序的“文件”菜单，这个菜单主要负责文件操作，例如“新建”、“打开”、“保存”、“另存为”等等，还包括“程序配置”、“易模块管理”等。值得初学者注意的是，在易语言的“程序”菜单中还包括“编译独立发布版本”的菜单项。通过这个菜单命令，用户可以把编制好的程序打包成exe可执行文件。
   ★、“编辑“菜单。
   和其他应用程序的编辑菜单一样，这个菜单集成了所有的文本编辑命令，例如“剪切”、“复制”、“粘贴”、“查找”等，还包括“菜单编辑器”，用来编制程序的菜单。“编辑”菜单主要是针对代码编辑窗口而言的。
   ★、“查看”菜单。
   主要用于对程序的表格型代码部分进行访问，如“自定义数据类型表”、“全局容器表”、“资源表”等。“查看”菜单还包括控制主窗口布局方式的工具条等。
   ★、“插入”菜单。
   “插入”菜单也是主要是针对代码编辑窗口而言的。用于在代码编辑窗口插入各种类型的程序成分和代码。
   ★、“数据库”菜单。
   用于对易数据库进行操作。 包括创建易数据库的“结构编辑器”和直接编辑易数据库的“记录编辑器”等。
   ★、“调试”菜单。
   这个菜单集中了各种调试命令。例如“单步跟踪进入”、“单步跟踪”、“清除所有断点”等。其中的“查改容器内容”可以编辑变量或者表达式。
   ★、“运行”菜单。
   这个菜单的命令主要控制程序的运行、暂停、终止等。通常用它们来演示程序效果。
   ★、“窗口”菜单。
   和其他应用程序的窗口菜单一样，用于含有多个子窗口之间的互相切换，也可以选择子窗口的分布方式，水平/垂直平铺、层叠、排列图标等。
   ★、“帮助”菜单。
   包括切换到“即时帮助”提示子夹、“易语言知识库”等。

   1.3.2    易语言的工具栏（条）

   众所周知，工具栏（条）就是菜单栏的快捷方式，为了避免多次选择菜单而把常用的一些菜单命令用图标的形式集中在一起，就成了工具栏（条）。因此，工具栏（条）中的所有命令大多都可以在菜单栏中找到原型。
   目前易语言的工具栏（条）有两类：“标准工具条”和“对齐工具条”。
   在“菜看”菜单中选“工具条”，或者在工具栏上单击鼠标右键，都会出现如图1.4所示的菜单。
   在菜单中选中指定的工具栏前打“√”号，则该工具栏就会出现在主窗口上；消去“√”号，则该工具栏会隐去。下面就逐一介绍这两个工具条。
   ★、“标准”工具条。
   主要包括最常用的十余个命令，包括程序操作、编辑操作、执行命令、窗口布局等。标准状态条如图1.5所示。
   在标准工具条中的各个图标的意义如图1.6所示。
   ★、“对齐工具条”。
   包括左/右/顶/底/中对齐，分布间距，等高度/宽度等。对齐工具条如图1.7所示。


在这一节，我们结合前面学过的知识，来编写一个最简单的程序。
   中文编程的先驱吴涛先生在他那著名的易语言帮助系统中，用了一个“祖国，你好！”的著名例子，从此“祖国，您好！”就成了易语言文化的一部分。这个例子的内层意义是这样的：如果使用C语言在DOS界面下编写一个程序，显示一行“祖国，您好！”的文字，那么它只需要一行代码（程序头尾不计）。而如果使用C++语言在Windows环境下编写一个程序，显示一行“祖国，您好！”，则需要大约200行代码。这个例子可见编程的不易。在这里，我们用易语言同样编写一个“祖国，您好！”，同学们猜猜需要多少行代码？
   程序是这样的：当按下一个默认名为“按钮1”的按钮时，在窗口上方出现一行字，“祖国，您好！”，如图1.8所示。
   下面，我们就来编写这个小小的程序。
   一位根本不懂英语的普通电脑用户，只要使用易语言，可以在短短三分钟内编写出视窗（Windows）系统下的电脑程序，您相信吗？不信，请随我一试：
    1、 启动易语言，在右边工具箱中选中“标签”控件（易语言又称控件为窗口单元），如图1.8所示，用鼠标拖动绘制到设计窗口上部中央，此标签被系统默认为“标签1”（当然你也可以改名），如图1.9所示。
    2、 在工具箱中选中“按钮”控件，用鼠标绘制到窗口下部中央，此按钮被系统默认为“按钮1”，如图1.10所示。
    3、 双击所绘制的“按钮”，切换到代码编辑窗口，如图1.11所示，输入以下文字后回车键：
        标签1.标题 = "祖国您好！"
   注意要按回车键该行代码才被确认，如图1.12所示。至此，恭喜您，这个程序已经编写完毕，可以随时运行。如图1.13所示。具体操作过程也可以看随书所附光盘中的一个无声录象《“祖国，您好！”编写演示》。

   为了使大家通过这个例程多学到一点知识，下面继续补充讲解编写这个程序的操作方法和一些原理。

   1.4.1    设计程序界面

   ★、启动易语言，在“新建”对话框中选择“程序”，再单击“确定”，如图1.14所示。
   ★、然后将会出现对象设计窗口，而我们将要设计的程序主界面就在这个窗口上，该窗口默认名为“启动窗口”，如图1.15所示。
   ★、如果想把该启动窗口调整到合适大小，可以这样：在窗口的四周共有8个句柄（小方点），其中左上方的5个是白色的，表示不可拖动；而右下方的3个是黑色的，表示可以拖动。将鼠标移动到句柄的上方时，鼠标指针会变成双箭头。此时可以拖动鼠标，而该窗口就可以随着鼠标的拖动而放大或缩小了。如图1.16所示。
   ★、下一步就是往该窗口添加控件。
   在右边的控件工具箱上选择一个按钮模样的图案，鼠标停留在上面片刻就会出现“按钮”的提示文字。单击它，则该图案会凹陷下去，如图1.17所示。
   此时再把鼠标移到启动窗口上，鼠标指针会变成十字形，在窗口合适的位置上拖动出一个矩形框，松开鼠标后，一个大小相当的按钮就画出来了。如图1.18所示。系统先将其自动命名为“按钮1”，按钮面显示的标题为“按钮”。
   可以看出，该控件四周也有8个小句柄，说明该控件也可以移动位置或调整大小。
   ★、我们再按照上面的方法添加一个标签（工具箱第三行的第一个控件，有字母“A”字样的图案），系统自动命名为“标签1”，标题为“标签”。如图1.19所示。
   经过以上步骤，本程序的界面已布置好了，下面我们来学学更改窗口上的控件的属性（外观特征）。

   1.4.2    设置控件的属性值

   ★、单击“按钮1”，该按钮周围就会出现8个小句柄，表示该控件已经被选中。此时，我们再选中左边工作夹中的“属性”子夹，就会在属性窗口出现“按钮1”的属性设置，属性窗口的上方有该按钮的名称“按钮1”。
   控件（窗口单元）的名称很重要，因为它提供了该控件在窗口上的唯一标记，编写代码时将通过这个名称来表示这个控件。
   程序编辑窗口的最下面是状态夹，当我们选中“按钮1”的某个属性，再选中状态夹的提示子夹，就会出现该属性的提示信息。比如对于“名称”的解释是：“本属性记录当前所选择对象的名称”。
   拖动属性窗口中的滚动条，找到“按钮1”的“标题”属性，将该属性的属性值由“按钮”改为“按我”，在右边的属性值一栏中直接输入即可，然后再按回车键确认本操作。此时，所做的属性值修改已经直接反映在启动窗口上，如图1.20所示。
   ★、再选中“标签1”，其属性值的设置参考“按钮1”。我们还可以在属性窗口设置该标签标题的字体、字色等属性。

   1.4.3    编写程序代码

   双击“按我”按钮，此时会切换到代码编辑窗口，并且系统会自动生成一个程序过程，其名称为“子程序：_按钮1_被单击”。如图1.21所示。
   在该子程序表格下有一个虚线的方框，该子程序的第一行代码就在此输入。双击该虚线方框，使该方框颜色变灰，就可以输入代码了。若要插入一行代码，可以点鼠标右键选“插入新行”或“向后插入新行”。下面我们就编写一行代码：
                   标签1.标题=“祖国，您好！”
   最后按回车键确认以消去代码行前面的“※草稿：”字样，这样我们这个程序就编写完成了。可以用[Ctrl]+[Tab]键切换回到界面编辑窗口，如图1.13所示。

   1.4.4    测试运行程序

   编好一个程序后，怎样运行它呢？一般有三种方法：
   方法一：从菜单栏中选“运行→运行”来启动程序。
   方法二：按F5键。
   方法三：从工具条中选图案为“▲”的按钮并单击。
   图1.14就是启动这个程序之后的结果。
   单击“按”按钮，程序将会变成如图1.15的样子。看来，我们的程序确实达到了预期目的。
   我们先要终止该程序的运行才能退出易语言系统，终止程序运行的方法是选菜单“运行→终止”，或在工具栏中点击图案为“■”的按钮。

   1.4.5    代码编写原理

   ★、这个子程序的完整代码为：
              子程序：_按钮1_被单击
              标签1.标题=“祖国，您好！”
   这个子程序用中文表达，意思就是：当单击按钮1时，标签1的标题就变成“祖国，您好！”。我们可以把“标签1.标题”理解为“标签1的标题”。可以看出易语言很接近人类的自然语言尤其是中国人自己的语言。
   ★、我们添加的这个代码行在易语言中被称为赋值语句，因为它的中间有一个“=”号，赋值语句的含义就是把等号右边的表达式的属性值赋给等号左边的变量（不固定的量）。
   等号的右边是一个文本，在易语言中要引用文本时，这个文本要用双引号括起来，它的值就是如“祖国，你好！”之类。
   ★、操作该程序的人与“按钮1”的关系是“单击”与“被单击”的关系，从而两者发生联系，该按钮也就成了人们操作程序、发送指令的一个接口。按照“事物的相互联系构成事物的运动”的物理学原理，本程序就在“单击”的条件下产生相应的运动，如标签1.标题=“祖国，您好！”之类。“单击”或“被单击”在程序语言中被称为“事件”。windows程序都是由事件驱动的，一个事件就构成一个子程序。在本书的第二章将对这些编程语言作详细的解释。

--------------------------------------------------------------------------------


在上一节中我们学做了一个最简单的易程序， 但是只能在易语言环境下运行。怎样使它脱离易语言环境也照样运行？我们需要把它保存并编译成exe可执行文件，因为我们所见到的应用程序都是后缀名为.exe格式的文件。

   ㈠、保存程序的方法。

   从菜单栏中选择“文件”菜单中的“保存”，随即屏幕上出现一个对话框，如图1.22所示。
   这个对话框的标题为“保存为：”。在该对话框中名称为“文件名”的输入框中输入你想要起的名字，然后单击“确定”。这时文件就被保存了，同时关闭对话框。如果你有多个文件要保存，那你就辛苦一下，多保存几次吧。
   下次要用这个应用程序的时候，你可以从菜单栏中选“程序”菜单中的“打开”，然后从对话框中选择你要打开的文件，再确定一下即可。

   ㈡、生成.exe文件的方法。

   ⑴、一个独立运行的文件（指.exe文件）是不需要易语言环境的，它可以直接运行于windows和dos环境中。就是说，一个独立运行的文件就象是安装游戏时的setup.exe文件一样，只要单击它就马上安装游戏，而不必再易语言编辑环境中打开。

   ⑵、如果希望应用程序不必在易语言中打开，就必须把应用程序编译成.exe文件。好。让我们试一下。

   从菜单栏中选“程序→编译发布版本”，弹出一个保存文件的对话框，如图1.23所示。
   从中输入一个你想要的文件名，再选择保存在什么地方（即保存的位置或路径），再单击“确定”。这样，一个.exe文件就形成了。
   最后，你如果想看看自己的“战果”，可以进入windows的“我的电脑”或“资源管理器”中，找到该文件，然后双击文件名即可。当然，在DOS的系统提示符下键入文件名也能执行。


我们常常听到编程高手们为了宣扬自己所学的一门编程语言，议论说自己学的这门编程语言是面向对象的，另外那门编程语言不是面向对象的。我们应该清楚，一些高手的说法可能会带有误导成分。那他们究竟说得对不对？究竟什么是面向对象？面向对象有什么重要意义？为什么高手们常常借助面向对象来宣扬自己所学？易语言究竟是不是面向对象的？这些问题是我们学习易语言时需要明白的。

   阿猫：“什么是面向对象？常看到这个词，但就不太清楚什么意思。”
   阿狗：“我也不懂，听着就是了 。”
   阿牛：“就是OOP 。”
   阿猪：“这样解释还不如不解释。”
   阿木：“oop stands for object oriented programming。是一个编程思想。如果你是启蒙阶段，用易语言知道不如不知道。如果你想皈依程序，用Standard C++一定要知道。oop,多型，stl一个都不能少。 http://jjhou.csdn.net/这里有你想要的。 ”

   阿水：对象嘛，还不懂？所谓对象者，指窗口、控件、数据库等之类的东西也。所谓面向对象编程嘛，就是围绕“对象”为中心进行编程的一种方法。一般是指用具体的控件（即对象）来发出指令、接收指令、传送指令并反馈指令的一种编程方法，跟面向过程的编程方法比较，它更简单易懂。比如搞（至于怎样搞？，可以单击、双击或按下之类，“搞”即“事件”也）一下某个按钮（对象）就可以开始或结束一个程序，“搞”这个指令为某一个“事件”，点击后程序怎样运行（“移动”、“关闭”、“加入内容”之类）为“命令”或“方法”，“过程”（包括结果）通常表现为对象的属性（变量或常量）的变化（如“编辑框3.内容（变为）=“祖国，你好！”）。也即说面向对象的编程方法主要是运用对象（一般表现为具体的控件，有时也不一定）的属性（实质就是变量或常量）、事件、方法（动作）和过程来完成程序的一种编程思想和方法。
   什么是面向过程，我们一般都没有见过。我们只知道用面向对象的方法容易理解。易语言可以说运用的是面向对象的编程方法。在易语言中我们就经常提及“对象”，并且通过改变对象的属性来设置各对象。
   可能有同学要问面向对象、创建对象有什么好处？不用面向对象行吗？这我们要从头说起。人类初期的编程语言都是面向过程的，由于没有任何现成的对象（窗口、控件、数据库等）可供面向，单是创建一个控件可能就要用到数百行代码，并且大量的时间耗费在创建对象中。
   后来编程界出现面向对象（OOP）的编程概念，将常用的程序过程模块化、对象化，以便供人们在编程时引用。在OOP方式下编程，你不必再去编写冗长的界面程序（如绘制坐标轴、绘制按钮及其按钮下陷的效果等等），你的重点完全在程序功能的实现上，而不是在界面的绘制上，这样OOP的编程方式大大缩短了软件的开发时间，提高了程序员的开发效率，也使编程就象网页设计或画画一样简单。随着软件不断向复杂性、大规模、多功能性发展，尽管OOP方式也存在着对底层开发较薄弱的问题，但OOP的程序开发方式越来越显示它的强大魅力。
   打个比方来说明，人们一般在吃饭的时候用到筷子、碗、叉子等，但你想一想，如果人们都在吃饭的时候才去用原料制造一些器具，那么情况又如何呢？明白了面向对象的意义了吗？当然如果你是编程天才，那么你也可以开发自己的“对象”甚至是开发自己的编程语言，像吴涛先生那样进行编程语言的底层开发工作。
    至于面向对象的含义，试举一例说明：

子程序（VB称为“过程”）：_按钮1_被单击    ※由对象名和事件名构成该名称
编辑框3.内容="金善喜"       ※将该对象的属性赋值为"金善喜"
如果(_按钮1_被单击=真)
则  编辑框3.内容="朱茵"     ※该对象属性值变为"朱茵"
否则 返回                   ※该对象属性值还是"金善喜"

   以上例子通过"单击"事件触动"按钮1"对象发出指令,而"编辑框3"对象接收并反馈该指令,使其属性值发生变化,从而完成程序。
  再看下一例：

子程序：_按钮1_被单击
编辑框2.内容 ＝ 编辑框1.内容   ※当单击按钮1时，把编辑框1的内容传给编辑框2
编辑框1.内容 ＝ “”           ※然后再清空编辑框1，为下次输入内容作准备

   在这一例中，“编辑框1”的内容属性值和“编辑框2”的内容属性值都不是固定的。没有固定值的属性我们就称为“变量”（即易语言所说的“容器”）。一般我们先要声明变量（即建立容器），以便跟常量区别开来，然后再赋予属性值（范围）。如果没有声明变量就运行程序，一般会提示：“对不起，没有找到相关容器”。就象你填履历表，如果你没有把你的属性（年龄、性别、学历等）填好填正确，上面就发下来让你重填，道理一样。
   但上面例子没有经过声明就可以赋予属性值（即“编辑框2.内容 ＝ 编辑框1.内容），这是为什么？什么时候要建立容器？什么时候不用建立容器？且听下一章分解 。

   本章思考与练习

   1、试编写程序，单击鼠标可以改变启动窗口的标题。
   2、易语言的特点是什么？
   3、试把编程的输入法变成你自己所用的输入法。
   4、在“祖国，您好！”的例程中，除了点击“按钮1”可以使系统创建一个子程序外，还有什么方法快速创建该事件的子程序？
   5、谈谈你对OOP的理解。


对于初学者来说，怎样理解用易语言来编程？跟VB、DELPHI、VC++等语言一样，都是围绕对象、运用现成的对象来进行编程的。我们理解了对象的含义及其作用，就能很好地理解编程语言，包括易语言，更能使我们培养编程思路，并培养独立完成程序编写的能力。比如上一节课的例程“祖国，您好!”，就是先设计好按钮、标签这两个对象，用“单击按钮”这个对象事件来作为执行指令的依据，然后就围绕这两个对象来进行编程。
   所谓对象，指窗口、控件、数据库等之类的东西。所谓运用对象进行编程，其程序设计是以对象为中心，以事件作为执行程序的依据。 一般是指用具体的控件（即对象）来发出指令、接收指令、传送指令并反馈指令的一种编程方法，这种编程方法由于具有形象性和具体性，故易于为人们所理解。比如搞（至于怎样搞？，可以单击、双击或按下之类，“搞”即“事件”也）一下某个按钮（对象）就可以开始或结束一个程序，“搞”这个指令为某一个“事件”，点击后程序怎样运行（“移动”、“关闭”、“加入内容”之类）为“命令”或“方法”，“过程”（包括结果）通常表现为对象的属性（变量或常量）的变化（如“编辑框3.内容=（变为）“祖国，你好！”）。也即说运用对象进行编程的方法主要是运用对象（一般表现为具体的控件，有时也不一定）的属性（实质就是变量或常量）、事件、方法（动作）和过程来完成程序的一种编程思想和方法。
  在易语言中我们就经常提及“对象”，并且通过改变对象的属性来设置各对象。
  可能有同学要问运用对象、创建对象有什么好处？不运用对象行吗？这我们要从头说起。人类初期的编程语言都是面向过程的，由于没有任何现成的对象（窗口、控件、数据库等）可供编程时运用，单是创建一个控件可能就要用到数百行代码，并且大量的时间耗费在创建对象中。有一个著名的等式：数据结构+算法=程序，就是形容这种面向过程的编程方式的。
   后来编程界出现运用现成的对象进行编程的方法，将常用的程序过程和数据结构模块化、对象化，以便供人们在编程时引用。用这种方式进行编程，你不必再去编写冗长的界面程序（如绘制坐标轴、绘制按钮及其按钮下陷的效果等等），你的重点完全在程序功能的实现上，而不是在界面的绘制上，这样的编程方式大大缩短了软件的开发时间，提高了程序员的开发效率，也使编程就象网页设计或画画一样简单。随着软件不断向复杂性、大规模、多功能性发展，加上某些发展成熟的编程语言既能使用对象，又能创建对象，使这种运用对象的编程方式越来越显示它的强大魅力。
   打个比方来说明，人们一般在吃饭的时候用到筷子、碗、叉子等，但你想一想，如果人们都在吃饭的时候才去用原料制造一些器具，那么情况又如何呢？明白了运用对象的意义了吗？当然如果你是编程天才，那么你也可以开发自己的“对象”甚至是开发自己的编程语言，像吴涛先生那样运用面向底层、面向对象的编程方式，也就是相当于自己使用筷子、碗、叉子来吃饭，也给别人制造筷子、碗、叉子，或者可以比喻成“既搞建筑，又开砖厂”。这种编程方式又比单纯运用对象的方式更高了一层次。
   至于运用对象进行编程的含义，试举一例说明：

   子程序：_按钮1_被单击       ※由对象名和事件名构成该名称
   编辑框3.内容="金善喜"       ※将该对象的属性赋值为"金善喜"
   如果(_按钮1_被单击=真)
   则  编辑框3.内容="朱茵"     ※该对象属性值变为"朱茵"
   否则 返回                   ※该对象属性值还是"金善喜"

   以上例子通过"单击"事件触动"按钮1"对象发出指令,而"编辑框3"对象接收并反馈该指令,使其属性值发生变化,从而完成程序。
   再看下一例：

   子程序：_按钮1_被单击
  编辑框2.内容 ＝ 编辑框1.内容   ※当单击按钮1时，把编辑框1的内容传给编辑框2
  编辑框1.内容 ＝ “”           ※然后再清空编辑框1，为下次输入内容作准备

   在这一例中，“编辑框1”的内容属性值和“编辑框2”的内容属性值都不是固定的。没有固定值的属性或在程序运行过程中可以随时发生变化的量我们就称为“变量”（即易语言所说的“容器”）。一般我们先要声明变量（即建立容器），以便跟常量区别开来，然后再赋予属性值（范围）。如果没有声明变量就运行程序，一般会提示：“对不起，没有找到相关容器”。就象你填履历表，如果你没有把你的属性（年龄、性别、学历等）填好填正确，上面就发下来让你重填，道理一样。
  但上面例子没有经过声明就可以赋予属性值（即“编辑框2.内容 ＝ 编辑框1.内容），这是为什么？什么时候要建立容器？什么时候不用建立容器？且听下一章分解 。

  本章思考与练习

  1、试编写程序，单击鼠标可以改变启动窗口的标题。
  2、易语言的特点是什么？
  3、试把编程的输入法变成你自己所用的输入法。
  4、在“祖国，您好！”的例程中，除了点击“按钮1”可以使系统创建一个子程序外，还有什么方法快速创建该事件的子程序？
  5、谈谈你对运用对象进行编程的理解。


窗口程序集：窗口程序集1

程序集容器：a     数据类型：文本型
程序集容器：b     数据类型：文本型
程序集容器：i     数据类型：整数型
程序集容器：s     数据类型：整数型
   ※备注：分别定义两个文本型程序集变量，分别用来存储启动窗口和标签1的标题，以供各子程序调用
   ※备注：分别定义两个整数型程序集变量，分别用来存储启动窗口和标签1的标题的字符数目，以供各子程序调用

------------------------------

子程序：__启动窗口_创建完毕

_启动窗口.标题 ＝ “有动画效果的窗体标题”
标签1.标题 ＝ “用标签制作滚动显示字幕”
a ＝ _启动窗口.标题
b ＝ 标签1.标题
时钟1.时钟周期 ＝ 0
时钟2.时钟周期 ＝ 0
   ※备注：将两个定时器设置为无效
------------------------------

子程序：_按钮1_被单击
   ※备注：控制逐字显示效果
i ＝ 0
s ＝ 0
   ※备注：若将i和s定义为静态局部变量，则以上两行不用。最好还是改为静态局部变
     量，在这里给出一道作业题，将i和s定义为静态局部变量，然后相应修改程序。
时钟1.时钟周期 ＝ 100
时钟2.时钟周期 ＝ 0

------------------------------

子程序：_按钮2_被单击
   ※备注：控制滚动显示效果

_启动窗口.标题 ＝ 取空白文本 (30) ＋ a
    ※备注：在窗口标题前加30个空格
标签1.标题 ＝ 取空白文本 (80) ＋ b
    ※备注：在标签1标题前加80个空格
时钟2.时钟周期 ＝ 100
时钟1.时钟周期 ＝ 0

------------------------------

子程序：_时钟1_周期事件

局部容器：t       数据类型：文本型
局部容器：u       数据类型：文本型
   ※备注：产生标题的逐字显示效果
t ＝ 取文本左边 (a, i)
   ※备注：取得窗口标题的前i个字符
u ＝ 取文本左边 (b, s)
   ※备注：取得标签1标题的前s个字符
_启动窗口.标题 ＝ t
i ＝ i ＋ 1
   ※备注：重新设置窗口标题
标签1.标题 ＝ u
s ＝ s ＋ 1
   ※备注：重新设置标签1标题
如果真 (i ＞ 取文本长度 (a))
   i ＝ 0
如果真结束
如果真 (s ＞ 取文本长度 (b))
   s ＝ 0
如果真结束
   ※备注：如果标题已显示完毕，则重新逐个显示字符
------------------------------

子程序：_时钟2_周期事件

_启动窗口.标题 ＝ 取文本右边 (_启动窗口.标题, 取文本长度 (_启动窗口.标题) － 1) ＋ 取文本左边 (_启动窗口.标题, 1)
标签1.标题 ＝ 取文本右边 (标签1.标题, 取文本长度 (标签1.标题) － 1) ＋ 取文本左边 (标签1.标题, 1)
   ※备注：产生标题循环滚动效果

     作业题：将i和s定义为静态局部变量，然后相应修改程序。


一个经典加密方法，单一密码，可逆操作。在我的机器（ C466 192M ）上30，000字节的加密需要80秒左右。

                  子程序：RC4
返回值类型：字节集
备注：RC4加密算法

参数：源    数据类型：字节集
参数：密匙  数据类型：文本型

局部容器：K       数据类型：字节型  数组：256
局部容器：S       数据类型：字节型  数组：256
局部容器：i
局部容器：j
局部容器：y       数据类型：字节型
局部容器：t
局部容器：x
局部容器：temp    数据类型：字节型
局部容器：Outp    数据类型：字节集
局部容器：ee      数据类型：字节型

计次循环首 (256, i)
  S ＝ i － 1
计次循环尾 ()
j ＝ 1
容器循环首 (0, 255, 1, i)
  如果真 (j ＞ 取文本长度 (密匙))
      j ＝ 1
  如果真结束
  K [i ＋ 1] ＝ 取代码 (取文本中间 (密匙, j, 1), )
  j ＝ j ＋ 1
容器循环尾 ()
j ＝ 0
容器循环首 (0, 255, 1, i)
  j ＝ (j ＋ S [i ＋ 1] ＋ K [i ＋ 1] ＋ 256) ％ 256
  temp ＝ S [i ＋ 1]
  S [i ＋ 1] ＝ S [j ＋ 1]
  S [j ＋ 1] ＝ temp
容器循环尾 ()
连续赋值 (0, i, j)
容器循环首 (1, 取字节集长度 (源), 1, x)
  i ＝ (i ＋ 1 ＋ 256) ％ 256
  j ＝ (j ＋ S [i ＋ 1] ＋ 256) ％ 256
  temp ＝ S [i ＋ 1]
  S [i ＋ 1] ＝ S [j ＋ 1]
  S [j ＋ 1] ＝ temp
  t ＝ (S [i ＋ 1] ＋ (S [j ＋ 1] ＋ 256) ％ 256 ＋ 256) ％ 256
  y ＝ S [t ＋ 1]
  ee ＝ 位异或 (源 [x], y)
  Outp ＝ Outp ＋ 转换为字节集 (ee)
容器循环尾 ()
返回 (Outp)

      用同样的密码对加密后的文件再加密一次就是解密了。


窗口程序集：窗口程序集1

------------------------------

子程序：_编辑框1_内容被改变

局部容器：总行数  数据类型：整数型
局部容器：文本高度      数据类型：整数型

总行数 ＝ 绝对取整 (取文本长度 (编辑框1.内容)) ÷ 30
文本高度 ＝ 总行数 × 7.6
编辑框1.高度 ＝ 文本高度 ＋ 20
_启动窗口.高度 ＝ 编辑框1.高度 ＋ 50


这一讲我们要用到的表格控件是一个类似于电子数据表的绑定控件，可用一系列的行和列来显示记录和字段，所以我们就可以将数据以一种二维表格的形式一次性地显示出来，而不必象《数据源控件和数据库提供者控件的使用》这一讲的范例中那样，只能一个一个地查看数据。也就是说表格控件一般是作为数据处理者来使用，那么各种处理数据库的控件之间的关系可以表述为：
            数据库→数据提供者→数据源→表格（数据处理者）
   也就是说要使表格控件发挥作用，还需要配合数据库、数据提供者和数据源来使用。
   这里我们重要设置表格控件的主功能属性，即“数据源”属性，就可以制作一个简单的数据浏览表格。

   例程制作：学生成绩查询表格。

   步骤一、创建程序界面及数据库。
       我们要使用到的数据库就是《数据源控件和数据库提供者控件的使用》这一讲例程中的数据库，当然用其他数据库也行。
       在界面上添加一个数据提供者控件，一个表格控件，一个数据源控件。
   步骤二、设置对象属性值。
       将数据源的数据库文件名属性值设为“学生成绩.edb”(该数据库要跟程序在同一目录下），或设为该数据库的路径名，如“E/hahaha/学生成绩.edb”（可以不跟程序在同一目录下），将数据源控件的数据提供者的属性值设为“数据库提供者1”，将表格控件的数据源属性值设为“数据源1”，将表格控件设置为适当大小。
   步骤三、不用编写代码即可运行使用。我们可以运用数据源控件对表格控件中是数据进行相应的操作，也可以用鼠标对表格中的数据进行查询、添加、删除、更新等基本操作。


窗口程序集：窗口程序集1

程序集容器：鼠标状态    数据类型：整数型

------------------------------

子程序：_按钮1_被单击

销毁 ()

------------------------------

子程序：_图片框1_鼠标位置被移动
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

如果真 (鼠标状态 ≠ 0)
   图片框1.左边 ＝ (图片框1.左边 ＋ 横向位置) － 图片框1.宽度 ÷ 2
   图片框1.顶边 ＝ (图片框1.顶边 ＋ 纵向位置) － 图片框1.高度 ÷ 2
如果真结束

------------------------------

子程序：__启动窗口_创建完毕

标签1.标题 ＝ “用鼠标左键实现第一种拖动” ＋ #换行符 ＋ “用鼠标右键实现第二种拖动”

------------------------------

子程序：_图片框1_鼠标左键被按下
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

鼠标状态 ＝ 1

------------------------------

子程序：_图片框1_鼠标左键被放开
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

鼠标状态 ＝ 0

------------------------------

子程序：_图片框1_鼠标右键被按下
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

鼠标状态 ＝ 2

------------------------------

子程序：_图片框1_鼠标右键被放开
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

鼠标状态 ＝ 0

------------------------------

子程序：__启动窗口_鼠标位置被移动
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

鼠标状态 ＝ 0


[这个贴子最后由bb88在 2002/04/15 09:42pm 编辑]

 一、窗口的属性及其示例。

  ㈠、基本属性。（略）（见《关于窗口单元的基本属性和基本事件》）
  ㈡、一般属性。
     ⑴、边框。数据类型：整数型；本属性指定对象边框的类型。
         可供选择的属性值：
                  0、无边框
                  1、普通可调边框
                  2、普通固定边框
                  3、窄标题可调边框
                  4、窄标题固定边框
                  5、镜框式可调边框
                  6、镜框式固定边框

          例句：  窗口1.边框=4        （表示指定为窄标题固定边框）
      ⑵、底色。数据类型：整数型；本属性指定窗口背景的颜色。

          例句：  窗口1.底色=#蓝色     （调用常数时前面要加“#”号）
            或：  窗口1.底色=16711680  （“16711680”是蓝色的常量值）
      ⑶、底图。数据类型：字节集；本属性指定显示在窗口背景上的图片。

          例句：  窗口1.底图=金善喜.gif   （“gif”是一种图片格式）
                  （要先在资源表里建立图片资源）
      ⑷、底图方式。数据类型：整数型；如果设定了底图，本属性指定窗口背景上底图的显示方式。

       可供选择的属性值：
          0、图片居左上
          1、图片平铺
          2、图片居中

       例句：哈哈哈.底图方式=1   （“哈哈哈”是某个窗口的名称，为图片平铺方式）

      ⑸、背景音乐。数据类型：字节集；本属性指定当窗口调入时自动开始播放的音乐。

         例句：聊天窗口.背景音乐=单身的程序员.mp3
               （要先在资源表里建立声音资源）
      ⑹、播放次数。数据类型：整数型；本属性指定背景音乐的播放次数。

         可供选择的属性值：
            0、循环播放
            1、仅播放一次
            2、不播放
        例句：音乐窗口. 循环播放=0

      ⑺、控制按钮。数据类型：逻辑型（真或假）；本属性设置是否显示窗口上的所有控制按钮及窗口控制菜单。

        例句：窗口3. 控制按钮=假
      ⑻、最大化按钮。数据类型：逻辑型；本属性设置是否显示窗口右上角的最大化或还原按钮。

          例句：窗口3. 最大化按钮=真
      ⑼、最小化按钮。数据类型：逻辑型；本属性设置是否显示窗口右上角的最小化按钮。
      ⑽、位置。数据类型：整数型；本属性设置窗口的位置及状态。

          可供选择的属性值：
              0、通常
              1、居中
              2、最小化
              3、最大化
          例句：窗口3. 位置=2
      ⑾、可否移动。 数据类型：逻辑型；本属性设置窗口位置能否被移动。

           例句：窗口3. 可否移动=假
      ⑿、图标。数据类型：字节集；本属性设置窗口左上角所显示的图标。

           例句：窗口3. 图标=易.gif
      ⒀、回车下移焦点。数据类型：逻辑型；本属性如果设置为真，运行时当用户在本窗口上按下回车键后，将自动将当前焦点转移到下一个单元（控件）。本属性如果设置为假，当用户在本窗口上按下回车键后，将等同于按下具有“默认”属性的按钮。

           示例：比如窗口3中几个控件，当“窗口3.回车下移焦点=真”时，按回车键，则焦点光标会顺次在这几个控件中移动；当“窗口3.回车下移焦点=假”时，按回车键，则焦点光标只停留在第一个控件上。
      ⒁、Esc键关闭。数据类型：逻辑型；本属性设置运行时用户是否可以用 Esc 键关闭本窗口。
          例句：窗口3. Esc键关闭=真
      ⒂、帮助文件名。数据类型：文本型；指定欲打开帮助文件的名称，如果没有指定帮助文件，将使用默认帮助文件名称，即本易程序的文件名称（不含其后缀）＋“.hlp”后缀。
          例句：窗口3. 帮助文件名=使用说明.hlp
             （先要建立一个叫“使用说明”的帮助文件）
      ⒃、帮助标志值。数据类型：整数型；用于在帮助文件中指定相应的帮助标志数值。本属性如果为零，则显示帮助主题。

          例句：窗口3. 帮助标志值=15     （显示代号为15的帮助文件段落）
      ⒄、F1键打开帮助。数据类型：逻辑型；本属性设置运行时用户是否可以用 F1 键打开有关本窗口的帮助信息。

          例句：窗口3. F1键打开帮助=真
      ⒅、在任务条中显示。数据类型：逻辑型；设置本窗口是否出现在 Windows 系统的任务条中。默认为真，所以我们一般打开窗口时它就会在 Windows 系统的任务条中显示。

          例句：窗口3. 在任务条中显示=假    （窗口打开时在任务条中没有出现）

      ⒆、随意移动。数据类型：逻辑型；设置当用户在窗口上任何位置按下鼠标左键后是否进入窗口整体移动模式。注意如果本属性设置为真，则在本窗口及其中所有子单元上均不能再接收到“鼠标左键被按下”和“鼠标左键被放开”事件。

          例句：窗口3. 随意移动=真

      ⒇、外形。数据类型：整数型；设置窗口的外形。

          可供选择的属性值：
              0、矩形
              1、椭圆
              2、圆角矩形
              3、环
              4、正三角
              5、倒三角
              6、左三角
              7、右三角
              8、平行四边形
              9、五边形
              10、六边形
              11、梯形
              12、菱形
              13、五角星
              14、十字星
              15、闪电形
              16、爆炸形1
              17、爆炸形2
              18、燕尾
              19、折角矩形
              20、左箭头
              21、右箭头
              22、上箭头
              23、下箭头
              24、左右箭头
              25、上下箭头
              26、十字箭头
              27、丁字箭头
              28、燕尾箭头
              29、五边形箭头

         例句：窗口3. 外形=16       （易语言附带的例程中就有一个爆炸形窗口）
   (21)、总在最前。数据类型：逻辑型；设置本窗口永远位于其它窗口的前面。

         例句：窗口3. 总在最前=假

     本贴例程：参考《菜鸟每日一课——自制窗口控制按钮》。


窗口程序集：窗口程序集1

------------------------------

子程序：__启动窗口_创建完毕

时钟1.时钟周期 ＝ 35
纵向滚动条1.最大位置 ＝ 图片框1.高度 ＋ 80
纵向滚动条1.最小位置 ＝ 0 － 编辑框1.高度
纵向滚动条1.位置 ＝ 纵向滚动条1.最大位置
_启动窗口.获取焦点 ()

------------------------------

子程序：_时钟1_周期事件

如果 (纵向滚动条1.位置 ≥ 纵向滚动条1.最小位置 ＋ 20)
   纵向滚动条1.位置 ＝ 纵向滚动条1.位置 － 1
否则
   纵向滚动条1.位置 ＝ 纵向滚动条1.最大位置
如果结束
编辑框1.顶边 ＝ 纵向滚动条1.位置 － 80
编辑框1.可视 ＝ 真


 [这个贴子最后由bb88在 2002/04/15 02:17pm 编辑]

   在以后的介绍中将会逐步把易语言的各种窗口单元（控件）向菜鸟们作比较详细的介绍。这里首先介绍的是窗口单元的基本属性和基本事件，以便举一反三来理解并应用其他的控件属性和事件。
   ㈠、基本属性。
     各种窗口单元（控件）都具有的属性我们就称基本属性。比如“名称”、“高度”、“宽度”、“颜色”等属性是各种窗口单元都有的。
    ⑴、名称——属性类型：基本属性。这是识别一个事物（对象）必需的属性，就象一个人要有姓名我们才知道他是谁一样。
       要注意不能用数字和符号来命名对象，比如“555”、“—*%”之类的命名是不会被系统通过的。
       系统给每一控件对象一个默认的名称，但由于一个较大的程序可能会有多个同类控件，为了便于管理，我们一般都要给这些同类型的控件对象重新命名，比如“输入框1”重命名为“作品”，“输入框2”重命名为“作者”，“输入框3”重命名为“下载地址”、、、
    ⑵、左边——属性类型：基本属性； 数据类型：整数型（可容纳 -2,147,483,648 到 2,147,483,647 之间的数值，尺寸为 4 个字节），本属性记录当前对象在窗口或父单元中的左边位置，单位为像素点，如果是窗口对象，记录的则是当前窗口在屏幕中的左边位置。
        例句：按钮1.左边=100
    ⑶、顶边——属性类型：基本属性； 数据类型：整数型。解析及例句参考⑵。
    ⑷、宽度——属性类型：基本属性； 数据类型：整数型。指该控件的宽度，单位为像素点。
        例句：按钮1.宽度=20
    ⑸、高度——属性类型：基本属性； 数据类型：整数型。解析及例句参考⑷。
    ⑹、标记——属性类型：基本属性； 数据类型：整数型。指定跟随于窗口单元的一段文本，用于在程序中取得或设置与该窗口单元相关联的数据。比如有多个同类的窗口单元，可以用来给这些同类的窗口单元编号。
        示例：输入编辑框 [容器1].标记 ＝ 到文本 (容器1)
              信息框 (“在第 ” ＋ 当前编辑框.标记 ＋ “ 项上输入了内容” ＋ #左引号 ＋ 当前编辑框.内容 ＋ #右引号, 0, )
    ⑺、可视——属性类型：基本属性； 数据类型：逻辑型。逻辑值为“真”时这个控件在运行后能看见，为“假”就看不见。
        例句：编辑框1.可视=假     （“编辑框1”不可见）
    ⑻、禁止——属性类型：基本属性； 数据类型：逻辑型。逻辑值为“假”时可以对该控件进行操作，为“真”时就禁止操作，该控件不能用。
        例句：哈哈哈.禁止=假       （“哈哈哈”是某个控件对象的名称）
    ⑼、鼠标指针——属性类型：基本属性； 数据类型：字节集。
        就是指定鼠标的形状。系统共指定以下鼠标形状及代号：0、默认型；1、标准箭头型；2、十字型；3、文本编辑型；4、沙漏型；5、箭头及问号型；6、箭头及沙漏型；7、禁止符型；8、四向箭头型；9、北<—>东箭头型；10、北<—>南箭头型；11、北<—>西箭头型；12、西<—>东箭头型；13、向上箭头型；14、自定义型。
        例句：驱动器框1.鼠标指针=11     （即鼠标放在驱动器框1上，形状就变成北<—>西箭头型）

   ㈡、基本事件。
       各种窗口单元（控件）都具有的事件我们就称基本事件。又称“固定事件”。
    ⑴、鼠标左键被按下。
        类型：系统基本事件。
        解析：处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去，如：_按钮1_被单击=假（我举的这句其实是一个错误的句子，但我不知道怎样表达“返回假”，“返回假”是什么意思，专业术语真是害死人）；如果不返回值或返回真，则将此事件继续传递到所属对象上去。
        语法：_对象名_鼠标左键被按下 （横向位置，纵向位置，功能键状态）
        参数：①、横向位置 整数型；指示鼠标在当前所处窗口单元中的横向位置。
              ②、纵向位置 整数型；指示鼠标在当前所处窗口单元中的纵向位置。
              ③、功能键状态 整数型；用于查看各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。（这样的解析我不太明白，等我明白了再用我自己的话来解析：①、为什么查看？②、怎样查看？专业术语真是害死人）
        例句：_按钮2_鼠标左键被按下 (200, 100, 1)     （调用“_按钮2_鼠标左键被按下”子程序）
    ⑵、鼠标左键被放开。参考⑴的解析。
    ⑶、被双击。参考⑴的解析。
    ⑷、鼠标右键被按下。参考⑴的解析。
    ⑸、鼠标右键被放开。参考⑴的解析。
    ⑹、鼠标位置被移动。参考⑴的解析。
    ⑺、获得焦点。
        类型：系统基本事件。
        解析：使鼠标光标移到该控件上去而产生的事件。比如一个输入框获得了焦点，打开程序就会在该输入框出现光标，这样不用鼠标选中该输入框也能输入文字。
        语法：_对象名_获取焦点 ()
        例句：_输入框1_获取焦点()     （调用“_输入框1_获取焦点”子程序）
    ⑻、失去焦点。
        参考⑺的解析。
    ⑼、按下某键。
        类型：系统基本事件。
        解析：按下键盘某个键而产生的事件。
        用途：我们设置快捷键时可以使用该事件。
        语法：_对象名_按下某键 （键代码，功能键状态）
        参数：
            键代码 整数型；为键常量值，如：“#F1键”、“#回车键” 等等。具体所有的键常量见库常量表。
            功能键状态 整数型；用于查看在按下本键的同时各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功键。（这样的解析我不太明白，等我明白了再用我自己的话来解析：①、为什么查看？②、怎样查看？专业术语真是害死人）
         例句：_按钮1_按下某键 （#回车键，4）
     ⑽、放开某键。
        参考⑼的解析。
     ⑾、字符输入。
        类型：系统基本事件。
        解析：菜鸟一般对帮助文件下半部的解析不明白，在这里只取其上半部解析：当用户按下和松开一个字符键时发生此事件。字符键包括任何可打字打印的键盘字符及回车（Enter）和退格（BackSpace）键。比如有一个子程序叫“_编辑框1_字符输入”，我们向“编辑框1”任意输入文字或者按“回车键”或“空格键”之类，都可使“编辑框1”产生该事件。
        语法：_对象名_字符输入 (字符代码)  （我也不明白“字符代码”的意思，哈哈）
        例句：_编辑框1_字符输入(1)

     从上面的介绍高手们应该清楚大多数菜鸟为什么看帮助文件很困难了吧,因为我上面的介绍大部分来自帮助文件，上面的介绍有很多是连我自己也不明白的，让大家失望了，哈哈。有时候有例句也不能解决问题，关键是要用菜鸟的话向菜鸟同志们（包括我）讲解表达清楚。
     试举一例让高手们参考：我写的〈易语言常用语句〉我自己觉得通俗易懂了，但仍然有人说“太简单了”，意思是说得不够清楚明白，太抽象了，不够具体。这已经体现出要让菜鸟入门，就要从最基本的讲起。

--------------------------------------------------------------------------------
交流附件上传地址：http://www.91asp.com/


在以后的介绍中将会逐步把易语言的各种窗口单元（控件）向菜鸟们作比较详细的介绍。这里首先介绍的是窗口单元的基本属性和基本事件，以便举一反三来理解并应用其他的控件属性和事件。
 ㈠、基本属性。
   各种窗口单元（控件）都具有的属性我们就称基本属性。比如“名称”、“高度”、“宽度”、“颜色”等属性是各种窗口单元都有的。
  ⑴、名称——属性类型：基本属性。这是识别一个事物（对象）必需的属性，就象一个人要有姓名我们才知道他是谁一样。
     要注意不能用数字和符号来命名对象，比如“555”、“—*%”之类的命名是不会被系统通过的。
     系统给每一控件对象一个默认的名称，但由于一个较大的程序可能会有多个同类控件，为了便于管理，我们一般都要给这些同类型的控件对象重新命名，比如“输入框1”重命名为“作品”，“输入框2”重命名为“作者”，“输入框3”重命名为“下载地址”、、、
  ⑵、左边——属性类型：基本属性； 数据类型：整数型（可容纳 -2,147,483,648 到 2,147,483,647 之间的数值，尺寸为 4 个字节），本属性记录当前对象在窗口或父单元中的左边位置，单位为像素点，如果是窗口对象，记录的则是当前窗口在屏幕中的左边位置。
      例句：按钮1.左边=100
  ⑶、顶边——属性类型：基本属性； 数据类型：整数型。解析及例句参考⑵。
  ⑷、宽度——属性类型：基本属性； 数据类型：整数型。指该控件的宽度，单位为像素点。
      例句：按钮1.宽度=20
  ⑸、高度——属性类型：基本属性； 数据类型：整数型。解析及例句参考⑷。
  ⑹、标记——属性类型：基本属性； 数据类型：整数型。指定跟随于窗口单元的一段文本，用于在程序中取得或设置与该窗口单元相关联的数据。比如有多个同类的窗口单元，可以用来给这些同类的窗口单元编号。
      示例：输入编辑框 [容器1].标记 ＝ 到文本 (容器1)
            信息框 (“在第 ” ＋ 当前编辑框.标记 ＋ “ 项上输入了内容” ＋ #左引号 ＋ 当前编辑框.内容 ＋ #右引号, 0, )
  ⑺、可视——属性类型：基本属性； 数据类型：逻辑型。逻辑值为“真”时这个控件在运行后能看见，为“假”就看不见。
      例句：编辑框1.可视=假     （“编辑框1”不可见）
  ⑻、禁止——属性类型：基本属性； 数据类型：逻辑型。逻辑值为“假”时可以对该控件进行操作，为“真”时就禁止操作，该控件不能用。
      例句：哈哈哈.禁止=假       （“哈哈哈”是某个控件对象的名称）
  ⑼、鼠标指针——属性类型：基本属性； 数据类型：字节集。
      就是指定鼠标的形状。系统共指定以下鼠标形状及代号：0、默认型；1、标准箭头型；2、十字型；3、文本编辑型；4、沙漏型；5、箭头及问号型；6、箭头及沙漏型；7、禁止符型；8、四向箭头型；9、北<—>东箭头型；10、北<—>南箭头型；11、北<—>西箭头型；12、西<—>东箭头型；13、向上箭头型；14、自定义型。
      例句：驱动器框1.鼠标指针=11     （即鼠标放在驱动器框1上，形状就变成北<—>西箭头型）

 ㈡、基本事件。
     各种窗口单元（控件）都具有的事件我们就称基本事件。又称“固定事件”。
  ⑴、鼠标左键被按下。
      类型：系统基本事件。
      解析：处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去，如：_按钮1_被单击（）=假；如果不返回值或返回真，则将此事件继续传递到所属对象上去。
      语法：_对象名_鼠标左键被按下 （横向位置，纵向位置，功能键状态）
      参数：①、横向位置 整数型；指示鼠标在当前所处窗口单元中的横向位置。
            ②、纵向位置 整数型；指示鼠标在当前所处窗口单元中的纵向位置。
            ③、功能键状态 整数型；用于查看各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。（这样的解析我不太明白，等我明白了再用我自己的话来解析：①、为什么查看？②、怎样查看？专业术语真是害死人）
      例句：_按钮2_鼠标左键被按下 (200, 100, 1)     （调用“_按钮2_鼠标左键被按下”子程序）
  ⑵、鼠标左键被放开。参考⑴的解析。
  ⑶、被双击。参考⑴的解析。
  ⑷、鼠标右键被按下。参考⑴的解析。
  ⑸、鼠标右键被放开。参考⑴的解析。
  ⑹、鼠标位置被移动。参考⑴的解析。
  ⑺、获得焦点。
      类型：系统基本事件。
      解析：使鼠标光标移到该控件上去而产生的事件。比如一个输入框获得了焦点，打开程序就会在该输入框出现光标，这样不用鼠标选中该输入框也能输入文字。
      语法：_对象名_获取焦点 ()
      例句：_输入框1_获取焦点()     （调用“_输入框1_获取焦点”子程序）
  ⑻、失去焦点。
      参考⑺的解析。
  ⑼、按下某键。
      类型：系统基本事件。
      解析：按下键盘某个键而产生的事件。
      用途：我们设置快捷键时可以使用该事件。
      语法：_对象名_按下某键 （键代码，功能键状态）
      参数：
          键代码 整数型；为键常量值，如：“#F1键”、“#回车键” 等等。具体所有的键常量见库常量表。
          功能键状态 整数型；用于查看在按下本键的同时各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功键。（这样的解析我不太明白，等我明白了再用我自己的话来解析：①、为什么查看？②、怎样查看？专业术语真是害死人）
       例句：_按钮1_按下某键 （#回车键，4）
   ⑽、放开某键。
      参考⑼的解析。
   ⑾、字符输入。
      类型：系统基本事件。
      解析：菜鸟一般对帮助文件下半部的解析不明白，在这里只取其上半部解析：当用户按下和松开一个字符键时发生此事件。字符键包括任何可打字打印的键盘字符及回车（Enter）和退格（BackSpace）键。比如有一个子程序叫“_编辑框1_字符输入”，我们向“编辑框1”任意输入文字或者按“回车键”或“空格键”之类，都可使“编辑框1”产生该事件。
      语法：_对象名_字符输入 (字符代码)  （我也不明白“字符代码”的意思，哈哈）
      例句：_编辑框1_字符输入(1)

   从上面的介绍高手们应该清楚大多数菜鸟为什么看帮助文件很困难了吧,因为我上面的介绍大部分来自帮助文件，上面的介绍有很多是连我自己也不明白的，让大家失望了，哈哈。有时候有例句也不能解决问题，关键是要用菜鸟的话向菜鸟同志们（包括我）讲解表达清楚。
   试举一例让高手们参考：我写的〈易语言常用语句〉我自己觉得通俗易懂了，但仍然有人说“太简单了”，意思是说得不够清楚明白，太抽象了，不够具体。这已经体现出要让菜鸟入门，就要从最基本的讲起。


[这个贴子最后由bb88在 2002/04/30 01:24pm 编辑]

在编写课程时发现，有一部分初学者对于流程控制命令的代码搞不懂，比如条件语句，它里面的连接虚线是什么意思？现在就以条件流程控制命令为例来说明。

  ㈠、“如果—就—否则”语句。

     “如果—就—否则”语句的意思是“如果...就做...否则就...”，也就是符合比较式里说的条件时做某事，不符合该条件就做另外一件事。
    该语句的格式如下：

            如果（条件式） 就
                 程序语句一
            否则
                 程序语句二
          如果结束

    意思即是：“如果符合该条件式，就执行程序语句一，否则就执行程序语句二，然后结束该流程”。这个语句使程序有两个可供选择的执行路径，无论选择那个方向进行，程序都在共同之处结束。用下面的图例表示为：
[img]http://www.91asp.com/bbs.nsf/c53885e4b38488454825681f0035243d/fe78af7e39d880b848256bab001b6742/$FILE/liuchen.gif[/img]

   如果我们理解了这个图例，也就不难理解易语言流程控制代码中虚线连接的意思了，跟上面图例的线条连接的意思是一样的。易语言代码示例如下：
[img]http://www.91asp.com/bbs.nsf/c53885e4b38488454825681f0035243d/998c1abc319ae1a348256bab001bc36a/$FILE/liuchen3.gif[/img]
   所以我们编程时要分清该语句究竟是哪种语句的。比如我们要在上面的“程序语句一”中向前或向后插入“程序语句三”，那么当符合该条件式时，就会同时执行“程序语句一”和“程序语句三”。
   请比较一下下面两个流程控制的编写有什么不同。流程一：“如果密码≠“123”，则提示‘不能登陆’，并且返回原处，否则提示‘登陆成功’”。流程二：“如果密码≠“123”，则提示‘不能登陆’，否则返回原处，并且提示‘登陆成功’”。

  ㈡、“如果—就”语句。（即“如果真”语句）

      该语句的格式为：

            如果（条件式） 就
                 程序语句
         如果结束

      用图例表示为：
[img]http://www.91asp.com/bbs.nsf/c53885e4b38488454825681f0035243d/7e014eb64206b3a048256bab001b9200/$FILE/liuchen2.gif[/img]

  这个流程中，程序只有一个运行方向，也就是当符合条件时才执行。至于在易代码中怎样表示请看该流程图，这里就不画出来了。例句：“如果你敢删我的贴，我就打断你的腿”。

  总结：我们编写有关流程控制的代码时，可先用平常的语言表达出来，并结合流程图来规划，然后再转化为代码。


写注册项（）命令的使用方法

调用格式： 〈逻辑型〉 写注册项 （根目录，全路径注册项名，欲写入值）
英文名称：SaveRegItem
在 Windows 注册表中保存或建立指定的注册表项。如欲写入注册项默认值，请在项目名后加“\”号，如“test\”。成功返回真，否则返回假。与“写注册表项”命令不同的是本命令可以写任意位置处的注册表项。本命令为中级命令。
参数<1>的名称为“根目录”，类型为“整数型（int）”。可以为以下常量值之一： 1、#根类； 2、#现行设置； 3、#现行用户； 4、#本地机器； 5、#所有用户。
参数<2>的名称为“全路径注册项名”，类型为“文本型（text）”。
参数<3>的名称为“欲写入值”，类型为“通用型（all）”。参数值指定欲写入到指定注册表项中的值，只能为数值、文本或者字节集，否则命令将失败。

其实：＃根类----HKEY_CLASSES_ROOT    　　（根目录＝1）
     #现行设置----HKEY_CURRENT_CONFIG　（根目录＝2）
     #现行用户----HKEY_CURRENT_USER　　（根目录＝3）
     #本地机器---HKEY_LOCAL_MACHINE　　（根目录＝4）
     #所有用户---HKEY_USERS　　　　　　（根目录＝5）
    根目录可以用1、2、3、4、5数字写入，应该用哪一个根目录不可以乱来，必须在了解注册表的情况下才能操作，或在有关资料的指导下进行。全路径注册项名组成：路径（不含根目录）+注册项，欲写入值：可以是字符串。如要将一个程序加入注册表使其在开机后自动运行，那就是要把字符串“文件所在目录路径+文件名”写入到HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run中，实际书写方法如下：
            写注册项（4，“Software\Microsoft\Windows\CurrentVersion\Run”,“c:\wly\文件名.exe”）（注：Run是注册项）
    如果要删除，只要写：
            删除注册项（4，“Software\Microsoft\Windows\CurrentVersion\Run”）
    即可。
   该命令的特点是可以在注册表任何地方写入，即可以将给定的路径表达出来，而下面这个命令是为了方便使用，也只能写在一个相对固定的位置，方便易语言内部使用。如内部程序需要写注册项时，一般可以用这一个：
    调用格式： 〈逻辑型〉 写注册表项 （程序名称，节名称，注册表项名称，欲写入值）
英文名称：SaveSetting
在 Windows 注册表中保存或建立指定的注册表项设置值。成功返回真，否则返回假。本命令为初级命令。
参数<1>的名称为“程序名称”，类型为“文本型（text）”。包含应用程序的名称，用作在注册表中的入口名。
参数<2>的名称为“节名称”，类型为“文本型（text）”。包含欲写入的注册表项所处的节名称。
参数<3>的名称为“注册表项名称”，类型为“文本型（text）”。参数值指定欲写入的注册表项在其节中的名称。
参数<4>的名称为“欲写入值”，类型为“通用型（all）”。参数值指定欲写入到指定注册表项中的值，只能为数值、文本或者字节集，否则命令将失败。

        例如：要在一个叫“文件名.ini”的配置项中设定小节“项目1”，和项目“分类”，再在“分类”中填入数字，其表达方法为：
        写注册表项（“文件名.ini”,“项目1”，“分类”，数字）
        其实质效果相当于上面一个命令：
        写注册项（3，“Software\文件名.ini\项目1\分类”，数字）
 其中的数字可以是字符串，可以是十进制数，也可以是字节集，例：当作字符串写“5”，“abc”，在注册表中出现："5"，"abc"；当作十进制363写，在注册表中出现16进制DWORD值ox0000016b；当作字节集写｛5｝或｛12，2，25，...｝在注册表中出现的为二进制值5或12，2，25，...（注：大括号内是十进制数）
  相应的删除命令如下：
        删除注册表项（“文件名.ini”,“项目1”，“分类”）
调用格式： 〈逻辑型〉 删除注册表项 （程序名称，［节名称］，［注册表项名称］）
英文名称：DeleteSetting
在 Windows 注册表中，删除应用程序项目入口、注册表节或注册表项。成功返回真，否则返回假。本命令为初级命令。
参数<1>的名称为“程序名称”，类型为“文本型（text）”。包含应用程序的名称，用作在注册表中的入口名。如果该入口中已不存在节，且下一参数被省略或为空，则将此应用程序入口删除。
参数<2>的名称为“节名称”，类型为“文本型（text）”，可以被省略。指定包含被删除注册表项的节名称。如果下一参数被省略或为空，则将此注册表节连同其中所有的注册表项都删除。
参数<3>的名称为“注册表项名称”，类型为“文本型（text）”，可以被省略。参数值指定要删除注册表项的名称。


简单实现FTP下载，上传和HTTP下载

=========================================================

★★FTP下载，上传：

★创建网络连接
lngINet ＝ InternetOpen (“FTP Control”, 1, “”, “”, 0)
如果真 (lngINet ＝ 0)
   信息框 (“创建网络连接失败！”, 0, )
如果真结束

★登录FTP站点
lngINetConn ＝ InternetConnect (lngINet, FTP地址, 21, “anonymous”, “anonymous@yourhost.com”, 1, 134217728, 0)
如果真 (lngINetConn ＝ 0)
   返回 (“登录FTP站点失败！”)
如果真结束

★FTP下载
   blnRC ＝ FtpGetFile (lngINetConn, 远程文件, 本地文件, 假, 0, 1, 0)
   InternetCloseHandle (lngINetConn)
   InternetCloseHandle (lngINet)
   如果 (blnRC ＝ 假)
       返回 (“下载文件失败！”)
   否则
       返回 (“下载文件成功！”)
   如果结束

★FTP上传
   blnRC ＝ FtpPutFile (lngINetConn, 本地文件, 远程文件, 1, 0)
   InternetCloseHandle (lngINetConn)
   InternetCloseHandle (lngINet)
   如果 (blnRC ＝ 假)
       返回 (“上传文件失败！”)
   否则
       返回 (“上传文件成功！”)
   如果结束

=========================================================

★★HTTP下载
           lReturn ＝ URLDownloadToFile (0, 远程文件, 本地文件, 0, 0)
           如果 (lReturn ＝ 0)
               “下载完毕！”
           否则
               “不能下载！”


窗口程序集：窗口程序集1

------------------------------

子程序：_按钮1_被单击

标签5.标题 ＝ “”
编辑框1.内容 ＝ “”
编辑框2.内容 ＝ “”
标签8.标题 ＝ “”
_启动窗口.获取焦点 ()

------------------------------

子程序：_编辑框1_内容被改变

标签5.标题 ＝ 编辑框1.内容
_启动窗口.获取焦点 ()
  ※备注：恒有焦点的编辑框，不用鼠标选中也能输入
  ※备注：所谓“焦点”是指窗口或窗口单元被选中的状态
  ※备注：运用“_编辑框1_内容被改变”事件，做到输入输出同步
------------------------------

子程序：_编辑框2_内容被改变

标签8.标题 ＝ 编辑框2.内容
   ※备注：非恒有焦点的编辑框，要用鼠标选中才能输入

    （例程下载：
http://eyuyan.com/cgi-bin/lb5000/Download.cgi/1_3939_1.e）


高手们在指导新生学习易语言时，常常强调看手册来学习的重要性。的确，编程手册的全面性、准确性和专业性，是任何一本教程都无法可比的，所以我们学易语言时看手册当然是很重要了。但另一方面，做到了全面性就很难同时做到具体性，做到了专业性就很难做到通俗易懂，所以好的教程在具体性、易学性等方面上又是手册所无法相比的。
   基于以上说法，我们在学习易语言时好的方法是手册与教程相结合。比如编程时遇到需要查找的问题，包括某个命令的语法、某个对象的用法、文本处理有哪些命令之类，就需要用到手册。 又如我们需要学习一些实例、了解网络编程的方法之类，我们就可以参考有关教程来学习，可以捧着它一篇一篇地阅读学习。当然大多数时候是两者都发挥作用，比如培养编程思路、培养独自编写程序的能力等，是离不开手册运用与教本学习的。
   如果有时间，我也可以写一本手册库式教程，直接学习手册资料库里的材料。


本例演示控制窗口大小的方法，本例中使用了窗口的高度属性、宽度属性、鼠标位置被移动事件，还涉及到变量（参数）的定义、流程控制语句、逻辑运算、建立子程序等知识。
   第一步：建立用户界面，该用户界面只有一个窗口，没有其他控件。
   第二步：设置窗口的属性：背景色=（任选一种颜色）；边框=普通固定边框；标题=“可变窗口”。
   第三步：在程序代码窗口输入以下程序：

窗口程序集：窗口程序集1

------------------------------
子程序：__启动窗口_创建完毕

_启动窗口.宽度 ＝ 175
_启动窗口.高度 ＝ 100

------------------------------

子程序：__启动窗口_鼠标左键被放开
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

销毁 ()

------------------------------

子程序：__启动窗口_鼠标位置被移动
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

如果真 (横向位置 ≥ _启动窗口.宽度 － 10)
   _启动窗口.宽度 ＝ _启动窗口.宽度 ＋ 20
如果真结束
如果真 (纵向位置 ≥ _启动窗口.高度 － 50)
   _启动窗口.高度 ＝ _启动窗口.高度 ＋ 20
如果真结束

   第四步：用文件名“可变窗口”保存文件，然后运行程序，看一看鼠标在窗口中移动时窗口的变化。


[这个贴子最后由bb88在 2002/06/18 00:43am 编辑]

所谓面向对象的编程，就是程序代码由对象的属性、事件和方法来构成，所以我们要学用编程，就必须了解对象的属性、方法和事件，这样你才能理解代码的意思，为编程打下必需的知识基础。
说到控件（易语言称为窗口单元），我们不能不提对象。可以说对象跟控件在意思上相近，把对象画出来放到窗口上我们就称为控件（对象通过具体的控件来表现），比如“按钮”对象。但对象不一定表现为具体的控件，比如“菜单.可视=真”中，“菜单”这个对象在易语言中就找不到有控件。

㈠、什么是控件？
 “控件”在一些编程语言中又被称为“构件”、“部件”之类，易语言按其自身的语言逻辑一般称之为“窗口单元”。
 在实际应用程序时，常常要多次向计算机发送不同指令。那怎样发送指令？
是不是用嘴对计算机说：“现在我向你下达一个旨意，怎样怎样”、“长江、长江，请追击敌人，over”，然后计算机说：“喳！遵旨”、“yes，黄河，yes，黄河，over”？当然不是，是通过按钮、发话框、选择框之类的控件（易语言称为窗口单元）发送命令，然后又由这些控件来执行指令的（即有些控件常用来发令，有些主要用于执行命令）。所以控件（控制部件）我们可以简单地解析为：“用来发送指令、传递指令、执行指令和反馈指令的那种东东（部件）”。所以我们不要小看按钮之类的东东，没有它程序何从运行。让我们在以后的学习中了解“按钮_被单击"、"按钮_被双击"之类的发令方式，再逐步学好如何运用控件、扩展控件。

㈡、究竟什么是对象呢？
 通俗地说，它的意思跟“东西”、“事物”、“现象”之类相近，可以说世界上的一切东西都是对象：人、台灯、地球、凳子等都是对象（事物）。事物在时空、联系、运动和变化发展中存在，事物的相互联系构成运动。在程序中，我们称事物在时空中的存在为对象的“属性”，称事物的相互联系为程序及对象的“事件”，称由联系构成的运动为“方法”，称变化发展（主要是指事物属性的变化发展）为“过程”（程序或子程序）。

㈢、什么是对象的属性呢？
 就是对象的性质和特征等对象表现方式，一般是用来描述控件对象的外观特征。书本上说任何事物都有质（性质）和量两方面属性。比如一个人是男是女、是好人还是坏人、入党没有、姓名、民族等是一个人在质方面的属性，身高、年龄、体重、文化程度等是人的量方面的属性，也就是说考察一个人要从质和量两方面来考察，通过了解属性才能认识一个人。同理，编程中所使用的对象也是有属性的，没有属性，对象就无从依托、无从表现、无从理解，没有属性的对象是不存在的。
 比如“窗口”这个对象有“高度”、“宽度”、“标题”、“名称”等属性。有一些属性，一般控件都会有，比如“背景色”、“高度”、“宽度”等。有一些属性是某些控件所独有的，比如“表格”控件有“表格线颜色”、“标尺”等特殊属性。
 属性可分数值型属性（量）和逻辑型属性（质）。比如“编辑框1.左边=20”是赋编辑框对象予数值型属性，而“编辑框.可视=真”是赋予对象逻辑型属性。
 那么，我们怎样知道某个控件有哪些属性呢？有两种方法查找具体对象的属性：①、在易语言的设计界面的左边的工作夹里有个“属性夹”，在这里我们可以查找或设置被选中对象的属性；②、选“帮助→易语言知识库→目录→参考手册首页→系统核心支持库”，我们会发现那里列举了易语言所有的控件对象（窗口单元），点击某个控件对象，会显示该控件对象的所有属性、方法和事件。

㈣、什么是对象的事件呢？
  我们以一个例子来说明，比如“bb88骂Etp21 ，（致使）Etp21的脸色很难看，并且握紧了拳头”。在这个例子中，“bb88”和“Etp21”是怎样联系起来的？他们之间是什么关系？是通过骂这个动作联系的，图示：“bb88—（骂）→Etp21”，他们之间的关系是骂与被骂的关系，那么“Etp21的脸色很难看，并且握紧了拳头”这个程序是由程序操控者“bb88”骂的动作引起的（称为“事件驱动”），我们称“被骂”这个受动动作为“Etp21”这个对象的“事件”。
   事件可以解析为通过具体的控件使程序运行的一种驱动或受动指令，包括用户通过控件输入而由电脑接收的指令，如“按钮1.被单击”，向按钮发出“单击”的指令，那么“被单击”就是“按钮1”的事件；也包括程序运行的某种驱动或受动条件，比如“（时钟）周期事件”等。程序的受动方式（事件）包括接受的鼠标动作（被单击、被移动等）、键盘动作（按下某键、放开某键等）、时钟信号等。 事件也可以说我们对对象所做的操作。
   易语言是一门典型的面向对象编程的语言，它的整个程序都是由事件驱动的。其实我们的生活中就充满了各式各样的事件，比如“闯红灯”这个事件的发生会导致警察追杀你、走路撞到电线杆这个事件会导致头痛等。这些例子虽然滑稽，但可以清楚地解析事件的含义，就象你马上能体会到在什么地方单击鼠标时会发生什么，按下键盘时会发生什么，这些就是事件。程序启动后，并不能自动运行，而要等用户输入指令（比如按下某个按钮）它才运行某段程序。因此，windows程序从本质上来说，可以称之为是“事件驱动”的。
    易语言对象的事件包括自有事件和基本事件。自有事件是该种控件的特有事件，基本事件是各种对象共同具有的事件。
    那么，我们怎样知道某个控件对象有哪些事件呢？也是有两种方法查找具体对象的能接收的事件：①、选中某个控件对象后，在易语言编辑界面的左边“属性夹”里选“在此选择加入事件处理子程序”子夹，可以设置该控件的事件，并同时快速地在代码编辑区出现该事件的代码；②、选“帮助→易语言知识库→目录→参考手册首页→系统核心支持库”，我们会发现那里列举了易语言所有的控件对象（窗口单元），点击某个控件对象，会显示该控件对象的所有属性、方法和事件。

 ㈤、什么是对象的方法？
    以“Etp21的脸色很难看，并且握紧了拳头”这个程序来说，“握紧了拳头”这个程序运行的动作我们就称为“方法”。方法是一个具体对象能够执行的动作，它是指对象所固有完成某种任务的功能,可由我们在需要的时候调用。有的方法会有参数表，有的方法则不用参数，“参数”大概相当于方法的相关数据，包括相关对象属性值、系统命令、执行条件、项目、常量、子程序、函数乃至其他对象的方法等，都是可以调用的参数。执行、调用一个对象的方法的一般格式如下：
            对象名.方法名（参数）。
   例如需要在一个名为“购物篮”的列表框里添加一个叫“苹果”的列表项目，其语句如下：购物篮.加入项目（苹果）。在这个例句中，“加入项目”是“购物篮”的方法，“苹果”是其参数。不同的方法有不同的参数，一种方法可以有多种类型的参数。我们可以选“帮助→易语言知识库→目录→参考手册首页→系统核心支持库”，我们会发现那里列举了易语言所有的控件对象（窗口单元），点击某个控件对象，会显示该控件对象的所有属性、方法和事件，点击某个方法可以查看该方法的代码格式、可用的参数及其类型。
    可以看出，事件和方法都有相近的意思，它们都是一种动作，只不过事件是促使程序运行的一种外部动作，而方法是程序具体运行的一种动作（即程序怎样运行）。
    那么，我们怎样知道某个控件对象有哪些可供执行的方法呢？欲查看某类窗口单元具有哪些方法、这些方法的详细解释以及有哪些可用参数等，请到易语言设计界面的支持库夹中的“数据类型”分枝中寻找。譬如：想了解画板的所有方法，可以到“数据类型 -> 画板”下查看，如果点击“画板”数据类型下面的某个方法，会在代码编辑区里出现该方法的调用代码，我们可以利用这种功能来快速编辑代码。
    另一方法是：选“帮助→易语言知识库→目录→参考手册首页→系统核心支持库”，我们会发现那里列举了易语言所有的控件对象（窗口单元），点击某个控件对象，会显示该控件对象的所有属性、方法和事件。

 ㈥、对象的属性、事件和方法的综合运用。（理解一个事件的过程，即子程序）
   windows程序其实就是对象的属性、事件和方法的综合运用，比如“bb88骂Etp21 ，（致使）Etp21的脸色很难看，并且握紧了拳头”，转化为程序语言就是：

   子程序：骂_被单击              （有一个叫“骂”的按钮）
      Etp21.脸色=红一块青一块     （这个处理事件的代码可称为赋值型语句）
      Etp21.握紧拳头（）          （这个处理事件的代码可称为方法型语句）

   请找找这个程序有哪些对象、属性、方法和事件。事件过程一般表现为对象属性的变化、对象动作（方法）的执行以及指示下一事件的发生等。事件过程（子程序）的一般格式如下：

         子程序：对象名_事件名（）
              处理事件的代码
         （子程序结束）

    怎样理解这个程序格式？从上述格式中可以看到，某个事件过程（子程序）的名称主要由对象名和事件名组成，中间用下划线连接以区分清楚。不能随意改动该程序名，否则当指定事件发生时系统便无法调用相应的事件过程（程序）。又如果某个对象的某个事件发生了，但是没有为该事件编写响应事件的过程代码，这样对象所发生的这个事件就会毫无反应（比如点击“按钮1”不见反应）。

--------------------------------------------------------------------------------
交流附件上传地址：http://www.91asp.com/


[这个贴子最后由bb88在 2002/05/07 07:18pm 编辑]

http://www.91asp.com/bbs.nsf/0/6ecbeb8f130a18cb48256bb1002c87b4/$FILE/_82f8qq4trms9svl0jpav17k652f7q4_.e

子程序：_按钮1_被单击

如果真 (标签1.标题 ＝ “”)
   标签1.标题 ＝ “祖国你好！”
   返回 ()
如果真结束
如果真 (标签1.标题 ＝ “祖国你好！”)
   标签1.标题 ＝ “我的祖国”
   返回 ()
如果真结束
如果真 (标签1.标题 ＝ “我的祖国”)
   标签1.标题 ＝ “我会成功”
   返回 ()
如果真结束
如果真 (标签1.标题 ＝ “我会成功”)
   标签1.标题 ＝ “一个容易的语言”
   返回 ()
如果真结束
如果真 (标签1.标题 ＝ “一个容易的语言”)
   标签1.标题 ＝ “祖国你好！”
如果真结束


 这里的课程都是假设你用过frontpage等网页编辑工具或word之类的办公软件来讲的。因为易语言也是一种典型的可视化编程，其编辑窗口、设计图形界面的方法跟网页设计差不多，所以如果你用过以上所说的工具之一，就会对用易语言设计程序界面不难理解。
  如果你学会了易语言，就为以后再深造VB、VC、VC++等语言打下很好的基础。其实对于英语不过关的大多数易爱好者来说，如果你一开始就学VB等，可能学了一年也摸不着头脑。但是如果你从学易语言开始，比如跟着《菜鸟每日一课》来学，随随便便也能很快把bb88的三板斧学全。如果你是通过VB来学这三板斧的话，相信你虽然照猫画老虎一样也能编编程，但离开例子也能编就很难做到了，并且要理解和掌握这些三板斧所用的基本原理和基本知识，很可能认真学一年也不得其门，因为你很难理解那些弯弯曲曲的字母是什么意思。以上“如果”统统结束。
  可以不夸张地说，易语言是目前亚洲人编程入门的最好工具、、之、之一（其实应该是目前最好的）。但是，世界上目前还没有那种编程工具是十全十美的，每一种流行的工具都有它的优势和缺陷。在相当长的一段历史时期内，将没有那一种编程工具能够一统天下，而是八仙过海，各显其能。正因为如此，我们在从事具体的编程工作时，不应泥拘于是英文的还是中文的，是微软的还是吴涛的，你觉得那种好用，那种适合你用，你就用那种吧，邓爷爷说能抓老鼠就是好猫，然也。
  就专业的编程工作者来说，也常常是几种工具配合来用，比如软件的图形界面可以用flash、photoshop之类来设计；如果你想编写大型程序的原形甚至正版，可用易语言、VB等，以加快开发速度，等觉得可行了可改用其他工具开发正版；开发数据库应用程序可用相应的工具，但里面所涉及到的网络技术又可用其他工具，包括网页编程所用的脚本语言等。基于此，我们就不难理解为什么一些单位在招聘程序员时，要求应聘者最好能掌握几种应用工具了。
  以上的综合使用编程工具的方法我们可文绉绉地称之为“混合编程开发工作环境”。

--------------------------------------------------------------------------------
交流附件上传地址：http://www.91asp.com/


下面是我一年前写的一篇关于作生日卡的文章；希望对初学者有用。    用E语言轻松制作贺卡
一、准备工作：
  首先选好素材，即准备好动
画图片和背景音乐。

二、开始制作：
 1、启动E语言，选择新建，将
启动窗口的背景音乐属性设为“
祝你生日快乐”、边框的属性设
为“无边框”；在启动窗口中分
别放入一个标签、一个图片框、
一个时钟控件。选择一幅你喜欢
的图片，作为标签的底图，将标

签的边框属性设为“无边框”、标题属性改为：“福如东海 寿比南山”、文字颜色属性改为红色。调整图片框的大小，使其刚好遮盖住剩余的窗口，将图片框的底图属性设为事先准备好的动画图片。
 2、在“窗口程序集”中加入三个程序集容器（即通常所说的定义全局变量）：
窗口程序集：窗口程序集1

程序集容器：横坐标 数据类型：整数型
程序集容器：纵坐标 数据类型：整数型
程序集容器：计数器 数据类型：短整数型

 3、在“__启动窗口_创建完毕”子程序中输入如下程序（作初始化处理）：

子程序：__启动窗口_创建完毕

计数器 ＝ 1
横坐标 ＝ 200
时钟1.时钟周期 ＝ 100

 4、在“_图片框1_被双击” 子程序中输入如下语句(这段代码用于：当把鼠标移到图片框上时单击鼠标左键退出程序)：

子程序：_图片框1_鼠标左键被按下
返回值类型：逻辑型

参数：横向位置 数据类型：整数型
参数：纵向位置 数据类型：整数型
参数：功能键状态 数据类型：整数型

结束 ()

 5、在“_时钟1_周期事件”子程序中写入如下程序（用于自动控制窗口的移动口）：

子程序：_时钟1_周期事件

如果 (计数器 ＝ 1)
如果 (横坐标 ≤ 350)
横坐标 ＝ 横坐标 ＋ 1
纵坐标 ＝ 纵坐标 ＋ 1
移动 (横坐标, 纵坐标, 419, 272)
计数器 ＝ 1
否则
计数器 ＝ 2
如果结束
否则
如果 (横坐标 ≥ 200)
横坐标 ＝ 横坐标 － 1
纵坐标 ＝ 纵坐标 － 1
移动 (横坐标, 纵坐标, 419, 272)
计数器 ＝ 2
否则
计数器 ＝ 1
如果结束
如果结束

 好了，运行程序试试，是不是很酷！  下载：生日卡.zip(139k)含源代码


说明：字幕先逐渐变大，再逐渐变小，循环往复，直至程序退出。

窗口程序集：窗口程序集1

------------------------------

子程序：_时钟1_周期事件

局部容器：渐变字体      数据类型：长整数型      <静态>
局部容器：计数器  数据类型：整数型  <静态>

标签1.字体.字体大小 ＝ 渐变字体
计数器 ＝ (计数器 ＋ 1) ％ 140
如果真 (计数器 ＜ 60)
   渐变字体 ＝ 渐变字体 ＋ 2
如果真结束
如果真 (计数器 ＞ 80)
   渐变字体 ＝ 渐变字体 － 2
如果真结束

------------------------------

子程序：__启动窗口_创建完毕

_启动窗口.位置 ＝ 3
标签1.顶边 ＝ -20
标签1.高度 ＝ 取用户区高度 () ＋ 18
标签1.宽度 ＝ 取用户区宽度 ()


不好意思，我把我的《图片演示2.0》左看右看横看竖看，研究了半天，都看不出有什么值得一说的新技术。这个程序的所有功能就只是一个简单的“画板.复制（）”命令而已。
   不过既然答应浪花了，我就说说我的思路吧。先说说其中的一个百叶窗效果：

   程序文本如下：

子程序：从左往右百叶窗效果

局部容器：百叶宽度      数据类型：整数型
局部容器：容器1   数据类型：字节型

判断循环首 (百叶宽度 ＜ 演示画板.宽度 ÷ 10 ＋ 1)
   容器循环首 (1, 10, 1, 容器1)
       隐藏画板.复制 (((容器1 － 1) × 隐藏画板.宽度) ÷ 10, 0, 百叶宽度, 隐藏画
           板.高度, 演示画板, ((容器1 － 1) × 演示画板.宽度) ÷ 10, 0, )
   容器循环尾 ()
   百叶宽度 ＝ 百叶宽度 ＋ 1
   延时 (速度)
判断循环尾 ()

   《图片演示》的实现图片切换的方法，就是在窗口中添加两个一样的画板，一个用来演示，
一个隐藏，存放下一幅要显示的图象。然后，把隐藏画板中的图象用不同的方法复制到
演示画板上显示，从而实现不同的效果。
   这里我把百叶窗每一页百叶的最大宽度设为演示画板的十分之一。然后用循环依次从隐
藏画板中复制图象到演示画板。本程序中画板的宽度为400，所以百叶的最宽度为40，也就是
依次如下复制：

   隐藏画板.复制 (0, 0, 百叶宽度, 隐藏画板.高度, 演示画板, 0, 0, )
   隐藏画板.复制 (40, 0, 百叶宽度, 隐藏画板.高度, 演示画板, 40, 0, )
   隐藏画板.复制 (80, 0, 百叶宽度, 隐藏画板.高度, 演示画板, 80, 0, )
   ……
   隐藏画板.复制 (360, 0, 百叶宽度, 隐藏画板.高度, 演示画板, 360, 0, )

注：以上这段即相当于程序中的这一个循环：

   容器循环首 (1, 10, 1, 容器1)
       隐藏画板.复制 (((容器1 － 1) × 隐藏画板.宽度) ÷ 10, 0, 百叶宽度, 隐藏画
板.高度, 演示画板, ((容器1 － 1) × 演示画板.宽度) ÷ 10, 0, )
   容器循环尾 ()

   其中百叶宽度从0开始，每次增加1，直到40，当宽度达到40时，所有图象复制完毕，子程
序结束。则又相当于外面那个循环：

   判断循环首 (百叶宽度 ＜ 演示画板.宽度 ÷ 10 ＋ 1)
       ……
       ……（省略号内容为上述那个循环）
       百叶宽度 ＝ 百叶宽度 ＋ 1
       延时 (速度)
   判断循环尾 ()

   不知道我这样说清楚了没有？


一步一步跟我学写易程序二

今天我们在上一次所书写程序的基础上继续加入新功能：密码校验，即只有存在该密码的用户才能进入系统，并且进入的用户将被记录到系统日志数据库中去。
请先参阅《一步一步跟我学写易程序一》。

一、数据库部分：
根据本程序的需要，需要增加两个数据库：“密码”和“系统日志”。

密码数据库的字段列表如下：
1、密码  类型为“文本型”，字段长度为10，本字段用作记录用户密码；
2、密码所有者  类型为“文本型”，字段长度为10，本字段用作记录用户名。

数据库建立完毕后保存名称为“密码”。

系统日志数据库的字段列表如下：
3、进入者  类型为“文本型”，字段长度为10，本字段用作记录进入用户的名称；
4、进入时间  类型为“日期时间型”，本字段用作记录用户进入系统的时间。

数据库建立完毕后保存名称为“系统日志”。

数据库创建完毕后将产生两个文件：“密码.edb”、“系统日志.edb”。

二、输入初始数据：
为了演示程序功能，我们使用“数据库->记录编辑器”菜单功能打开所创建的“密码”数据库，并加入一条初始记录：
密码：“123”
密码所有者：“吴涛”

三、编写处理程序：
1、界面部分：
本程序无新增的界面部分。

2、代码部分：
程序在“__启动窗口_创建完毕”子程序前面增加了一部分代码以完成新增功能：

子程序：__启动窗口_创建完毕

局部容器：密码    数据类型：文本型
局部容器：进入者  数据类型：文本型

如果真 (输入框 (“密码校验”, “请输入密码:”, , 密码, ) ＝ 假)
*备注：可以自己设计一个密码输入窗体代替输入框
   结束 ()
    *备注：如果不输入密码,则直接退出.
如果真结束
如果 (打开 (“密码”, , , , , , ) ＝ 真 且 查找 (读 (“密码”) ＝ 密码))
   进入者 ＝ 读 (“密码所有者”)
   如果真 (打开 (“系统日志”, , , , , , ))
       加记录 (进入者, 取现行时间 ())
        *备注：记录当前进入者和进入时间
   如果真结束
   全部关闭 ()
    *备注：关闭可能已经打开的所有数据库
否则
   信息框 (“密码校验失败!”, 0, “错误”)
   结束 ()
如果结束

…… 后面为原有代码

程序分析：
在启动窗口创建完毕调用“__启动窗口_创建完毕”时，程序打开一个输入框请求用户输入密码，如果用户没有输入密码就退出输入框，程序直接结束，否则程序打开“密码”数据库并在该库中查找对应密码，如果没有找到，显示密码校验失败并退出程序。如果找到，则将用户进入信息记录到系统日志数据库中。

具体程序可以到 http://eyuyan.com/step2.zip 下载。


                  易语言网络功能详解：－浪花原创
这些都是我个人对网络的理解，也不一定全对。只能作为参考：

                在易语言支持库的网络通信里：
                第一、取主机名：gethostname,这个主机名，其实就是你自己的计算机的名字，当然，这个名字也就是你的计算机在网络上的标识。这个命令用处不是很大。此命令返回的数据类型为文本型。

                第二、通信测试：其实也就是dos命令里面的ping命令，大家在ping里都可以看到，它还有很多参数，比如说ping -t
                *******等，它所测试的目标可以是IP地址，也可以是对方的主机名（不会不懂IP地址吧？如果不懂，那你就可以运行一下winipcfg，你就可以看到你自己计算机的IP地址了）所以，结合上面的第一个命令，我们就可以做出一个很简单的程序来测试一下：标签。标题＝到文本（通信测试（取主机名，）），这一句代表什么意思呢？首先取出本计算机的主机名，然后再去ping本机，最后返回ping本机时所需要的时间再显示到标签。其实这就等同于dos里的ping
                -t 127.0.0.1这个命令，其中的127.0.0.1即是代表本机。本命令返回数据类型为整数型。
                第三、转换为主机名：本命令其实大家都可以测试一下，我相信有很多朋友的QQ都安装有查好友IP地址的补丁程序，这时，当你看到对方的IP地址时，你就可以应用一下这个软件了：标签。标题＝转换为主机名（QQ上所取回的IP地址），当然由于网络的问题，你有可能得多转换几次才能成功地取回对方的主机名。本命令返回数据类型为文本型。

                第四、转换为IP地址：本命令基本和上一个命令相同，只是转换的对象和目的是相反的。本命令返回数据类型为文本型。

                以上，是对网络方面的一些基本知道是理解。
                网络控件：
                一、数据报：这是基于udp协议的一种通信方式，udp协议是一种小数据量的，安全性能不高的一种通信方式，它可以用在局域网内实现内部通信，当用数据报来实现通信时整个通信建立的过程如下：数据报A向数据报B的指定端口发送数据（数据报B则在指定的端口进行监听）当数据报B监听到有数据到达时，则用数据报的取回数据的命令来取出数据，而此时的数据为字集节型，如果你所传送的数据为文本型，则需将其转换为文本型（用从字集节转换），当然，也可以为文件或其它类型，这时，我们怎么样去判断我们所传送的是什么类型的数据呢？作为接收方，我们是不可能知道的，所以，我们就得在数据的发送方也就是数据报A里的发送数据命令里加上一些标识，比如我们可以在第一个所要所送的数据里，采用一些不常用的符号作为分隔（可参照E-QQ里的数据传送）然后我们指定第一段为传送的数据类型的说明，第二段才为具体的数据，这时，接收方当接收到数据时，首先根据第一段来判断数据类型，然后再根据数据类型来进行转换。这样，我们基本上就可以实现简单的udp通信（包括文本和数据的传送）

                二、客户和服务器：这个应该很容易就明白他们之间的关系吧，服务器就象供货商，所以，我们每一个客户都应该向服务器发送请求才能进行通信。本命令是基于tcp/ip协议的通信，它可以应用在互联网上，安全性较高。具体应用如下：当一个客户需要和服务器建立通信时，首先需要进行连接，连接时就需要知道服务器的IP地址和监听端口。
                客户。边接是一个逻辑型的命令，返回的值表示是否和服务器建立了连接。当连接成功后，即可向服务器所送数据，发送数据的方式还是采用；上面udp协议中的方式，加上标识。发送数据也是一个逻辑型的命令，可根据其返回值来判断是否发送成功。客户要和服务器通信，同样也得接收服务器所返回的数据，这时，客户也就有一个数据到达的事件。当客户接收到从服务器返回的数据时，自动产生本事件，此时，你就可以采用取加数据命令来取出客户端所收到的数据。此时，客户和服务器的通信即成功建立。当不需要和服务器边接时，请注意用断开连接命令来断开和服务器的连接，也就是说让服务器知道你断开的消息。

                服务器端相比客户端，多出了一个取回客户而少了一个连接、一个断开连接的命令。因为作为服务器，它是让客户来连接的，而不是去连接客户的。服务器端的事件有三个，一是数据到达，这相信大家都能理解了。还有两个，一个是客户进入，当有客户进入时自动产生本事件，所以，当有不同的客户连接进来时，我们可以用取回客户的命令去得知道到当前连接到本服务器的客户的IP地址和端口号（所以，我们在此时可以结合上面的命令来得知对方的主机名）这们，我们就可以知道是谁连接上了服务器，同理，在客户离开的事件里，也可以用同样的方法去得知是谁和服务器断开了连接。服务器的发送数据方法也和客户的发送数据基本相同。

                三、端口通信：此控件目前对于我们应用不大，如写拨号程序时才会使用且功能不全，所以暂时不讲解。

                以上这些均来自浪花对网络功能的个人理解，如有讲得不对的地方，请各位朋友指正，谢谢！

                [ 此消息由 浪花 在 2001-09-20.09:34:03 编辑过 ]


窗口程序集：窗口程序集1

程序集容器：鼠标状态    数据类型：整数型

------------------------------

子程序：_外形框1_鼠标位置被移动
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

如果真 (鼠标状态 ≠ 0)
   外形框1.左边 ＝ (外形框1.左边 ＋ 横向位置) － 外形框1.宽度 ÷ 2
   列表框1.宽度 ＝ 外形框1.左边 － 外形框1.宽度 × 2 － 2
如果真结束
如果真 (列表框1.宽度 ＜ 96)
   列表框1.宽度 ＝ 96
如果真结束
如果真 (外形框1.左边 ＜ 126)
   外形框1.左边 ＝ 126
如果真结束

------------------------------

子程序：_外形框1_鼠标左键被按下
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

鼠标状态 ＝ 1

------------------------------

子程序：_外形框1_鼠标左键被放开
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

鼠标状态 ＝ 0

------------------------------

子程序：__启动窗口_鼠标位置被移动
返回值类型：逻辑型

参数：横向位置    数据类型：整数型
参数：纵向位置    数据类型：整数型
参数：功能键状态  数据类型：整数型

鼠标状态 ＝ 0


下列代码是用我的“多功能代码转换器”（0.8版）从vb代码里直接翻译过来的：

窗口程序集：窗口程序集1

------------------------------

子程序：__启动窗口_创建完毕

_启动窗口.位置 ＝ 3
标签1.高度 ＝ 取用户区高度 ()
标签1.宽度 ＝ 取用户区宽度 ()
标签1.背景颜色 ＝ #黑色
标签1.标题 ＝ “逐渐变小的文本”
标签1.字体.字体大小 ＝ 150
标签1.渐变背景颜色1 ＝ #绿色
标签1.可视 ＝ 真
时钟1.时钟周期 ＝ 100

------------------------------

子程序：_时钟1_周期事件

如果 (标签1.字体.字体大小 ＞ 2)
   标签1.字体.字体大小 ＝ 标签1.字体.字体大小 － 2
   标签1.左边 ＝ (_启动窗口.宽度 － 标签1.宽度) ÷ 2
   标签1.顶边 ＝ (_启动窗口.高度 － 标签1.高度) ÷ 2
否则
   标签1.可视 ＝ 假
   时钟1.时钟周期 ＝ 0
如果结束