欢迎使用易语言

易语言

主页一 主页二 论坛

三分钟就能编程序

    一位根本不懂英语的普通电脑用户，只要使用易语言，可以在短短三分钟内编写出视窗（Windows）系统下的电脑程序，您相信吗？不信，请随我一试：

    1、 启动易语言，在右边工具箱中选中“标签”，用鼠标拖动绘制到设计窗口上部中央；

    2、 在工具箱中选中“按钮”，用鼠标绘制到窗口下部中央；

    3、 双击所绘制的“按钮”，输入以下文字后回车：
        bq1.bt = "祖国您好！"

    至此，恭喜您，这个程序已经编写完毕，可以随时运行。

    上面所提及的易语言，是由飞扬软件工作室推出的全中文全可视化电脑程序编写语言。她的诞生结束了外国编程语言长期垄断中国市场的局面，使中国人终于可以使用自己的母语来编写各种实用电脑程序。她具有最彻底的中文支持，从程序显示到程序输入，用户不需要接触半点英文。输入程序时只要懂得拼音就行了，譬如上面输入“bq1.bt”，系统将自动转换为对应的“标签1.标题”程序语句（“bq1.bt”为“标签1.标题”中每个汉字声母的组合）。程序全部以中文方式显示，运算符号全部显示为对应的中文符号，日期时间以中文格式呈现，以便于我国用户理解、阅读程序。语言中专门提供了适合中国国情的命令，如中文格式日期时间处理、汉字发音处理、全半角字符处理、人民币金额处理等等。

    更酷的是，为方便初级用户入门，易语言使用流程图显示并编辑程序。用户在编写的过程中可以随时看到运行时程序所将经过的路线，有助于培养编程思路，提高解决问题的能力。图示：在易语言中编辑返回两个数值中较大值的程序的画面：

    还值得一提的是，易语言提供全程帮助跟踪支持，编程时用户可随时看到有关当前操作详细且全面的帮助信息。系统还可以将用户程序编译为 EXE 可执行文件，脱离语言环境单独运行。

另外，易语言提供多用户数据库支持，用户可以使用她来编写各种实用的数据库应用程序。

    为支持中高级用户，易语言提供了诸如对象、数据类型自定义、子程序指针、参考容器、常量、外部动态连接库命令调用等等很多高级语言特性。目前已包含数百条命令、数十类窗口单元数据类型、数百个常量。用户可以使用她来满足几乎所有的编程需求，具有极强的实用、适用及易用性，丝毫不逊于国外的同类软件。

基础知识

程序的输入方法

编程基础知识

一步一步跟我学易语言

编程手册

语言手册

数据库应用手册

参考手册

操作方法

安装及运行

如何即时查询帮助

操作手册

欢迎使用易语言(原名E语言）

    欢迎使用此款由飞扬工作室出品的 Windows 环境下的全中文实用电脑程序编写语言，她支持现今所有的 Windows 32 位操作系统，即：Windows 9X、ME、2000、NT 等，提供了中国电脑用户开发 Windows 应用程序最方便直观、快捷实用的方法，适合于初中级别电脑用户使用。尤其是根本不懂英文或者英文了解很少的初级用户，可以通过使用本语言极其快速地进入 Windows 程序编写的大门。

易语言与其它编程语言相比，具有以下主要优点：

  1. 全可视化支持。一般的可视化编程语言，仅支持图形用户界面的可视化设计操作，而易语言除了支持此类可视化，还支持程序流程的即时可视化呈视。即：用户在编写程序的过程中，可以即时看到当前程序的运行流程及路线，以助于培养编程思路，提高解决编程问题的能力；

  2. 全中文支持。作为一款由中国人自己设计的编程语言，易语言在中文处理方面做了大量的工作。用户在编写程序的过程中如果愿意，可以不接触任何英文。根本不懂英文或者英文了解很少的用户可以直接使用本语言来编写程序，不存在任何障碍。
    <1>、中文名称的快速录入。易语言内置四种名称输入法：首拼、全拼、双拼、英文。 三种拼音输入法均全面支持南方音。使用这些输入法用户能够以英文语句的录入速度来录入全中文程序语句。详情请参阅《程序的输入方法》节；
    <2>、程序全部以中文方式显示，运算符号全部显示为对应的中文符号，日期时间以中文格式呈现，以便于我国用户理解、阅读程序；
    <3>、语言中专门提供了适合中国国情的命令，如中文格式日期时间处理、汉字发音处理、全半角字符处理、人民币金额处理等等。以后此方面将会继续得到大量扩充及增强。

  3. 易语言由基本系统和运行支持库两部分组成，两者之间通过使用飞扬工作室自行定义的接口技术进行协作。运行支持库内提供了易语言的所有语言要素，如：命令、窗口和报表单元数据类型、普通数据类型、常量等等，还可以通过提供“加入（AddIn）”功能来扩充易语言基本系统。运行支持库可以被随意增减、抽换或升级，基本系统对运行支持库提供了详细的版本控制。本技术给用户带来的最大好处是：
    <1>、用户可以根据行业或自身需要定制易语言；
    <2>、由于运行支持库的不断增多、升级，易语言的功能将被迅速扩充；
    <3>、由于运行支持库可以仅包含声明而不包含实际的运行支持代码，并且可以随时被更新或抽换，这样可使人们通过国际互联网与服务器进行远程易语言交流（譬如复杂型电子商务、远程控制等等）成为可能，此是以后易语言互联网版本的发展方向。

  4. 即时编译并自动规范格式的语句录入方式。在输入程序的过程中，每条程序语句被录入后，都将被立即进行初步编译，一些通常的语法错误，将及时得到报告并要求进行修改。所录入语句被自动规范为统一格式后存放，因此任何人所编写的任何程序其呈现格式都完全一致。对于应用程序的协作开发、交流和维护非常有利。

    5.

  5. 系统内置的自动名称管理器能够对用户所定义的各类名称进行跟踪管理。譬如：假设程序中现存在一个名为“取最大值”的子程序，而且在很多地方都调用了该子程序。现在用户根据需要想把该子程序更改为另外一个名称，在传统的编程语言中，用户需要先更改该子程序的名称，然后搜寻整个应用程序，逐一找到使用了该子程序的地方，把名称相应地改变过来。在易语言中，用户只需更改子程序名称即可，程序中其它所有使用了该子程序的地方，其名称都将被自动快速地更改过来。

  6. 贯穿全程的即时且全面的信息帮助。用户在进行任何操作的过程中，均能够在状态行上或提示夹中获得有关当前操作位置的详细相关信息。譬如：如果用户移动光标到某程序行，马上就能够得到此程序行上所有命令的定义、参数、使用方法等等信息。

寻求合作

    飞扬工作室愿意与其它公司、机构、个人在以下方面寻求合作：

  • 为您的软件系统制作基于易语言的子系统，譬如类似于 Word 的宏语言，能够极大地提高软件的灵活性，让用户能够自主配置或组合使用您的软件功能。

  • 可以根据行业或特定需要为您定制易语言；

  • 承接国内外各类软件开发业务；
  • 与具有相当实力的公司或机构合作开发易语言的互联网电子商务版本

    飞扬工作室联系方式：

  电话／传真：(0717)4217328

  联系人：吴涛

  电子信箱：fly@eyuyan.com 或 zjwutao@yc.hb.cninfo.net


程序的输入方法

返回首页

[ 概念 ]
[  输入字类型指定  ]
[  书写拼音输入字的方法  ]
[  输入或修改名称本身  ]
[ 程序输入举例
]

一、概念：

    为了便于输入程序，易语言内置四种名称输入法：首拼、全拼、双拼、英文。三种拼音输入法均支持南方音及多音字。首拼输入法及全拼输入法在系统中被合并为“首拼及全拼输入法”，系统自动判别所输入的拼音是首拼方式还是全拼方式。双拼输入法的编码规则与 Windows 系统所提供的双拼输入法一致。例如：欲输入“取整 (1.23)”语句，各种输入法的输入文本为：

  • 首拼及全拼输入法：qz (1.23) 或者 quzheng (1.23)

  • 双拼输入法：quvg (1.23)

  • 英文输入法：int (1.23)

    以上各种输入法的名称部分输入文本（如：qz、quzheng、quvg、int）简称为“输入字”。拼音类输入法的输入字（如：qz、quzheng、quvg）简称为“拼音输入字”。首拼及全拼输入法的输入字简称为“首拼及全拼输入字”，双拼输入法的输入字简称为“双拼输入字”。

    输入字可以用来输入程序中所涉及到的一切名称，包括：

  • 所有当前运行支持库中所提供的命令、窗口和报表单元数据类型及其属性和方法、普通数据类型及其成员和方法、库定义常量等等名称；

  • 用户在程序中定义的子程序参数、子程序局部容器、程序集容器、全局容器名称；

  • 用户定义的子程序、 Dll 外部命令名称；

  • 用户定义的数据类型及其成员名称；

  • 用户所加入的资源和所定义的常量的名称；

  • 用户在设计窗口或报表时所定义的窗口单元、菜单项目或报表单元名称；

  • 系统数据类型名称。如：“整数型”、“小数型”等等；

  • 系统常量名称。如：逻辑值常量“真”和“假”等。

在使用首拼输入字时，需要注意纯韵母发音汉字的输入。如：“按钮”中的“按”字，它的发音是韵母“an”。对于此类汉字，在首拼输入法中必须写全。譬如“按钮”的首拼输入字就应该为“ann”（即an, n）。

二、输入字类型指定：

    在程序中书写输入字时，可以使用一个半角符号来引导该输入字，以指定其类型。各输入字的类型引导符号为：

  • 首拼及全拼输入字： 分号（“;”） 如： ;qz、;quzheng

  • 双拼输入字： 冒号（“:”） 如： :quvg

  • 英文输入字： 单引号（“'”） 如： 'int

    系统具有一个当前默认输入法状态，如果某输入字前没有加上类型引导符号，则默认是属于该输入法的输入字。系统安装完毕后，当前默认输入法为“首拼及全拼输入法”。这就意味着：在当前默认输入法为“首拼及全拼输入法”的时候，要想使用双拼输入字，则必须在输入字的前面加上类型引导符“:”。不过此时英文输入字前可以加也可以不加类型引导符“'”。其原因为：如果当前默认类型输入字不能找到匹配的目标名称时，系统将自动把该输入字转换为英文输入字后再去寻找匹配名称一次。

    可以使用“程序 -> 系统配置 - 输入夹 - 默认输入法”菜单功能修改当前默认输入法。

三、书写拼音输入字的方法（以首拼及全拼输入字举例）

  • 为了匹配目标名称中的大小写英文字母和半角数字，请在相应位置处使用对应的大写英文字母和半角数字。如：“jsjA”匹配“计算机a”和“计算机A”，“jsj1”匹配“计算机1”；

  • 为了匹配目标名称中的汉字符号或不知道发音的汉字，请在相应位置处使用该汉字。如：“j算j1”匹配“计算机1”。此功能用作修改程序非常方便，例如：欲将“如果”命令修改为“如果真”命令，只需要在“如果”的后面加上“z”即可；

  • 拼音输入字内不能包含除了“_”以外的所有其它半角符号。

  • 如果某拼音输入字匹配了多个目标名称，系统将自动列出来以供选择。如果不想让系统列出来，可以在拼音输入字后加上单引号（“'”），再后跟用作指定序号的数字 1 - 9 或大小写字母（对应于数值 10 - 35）即可。如：输入字“xc”具有两个匹配命令名称：“相乘”和“相除”，可以使用输入字“xc'1”来指定“相乘”命令，“xc'2”来指定“相除”命令。

四、输入或修改名称本身

    在程序中经常需要输入或修改各类名称本身，譬如：加入一个新子程序后，可能需要修改其子程序名称；在设计窗口上绘制上一个窗口单元后，可能需要修改其窗口单元名称，等等。在输入或修改名称本身的过程中，输入字不能用来引用其它已有名称，但可以引用专用的名称输入词组。所谓“名称输入词组”，类似于通常中文输入法中的自定义词组。用户在输入或修改名称的过程中按下空格键后，系统将自动使用位于当前光标前的输入字去搜寻系统中的名称输入词组，如果找到，就用匹配词组替换该输入字，否则加亮显示该输入字，表示未找到。系统中所有的名称输入词组都被存放在名为“name.txt”的文本文件中，用户可以使用系统中所提供的功能（程序 -> 系统设置 - 输入夹 - 编辑名称输入词组）进行修改，也可以使用其它文本编辑器直接修改，但注意要以纯文本的格式保存。文本文件中各词组之间应该用换行或全半角空格或制表符分隔开。词组内容必须为全中文，且不能包括 GBK 汉字。系统在处理这些词组时，不符合要求的将被滤去。

程序输入举例

    下面列出了输入一个判别两个数值大小并返回较大值的子程序的全过程，前提为：默认输入法为“首拼及全拼输入法”：

  1. 进入易系统后使用“插入 -> 新子程序集”菜单功能插入一个子程序集到程序（如果程序中已经有了子程序集，直接跳转到该子程序集即可）；

  2. 按下 Ctrl + N 插入一个新的子程序；

  3. 在“返回值类型”栏中输入“zsx”后回车（“zsx”匹配系统数据类型名称“整数型”）；

  4. 回车插入一个空参数，在“参数名”栏中输入“sz”后按空格（“sz”匹配系统安装时提供的名称输入词组文件中的“数值”词组），再输入“1”后回车；

  5. 在“类型”栏中输入“zsx”后回车；

  6. 重复第4、5步一次，但参数名改输入为“数值2”；

  7. 移动光标到参数表下的空程序语句上；

  8. 输入“rg (sz1 > sz2)”（中间的空格可以略去。“rg”匹配“如果”命令名称，“sz1”匹配“数值1”参数名称，“sz2”匹配“数值2”参数名称）；

  9. 下移一行光标后输入“fh (sz1)”（“fh”匹配“返回”命令名称）；

  10. 再下移一行光标后输入“fh (sz2)”。


编程基础知识

返回首页

[ 窗口单元及事件驱动 ]
[ 对象 ]
    [ 对象的概念 ]　[ 对象的创建 ]　[ 在程序中引用对象的属性及方法 ]
[ 编程举例 ]

    创建一个易应用程序只需要短短几分钟的时间 － 通过在设计窗口上“绘制”诸如编辑框和按钮等窗口单元来创建用户界面。然后，为窗口和窗口单元设置属性以规定诸如标题、位置、尺寸等的值。最后，编写处理程序将生命真正赋于程序。

窗口单元及事件驱动

    窗口单元及事件驱动是使用易语言在 Windows 环境下编程的基础知识。所谓“窗口单元”，即用作组成用户图形界面的基本成员，譬如：窗口、编辑框、图片框等等。窗口单元按可否容纳其它窗口单元划分为容器类和非容器类。按运行时是否可能具有可视外形划分为界面类和功能类。容器类窗口单元内可以包容其它的窗口单元，譬如窗口、选择夹、图片框等都属于容器类。而功能类窗口单元仅用作在其所在窗口上提供某种功能，譬如时钟、打印机等。

    所有窗口单元在其状态被改变或操作者在其上进行了某种操作后，都有可能向用户程序发送某种事件。譬如：当窗口的尺寸被改变后，窗口将向用户程序发送尺寸被改变的事件，用作给予用户程序通过相应的事件处理程序调整窗口单元布局或进行其它处理的机会。当操作者单击按钮后，“按钮”窗口单元将向用户程序发送按钮被单击的事件，等等。但并不是所有的状态改变或操作事件都将被发送到用户程序，那些易系统认为用户程序没有必要处理的或者系统完全能够自行处理的事件，都将被系统直接处理。这样用户可以快速创建强大的应用程序而毋需涉及不必要的细节。

    在传统的应用程序中，应用程序自身控制了执行哪一部分程序和按何种顺序执行程序，即从第一行开始并按应用程序中预定的路径执行。在事件驱动的应用程序中，程序不是按照预定的路径执行而是在响应不同的事件时执行不同的事件处理程序。如前所述，事件可以由窗口单元在其状态被改变或者操作者在其上进行了某种操作后触发。这些事件的顺序决定了程序执行的顺序，因此应用程序每次运行时所经过的程序的路径都是不同的。在执行中由于程序本身也可以对窗口单元的状态进行改变，譬如，在程序中改变编辑框中的内容将引发编辑框的“内容被改变”事件。如果该事件在用户程序中定义了相应的处理程序，则该处理程序将被执行。如果原来假设该事件仅能由操作者在该文本框中进行输入或修改所触发，则可能会产生意料之外的结果。所以在设计应用程序时必须完全理解并牢记事件驱动的特点。

对象

    易语言是一种基于对象的编程语言，能否熟练地使用易语言，理解对象的概念及其使用方法非常重要。

    一、对象的概念：

    所谓“对象”，即为属性、方法和事件的集合。在人们的日常生活中，“对象”也可以理解为“事物”，比如说，一个人、一件东西、一起事情，都可以被认为是一个“对象”。 对象的属性记录对象特征，对象的方法提供了对对象进行某种操作的途径，对象的事件用作通知外部它的状态发生了改变。譬如说一个电源开关，其外形、颜色、使用电压等等都可以认为是该电源开关“对象”的属性，而关闭或打开此电源开关则可以认为是电源开关“对象”的方法。在关闭或打开的同时，它可能产生事件，譬如通知与其相连的电器开始工作或者停止等等。在易程序中，例如“画板”窗口单元，即是一个典型的对象，它具有 “画笔类型”、“画笔粗细”等属性，同时又有“画直线”、“画矩形”等方法，在需要重画时还会产生“绘画”事件；

    二、对象的创建：

    在易程序中，对象通过定义数据类型的实例来创建。定义方法有多种，譬如将一个窗口单元绘制到设计窗口上或者在程序中定义一个具有该数据类型的容器。被绘制到设计窗口上的窗口单元或者所定义的容器即为对象。所谓“数据类型”，只是定义了对象的构架，就好比是房屋设计图和实际房屋之间的关系。设计图只是指定了该房屋的构造和布局，在使用该设计图建造出实际的房屋之前，房屋对象是根本不存在的。同样，一个数据类型可以定义出无限多个对象，就好比使用某一份房屋设计图可以建造出无数同样的房屋一样；

    三、在程序中引用对象的属性及方法：

    通过在对象及其属性或者方法之间加上句点（“.”）即可以引用对象的属性及方法。譬如以下语句：“容器1 = 画板1.画笔粗细”（读取“画板1”对象的“画笔粗细”属性），“画板1.画笔粗细 = 1”（修改属性）或者“画板1.画直线 (100, 100, 200, 200)”（调用方法）等。

举例

    下面举例说明一步步创建显示 “祖国，您好！”信息的易程序。

    创建易应用程序有三个主要步骤：

  • 创建应用程序界面；

  • 设置属性；

  • 编写代码。

    为了说明这一实现过程，按照以下步骤可创建一个简单应用程序，该应用程序的界面由一个标签和一个命令按钮组成。单击命令按钮，标签中会出现 "祖国，您好！" 信息。

    一、创建应用程序界面：

    建造易应用程序的第一步是创建并设计窗口，这些窗口将是应用程序界面的基础。然后在窗口上绘制构成界面的窗口单元。对于目前的应用程序，可用窗口单元工具箱中的两个窗口单元：标签和按钮。

    <1>、进入系统后跳转到名称为“_启动窗口”的窗口设计界面。如果在安装系统后没有使用“程序 -> 系统设置”菜单功能修改易程序的启动方式，新建程序进入编辑后就直接停留在“_启动窗口”窗口的设计界面；

    <2>、在窗口单元工具箱中选中“标签”窗口单元，使用鼠标将它绘制到窗口的上边中部；

    <3>、在窗口单元工具箱中选中“按钮”窗口单元，使用鼠标将它绘制到窗口的下边中部。

    二、设置属性：

    选中被绘制在窗口上的“标签”窗口单元，在属性表中将其“标题”属性值改为空。

    三、编写代码：

    <1>、双击被绘制在窗口上的“按钮”窗口单元或者选中该窗口单元后在属性表最下边的组合框内选取“被单击”事件从而开始编写对应的事件处理子程序；

    <2>、在子程序的程序部分输入“bq1.bt = "祖国，您好！"”后回车。

    至此，我们的第一个应用程序已经创建完毕，按下 F5 键或使用“运行 -> 运行”菜单功能开始执行程序，单击窗口中的按钮，标签中即出现 "祖国，您好！" 信息。编制好的例程请见附带的 FirstApp.e 程序文件。


新网页 2

一步一步跟我学易语言（原名 E 语言）

第一章：入门 | 第二章：进一步了解窗口单元属性的使用方法 | 第三章：其它的一些窗口单元知识
第四章：初步了解数据类型 | 第五章：初步了解容器 | 第六章：容器的写入规则
第七章：命令 | 第八章：进一步了解命令 | 第九章：流程控制命令
第十章：窗口单元的方法 | 第十一章：静态容器 | 第十二章：数组容器
第十三章：容器的初始值及动态管理数组容器 | 第十四章：初步了解子程序 | 第十五章：进一步了解子程序
第十六章：窗口程序集与子程序的关系 | 第十七章：子程序参数 | 第十八章：容器的使用范围
第十九章：子程序指针 | 第二十章：常数、常量与资源 | 第二十一章：自定义数据类型
第二十二章： Dll 命令 | 第二十三章：参考容器 | 第二十四章：窗口单元的事件
第二十五章：字节集 | 第二十六章：动态创建窗口单元 |
欢迎光临我们的主页 http://eyuyan.com 或 http://esoft.3322.net 查看最新易语言资讯。 欢迎使用电子邮件 fly@eyuyan.com 或者 zjwutao@yc.hb.cninfo.net 与我们联系！ 飞扬软件工作室 吴涛


用户如何发布自己的程序到其它计算机

如何安装自己的易程序到其它计算机

返回首页

当程序编写完毕后，您可能要将该程序发布到其它计算机上去运行，请按照以下步骤进行：

一、打开程序后使用“F.程序 -> B.编译发布版本”系统菜单项编译出该程序的 EXE 可执行文件，并将它拷贝到目的计算机；

二、如果目的计算机没有安装易语言系统，请将下列文件拷贝到该计算机 Windows 系统目录 System 子目录内：
1、易语言系统附带的 krnl.fnr （ krnl.fne 也可以）文件；
2、如果您的程序需要播放 MP3 音乐，需要拷贝易语言系统附带的 mp3.run 文件；
3、如果您的程序需要显示 JPG 或 JPEG 图片，需要拷贝易语言系统附带的 jpeg.run 文件。

在易语言以后版本中，将会提供制作用户程序安装系统的功能。


语言手册

返回首页

[ 易语言的命名约定 ]
[ 程序的启动方式 ]
[ 易语言的语言要素 ]
    [ 数据类型 ]
        [ 系统基本数据类型 ]
            [ 字节型 ]　[ 短整数型 ]　[ 整数型 ]　[ 长整数型 ]
            [ 小数型 ]　[ 双精度小数型 ]　[ 逻辑型 ]　[ 日期时间型 ]
            [ 文本型 ]　[ 字节集 ]　[ 子程序指针 ]
        [ 库定义数据类型 ]
        [ 自定义数据类型 ]
        [ 引用库定义或自定义数据类型对象的成员 ]
    [ 命令及操作符 ]
    [ 子程序 ]
        [ 子程序参数 ]
    [ Dll 命令 ]
    [ 程序集 ]
    [ 容器 ]
        [ 全局容器 ]　[ 程序集容器 ]　[ 局部容器 ]
        [ 容器的初始化 ]　[ 容器的赋值 ]　[ 容器的定义 ]　[ 参考容器 ]
    [ 常数 ]
        [ 数值型常数 ]　[ 逻辑型常数 ]　[ 日期时间型常数 ]　[ 文本常数 ]
        [ 子程序指针常数 ]　[ 常数集 ]
    [ 常量 ]
    [ 资源 ]
    [ 窗口、窗口单元及窗口程序集 ]
        [ 窗口的载入 ]
        [ 窗口单元的固定事件 ]
        [ 窗口单元的固定属性 ]

易语言的命名约定

    在易应用程序的编写过程中，用户涉及到定义各类名称，如：子程序名、容器名、数据类型名等等，这些名称的命名规则为：名称的首字母必须为全半角字母或汉字，其它字符必须为全半角字母、全半角数字或者汉字。虽然名称中允许半角字符“_”存在，但它被保留为系统专用，因此不要使用。与其它的编程语言相比，易语言的命名规则有以下特点：

  • 无长度限制，用户可以尽情地使用长名称来进行名称描述；

  • 永远不会与易语言的关键字产生冲突。譬如：现已存在“如果”命令，但用户仍然可以定义一个名称为“如果”的容器，两者之间不会产生任何冲突。

程序的启动方式

    每个易应用程序都可以在两种启动方式中选择一种，即：

  • 通过名称为“_启动窗口”的窗口启动；

  • 通过名称为“_启动子程序”的子程序启动。

    系统安装后默认为第一种启动方式，用户可以使用“程序 -> 系统配置 - 通常夹 - 程序启动方式”菜单功能进行更改。

    在第一种启动方式下，程序运行时系统将自动查找并载入名称为“_启动窗口”的窗口。在第二种启动方式下系统将自动执行名称为“_启动子程序”的子程序。

易语言的语言要素

    所有的易应用程序，都由下列语言要素或其中的一部分组成：

    一、 数据类型

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • 库定义数据类型：

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

  • 自定义数据类型：

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

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

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

    二、命令及操作符

    命令由运行支持库提供给用户在程序中使用，它们被分为很多类。有些命令的最后一个参数可以被扩展，譬如“相加”，它的“加数”参数可以被无限制地扩展，用作支持连续相加。这些命令在录入到程序中后在编辑窗口内其首部会显示出一个右双箭头作为标志。命令中的某些参数也有可能可以被省略，即调用时可以不提供参数数据。具体情况请参阅《支持库手册》。

    下面列出所有具有操作符的命令及其操作符运算优先级，值越小运算优先级越高。优先级高的命令在计算表达式时将被先执行，同优先级的命令按顺序执行：

命令名称 | 优先级 | 中文操作符号 | 英文操作符号
负 | 1 | － | -
相乘 | 2 | × | *
相除 | 2 | ÷ | /
整除 | 3 | ＼ | \
求余数 | 4 | ％ | % 或 Mod
相加 | 5 | ＋ | +
相减 | 5 | － | -
不等于 | 6 | ≠ | <> 或 !=
等于 | 6 | ＝ | = 或 ==
小于 | 6 | ＜ | <
大于 | 6 | ＞ | >
小于等于 | 6 | ≤ | <=
大于等于 | 6 | ≥ | >=
近似等于 | 6 | ≈ | ?=
并且 | 7 | 且 | And 或 &&
或者 | 8 | 或 | Or 或 ||
赋值 | 9 | ＝ | =

    三、子程序

    将程序分割成较小的逻辑单元就可以简化程序设计任务，这些部件被称为子程序。 子程序可用于压缩重复任务或共享任务，例如，压缩频繁的计算处理等等。

用子程序编程有两大好处：

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

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

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

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

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

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

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

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

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

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

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

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

  3. 数组。意义同上。

五、程序集

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

六、容器

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

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

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

  • 容器的初始化

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

  • 容器的赋值

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

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

  • 定义容器时的主要属性

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

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

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

  4. 数组。设置当前容器是否为数组容器及数组各维的上限值（即成员数目）。如为多维数组，定义时各上限值之间用逗号分隔。引用容器数组中某成员的方法为使用被中括号括住的从 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 或光标键在窗口上各单元之间移动焦点时的顺序。当窗口被载入后，输入焦点将被交给具有最小停留顺序值的单元。


易语言数据库手册

易语言数据库应用手册

返回首页

易语言的数据库功能大部分基于 XBASE 方式，所以您如果曾经接触过 XBASE 数据库系统中的任何一款，如：DBASE、FOXBASE、FOXPRO 等等，就能够相当快地了解并应用易语言的数据库。

所有易语言数据库支持命令的具体解释请在数据库命令参考手册中查看，下面介绍一些概念和编程应用知识。

一、易语言数据库文件的组成：

.edb | 数据库主文件
.edt | 数据库辅助数据文件，仅在数据库中存在备注型或者字节集型字段时才存在，文件名称除了后缀外与数据库主文件相同，它必须与.edb文件放在同一目录中。
.enx | 数据库索引文件。使用 B+ 树结构，由用户根据需要自行创建，用作加快记录的查找速度。

二、数据库的内部结构：

易语言数据库由行和列组成，如下面的数据库内容：

姓名 | 工资 | 扣除 | 实发
周丰 | 1500 | 200 |
王自飞 | 2000 | 350 |
王闯 | 1200 | 25 |
李建业 | 1300 | 340 |

其中每一行被称为一条记录，每一列称为一个字段。如上面的数据库就有四条记录和四个字段。

字段具有“名称”、“类型”、“最大文本长度”三个属性，有关介绍如下：

<1>、名称： 字段名称文本的长度必须在 16 个字符以内；
<2>、类型： 可以为以下常量值之一： 1、#字节型； 2、#短整数型； 3、#整数型； 4、#长整数型； 5、#小数型； 6、#双精度小数型； 7、#逻辑型； 8、#日期时间型； 10、#文本型； 11、#字节集型； 12、#备注型；
<3>、最大文本长度： 此属性仅当字段类型为“文本型”时才有效，用作指定文本的最大可能长度，其值范围必须在 1 到 512 之间。如果字段类型不为“文本型”，本属性无效。当写入数据到数据库中的文本型字段内时，多出的部分将被自动剪切。

三、系统中的“数据库”菜单功能：

您可以使用“数据库”菜单下的“结构编辑器”来创建一个指定结构的数据库或者修改一个已存在数据库的现有结构。然后，使用“记录编辑器”可以加入或修改初始记录数据。

值得告诉大家的是：这两个菜单功能皆通过调用 dbmanger.exe 文件（由 dbmanger.e 易程序生成）来完成，dbmanger.e 源程序已经随系统一起提供，用户可以对其进行修改或者扩充，使之更能满足您的需要。

下面介绍一些数据库应用程序中常用的编程知识，首先请下载并查看一下示例工资数据库 gz.edb ，其结构如下：

字段名称 | 类型 | 最大文本长度
姓名 | 文本型 | 10
工资 | 小数型 |
扣除 | 小数型
实发 | 小数型

其中的“实发”字段在本数据库中并没有被实际使用，仅用作方便对某些命令进行举例。

一、编程前的准备工作：

强烈推荐：在开始编写数据库应用程序之前，请将程序中所需使用数据库的名称及其内所有字段名设置为常量，因为常量可以使用系统内部的输入法来很快地输入。如：上面数据库内具有一个名称为“姓名”的字段，如果此字段名已经被设置为了常量，那么在程序中需要引用它时可以简单地输入 #xm ，而如果没有设置为常量，您就必须使用 Windows 系统的输入法来一个字一个字地输入 “姓名” ，这样岂非太麻烦了吗？为了让您能够快速地加入所有的相关数据库常量，在“数据库”菜单下有一个“加入数据库常量”功能，使用此功能可以一次性将指定数据库的名称及其所有字段名加入为常量。下面的讲述中假设您已经做了此准备工作。

二、数据库本身的常用操作：

1、创建数据库：

欲在程序中创建数据库请使用“创建”命令，如欲创建上面的示例工资数据库 gz.edb ，可以使用类似以下代码：

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

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

2、打开数据库：

欲打开指定数据库，请使用“打开”命令。可以同时打开多个数据库（其数目仅受 Windows 操作系统限制）。

注意易语言的数据库抛弃了 XBASE 的工作区概念，以便可以同时打开更多的数据库。

3、置当前数据库：

系统内部有一个“当前数据库”状态值，它被用来指向某一个已被打开的数据库。绝大部分数据库操作命令都针对当前数据库，譬如：记录指针的移动、字段的读写等等。用户可以使用“置当前库”命令来改变系统中“当前数据库”状态值的指向。如：

打开 (“gz”, , , , , , )
打开 (“gz1”, , , , , , )
置当前库 (“gz”)
置当前库 (“gz1”)

4、关闭数据库：

欲关闭当前数据库，请使用“关闭”命令。欲一次性关闭已打开的所有数据库，请使用“全部关闭”命令。

三、记录范围、字段范围、数据库表达式：

易语言中很多数据库命令都支持定义记录范围和字段范围，如：“复制记录”命令能够将当前数据库的记录复制到另外一个数据库文件，其调用格式的后半部分如下：

复制记录 （数据库文件名，记录条件，字段范围，… ）

其中，“记录条件”参数即用作让用户定义记录范围，用户需要使用一个子语句来提供参数数据。如，将示例数据库中所有姓王的员工记录都拷贝到新数据库 gzb.edb 中：

复制记录 (“gzb”, 读 (#姓名) ≈ “王”, )
输入方法：fzjl("gzb",d(#xm)?="王")

其中：读 (#姓名) ≈ “王” 即是用作定义记录范围的子语句，这与 XBASE 的格式基本一样，只不过在 XBASE 中可以直接使用字段名称，而易语言由于不是解释型语言，所以使用 读 （xxx） 替换（其中 xxx 为字段名）。

假如您只想把示例数据库中的“姓名”和“工资”字段复制过去，就需要使用字段范围参数：

复制记录 (“gzb”, , #姓名, #工资)

字段范围参数一般都为数据库命令的最后一个参数，以便让用户通过增加参数来同时提供多个字段，不过您也可以使用数组来做同样的工作：

局部容器：欲复制字段 数据类型：文本型 数组：0

加入成员 (欲复制字段, #姓名)
加入成员 (欲复制字段, #工资)
复制记录 (“gzb”, , 欲复制字段)

假如您想把数据库中所有员工的工资都加上 100 元，就需要使用数据库表达式。完成此工作的相关数据库命令“替换”的调用格式的后半部分如下：

替换 （替换范围，字段名称或替换数据，… ）

其每一个“字段名称或替换数据”参数对应“字段名称”、“替换数据”参数各一个。

语句如下：

替换 (真, #工资, 读 (#工资) ＋ 100)

其中，#工资 为字段名称，读 (#工资) ＋ 100 即为数据库表达式，用作提供“工资”字段替换数据的获取方法。

可以同时替换多个字段，如： 替换 (真, #工资, 读 (#工资) ＋ 100, #扣除, 0) 语句可以同时将“扣除”字段清零。

数据库表达式中也可以同时使用多个字段，如： 替换 (真, #实发, 读 (#工资) － 读 (#扣除)) 语句可以计算出每一个员工的实发工资。

还有很多数据库命令使用了数据库表达式，如：

计算最大的实发工资并跳到其员工记录： 取最大值 (读 (#工资) － 读 (#扣除), )

根据实发工资排序到 gzb.edb ： 计算排序 (“gzb”, 读 (#工资) － 读 (#扣除), , , )

四、当前记录指针：

每一个被打开的数据库都有一个“当前记录指针”状态值，它指向数据库中的某一条记录，用作为一些记录读写命令提供位置指示。如：“读”、“写”、“删除”等等。它除了指向正常的记录外，还可能具有以下状态值之一：

1、首记录前。表明当前记录指针已经移动到了数据库首记录的前面，此时如果执行读写当前记录的命令肯定会失败，因为无法找到对应的记录读写位置。使用“首记录前”命令可以测试到此状态值；

2、尾记录后。表明当前记录指针已经移动到了数据库最后一条记录的后面，此时如果执行读写当前记录的命令也会失败。使用“尾记录后”命令可以测试到此状态值；

使用“取记录号”命令可以取回当前记录指针所指向记录的编号（从 1 开始）。如果为 0 ，表示在首记录前，如果大于最大记录编号，表明在尾记录后。

“到首记录”命令可以将当前记录指针移动到数据库的首记录上，“到尾记录”命令可以将当前记录指针移动到数据库的最后一条记录上。“跳过”命令可以相对移动当前记录指针值。

通过移动当前记录指针，我们可以遍历数据库中的所有记录：

到首记录 ()
判断循环首 (尾记录后 () ＝ 假)
进行所需操作。
 跳过 ()
判断循环尾 ()

反向遍历：

到尾记录 ()
判断循环首 (首记录前 () ＝ 假)
进行所需操作。
 跳过 (-1)
判断循环尾 ()

五、读写字段：

记录字段的读写均在当前数据库的当前记录处进行，主要为以下命令：

1、“读”。如： 读 （#姓名） 可以返回当前记录处员工的姓名；
2、“写”。如： 写 （#姓名，“张三”） 可以将当前记录处员工的姓名改为“张三”；
3、“读字段”和“写字段”可以读写非当前数据库内的记录字段；
4、“修改”命令可以一次性修改当前记录的多个字段。如： 修改 (“王五”, 2000, 100) 语句可以将当前记录的员工姓名改变为“王五”，工资改为 2000 ，扣除改为 100 。

六、添加记录：

使用“加空记录”命令可以在当前数据库的尾部添加一条新的空记录。

使用“加记录”命令可以同时提供欲添加数据。如： 加记录 (“王五”, 2000) 语句可以在当前数据库的尾部添加一条名为“王五”，工资为 2000 ，扣除为 0 的新员工记录。

使用“添加”命令可以将其它数据库内的记录添加到本数据库，如： 添加 (“gzb”, , ) 可以将 gzb.edb 数据库中的所有记录添加到当前数据库的尾部； 添加 (“gzb”, 取记录号 () ≤ 10, ) 语句可以仅添加前 10 条记录； 添加 (“gzb”, 是否已删除 () ＝ 假, ) 语句可以仅添加所有未被删除的记录。

七、删除记录：

与 XBASE 数据库一样，记录使用“删除”命令删除，但删除后并不马上从数据库中清除，仅仅只被加上一个删除标记，依旧存在并可以正常访问。只有当执行“彻底删除”命令后，这些被加上删除标记的记录才会被从数据库中真正清除。

使用“是否已删除”命令可以查看当前记录是否被加上了删除标记，被加上删除标记的记录可以使用“恢复删除”命令取消其删除标记。

使用“清空”命令可以彻底删除当前数据库内的所有记录。

八、查找记录：

查找记录有两种方法：不使用索引和使用索引。

1、不使用索引：

查找在示例数据库中所有姓王的员工记录的方法类似如下：

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

注意与 XBASE 不同的是：易语言的查找从当前记录开始。

与易语言中的拼音处理类命令结合可以解决在汉字中极常见的近音搜寻问题：

查找 (发音比较 (“王屋”, 删全部空 (读 (#姓名)), 真))
查找 (输入字比较 (“wangwu”, 删全部空 (读 (#姓名)), 真, ))
查找 (输入字比较 (“ww”, 删全部空 (读 (#姓名)), 真, ))

语句中的“删全部空”命令用作预先去除字段数据中可能存在的全半角空格，如果确定所有记录的该字段数据中都不存在空格，可以去掉此命令。

第一条语句可以查找出当前数据库中所有姓名发音为“王屋”的员工，如：“王五”、“王舞”等等； 第二条语句完成类似的工作，不过使用的是全拼拼音编码；第三条语句使用的是首拼拼音编码。

2、使用索引：

可以使用结构管理器预先在 gz.edb 上建立索引文件，也可以在程序中创建：

新建索引 (“gz”, , , , #姓名)

上面的语句建立了一个名为 gz.enx 的索引文件，它基于示例数据库的“姓名”字段，您也可以建立基于多个字段的索引文件。

索引只有被打开后才能被使用。使用“新建索引”命令新建的索引会被自动打开并设置为当前索引。对于已经存在的索引文件，您必须在打开数据库时同步打开：

打开 (“gz”, , , , , , “gz”)

此语句同步打开了 gz.enx 数据库索引文件，并将其设置为当前索引。

在数据库中搜寻所有姓名为“王五”的员工：

置当前索引 (“gz”) 如果当前索引已经为 gz.enx ，则不需要此语句。
到首记录 （） 如果当前记录指针在首记录上，则不需要此语句。
判断循环首 (索引查找 (“王五”))
进行所需操作。
 跳过 ()
判断循环尾 ()

为了解决近音汉字搜寻问题，易语言中可以建立发音索引文件：

新建索引 (“gz”, #读音索引, #不区分大小写 ＋ #忽略所有空格, , #姓名)
新建索引 (“gz”, #南方读音索引, #不区分大小写 ＋ #忽略所有空格, , #姓名)

这两条语句分别建立了一个基于标准读音和一个基于南方读音的索引文件。

使用发音索引文件即可进行近音搜寻，如： 索引查找 (“王屋”) 就可以找到“王五”。

在打开数据库时应该使用其“索引文件表”参数同时打开所有的索引文件，以便索引文件能够得到及时的更新。您也可以使用“更新索引”命令来强制更新当前索引文件。

九、查看数据库命令是否执行成功：

大多数的数据库命令执行完毕后都会返回一个逻辑值，表明是否执行成功。但是也有一部分命令无法做到这一点，如：“取最大值”等。

您可以在任何数据库命令执行完毕后立即调用“取错误码”命令来查看其是否执行成功。如果成功，“取错误码”命令将返回 0 ，否则将返回一个非 0 的错误值。

另外，如果发现命令执行失败，立即调用“取错误信息”命令可以取回对应的错误信息文本，当然是全中文的。


系统核心支持库

命令类别：

流程控制 | 算术运算 | 逻辑比较 | 位运算
容器操作 | 数组操作 | 环境存取 | 拼音处理
文本操作 | 字节集操作 | 数值转换 | 时间操作
磁盘操作 | 文件读写 | 系统处理 | 媒体播放
程序调试 | 其他 | 数据库 |

窗口单元数据类型：

窗口 | 编辑框 | 图片框 | 外形框
画板 | 分组框 | 标签 | 按钮
选择框 | 单选框 | 组合框 | 列表框
选择列表框 | 横向滚动条 | 纵向滚动条 | 进度条
滑块条 | 选择夹 | 影像框 | 日期框
月历 | 驱动器框 | 目录框 | 文件框
颜色选择器 | 超级链接框 | 调节器 | 通用对话框
时钟 | 打印机 |  |

其它数据类型：

报表 菜单 字体 字段信息

常量表...


流程控制

流程控制 类别 跳至：系统核心支持库


如果

如果 命令 所属类别：流程控制

本命令根据提供的逻辑参数的值，来决定是否改变程序的执行位置，如果提供的逻辑参数值为真，程序继续顺序向下执行，否则跳转到左侧箭头线指向的命令处去执行。

语法： 无返回值 如果 （条件）

参数名 | 描 述
条件 | 必需的；逻辑型。本条件值的结果决定下一步程序执行位置。

示例：返回较大值的子程序。

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

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

如果 (数值1 ＞ 数值2)
返回 (数值1)
否则
返回 (数值2)
如果结束

参见： 语法的描述规则、示例的书写格式、基本数据类型


如果真

如果真 命令 所属类别：流程控制

本命令根据提供的逻辑参数的值，来决定是否改变程序的执行位置，如果提供的逻辑参数值为真，程序继续顺序向下执行，否则跳转到左侧箭头线指向的命令处去执行。同“如果”命令相比，本命令没有为假时的程序部分。

语法： 无返回值 如果真 （条件）

参数名 | 描 述
条件 | 必需的；逻辑型。本条件值的结果决定下一步程序执行位置。

示例：返回较大值的子程序。

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

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

如果真 (数值1 ＞ 数值2)
返回 (数值1)
如果真结束
返回 (数值2)


判断

判断 命令 所属类别：流程控制

本命令根据提供的逻辑参数的值，来决定是否改变程序的执行位置，如果提供的逻辑参数值为真，程序继续顺序向下执行，否则跳转到下一分枝处去继续判断。

语法： 无返回值 判断 （条件）

参数名 | 描 述
条件 | 必需的；逻辑型。本条件值的结果决定下一步程序执行位置。

示例：


判断循环首

判断循环首 命令 所属类别：流程控制

本命令根据提供的逻辑参数的值，来决定是否进入循环。如果提供的逻辑参数值为真，程序顺序执行下一条命令进入循环，否则跳转到本命令所对应的“判断循环尾”命令的下一条命令处以跳出循环。

语法： 无返回值 判断循环首 （条件）

参数名 | 描 述
条件 | 必需的；逻辑型。本条件值的结果决定下一步程序执行位置。

示例：将数值 0 - 9 显示在画板上。

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

判断循环首 (容器1 ＜ 10)
画板1.滚动写行 (容器1)
容器1 ＝ 容器1 ＋ 1
判断循环尾 ()


循环判断首

循环判断首 命令 所属类别：流程控制

执行本命令后将顺序执行下一条命令进入程序循环。

语法： 无返回值 循环判断首 （）

示例：将数值 0 - 9 显示在画板上。

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

循环判断首 ()
画板1.滚动写行 (容器1)
容器1 ＝ 容器1 ＋ 1
循环判断尾 (容器1 ＜ 10)


计次循环首

计次循环首 命令 所属类别：流程控制

执行本命令将把循环体内的命令重复执行指定的次数。提供的整数参数值决定将重复执行的次数。

语法： 无返回值 计次循环首 （循环次数，［已循环次数记录容器］）

参数名 | 描 述
循环次数 | 必需的；整数型。本数值指定执行计次循环体内所有命令的次数。
已循环次数记录容器 | 可选的；数值型，参数数据只能提供容器。本数值型容器用作记录当前循环首已经被进入过的次数（从 1 开始），程序可以直接取用此容器中的值。

示例：将数值 1 - 10 显示在画板上。

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

计次循环首 (10, 容器1)
画板1.滚动写行 (容器1)
计次循环尾 ()


容器循环首

容器循环首 命令 所属类别：流程控制

执行本命令将利用容器对循环体内的命令进行循环执行。第一次执行此命令时将使用“容器起始值”参数初始化“循环容器”参数所指定的容器。每次（包括第一次）执行到此命令处都将判断循环容器内的值是否已经超过“容器目标值”参数所指定的值，如已超过，则跳转到对应的“容器循环尾”命令的下一条命令处继续执行，否则顺序执行下一条语句继续进行循环。

语法： 无返回值 容器循环首 （容器起始值，容器目标值，容器递增值，［循环容器］）

参数名 | 描 述
容器起始值 | 必需的；整数型，初始值为“1”。定义循环容器的起始数值。
容器目标值 | 必需的；整数型。定义循环容器的目标数值，在循环首部如果发现容器值已大于此目标值时将跳出循环。
容器递增值 | 必需的；整数型，初始值为“1”。每次执行到循环尾部时都将把此值加入到循环容器中去，此值可为正数或负数，如为正数则递增，为负数则递减。
循环容器 | 可选的；数值型，参数数据只能提供容器。本数值型容器将用作控制循环执行次数，在循环尾部将自动递增或递减该容器内的数值。如果被省略，命令将自动使用内部临时容器。

示例：将十以内的奇数正序和倒序显示在画板上。

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

容器循环首 (1, 10, 2, 容器1)
画板1.滚动写行 (容器1)
容器循环尾 ()
容器循环首 (9, 1, -2, 容器1)
画板1.滚动写行 (容器1)
容器循环尾 ()


到循环尾

到循环尾 命令 所属类别：流程控制

本命令转移当前程序执行位置到当前所处循环体的循环尾语句处。

语法： 无返回值 到循环尾 （）

示例：显示 10 以内的所有偶数。

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

计次循环首 (10, 容器1)
如果真 ((容器1 － 1) ％ 2 ≠ 0)
到循环尾 ()
如果真结束
画板1.滚动写行 (容器1 － 1)
计次循环尾 ()


跳出循环

跳出循环 命令 所属类别：流程控制

本命令转移当前程序执行位置到当前所处循环体循环尾语句的下一条语句处。

语法： 无返回值 跳出循环 （）

示例：显示 1、2、3、4、5 。

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

计次循环首 (10, 容器1)
如果真 (容器1 ＞ 5)
跳出循环 ()
如果真结束
画板1.滚动写行 (容器1)
计次循环尾 ()


返回

返回 命令 所属类别：流程控制

本命令转移当前程序执行位置到调用本子程序语句的下一条语句处,并可根据需要返回一个值到子程序调用处。

语法： 无返回值 返回 （［返回到子程序调用处的值］）

参数名 | 描 述
返回到子程序调用处的值 | 可选的；通用型。

示例：显示 1 和 2 之间的较大值：

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

画板1.滚动写行 (取最大数值 (1, 2))

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

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

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

如果真 (数值1 ＞ 数值2)
返回 (数值1)
如果真结束
返回 (数值2)


结束

结束 命令 所属类别：流程控制

本命令结束当前易程序的运行。

语法： 无返回值 结束 （）

示例：


算术运算

算术运算 类别 跳至：系统核心支持库

相乘 | 相除 | 整除 | 求余数
相加 | 相减 | 负 | 取符号
取绝对值 | 取整 | 绝对取整 | 四舍五入
求次方 | 求平方根 | 求正弦 | 求余弦
求正切 | 求反正切 | 求自然对数 | 求反对数
是否运算正确 | 置随机数种子 | 取随机数 |


相乘

相乘 命令 所属类别：算术运算

返回两个数值的乘积，运算符号为“*”或“×”。

语法： 数值型 相乘 （被乘数，乘数，… ）

参数名 | 描 述
被乘数 | 必需的；数值型。
乘数 | 必需的；可扩充的；数值型。

示例：


相除

相除 命令 所属类别：算术运算

返回两个数值的商，运算符号为“/”或“÷”。

语法： 数值型 相除 （被除数，除数，… ）

参数名 | 描 述
被除数 | 必需的；数值型。
除数 | 必需的；可扩充的；数值型。

示例：


整除

整除 命令 所属类别：算术运算

求出两个数值的商，并返回其整数部分，运算符号为“\”。

语法： 数值型 整除 （被除数，除数，… ）

参数名 | 描 述
被除数 | 必需的；数值型。
除数 | 必需的；可扩充的；数值型。

示例：


求余数

求余数 命令 所属类别：算术运算

求出两个数值的商，并返回余数部分，运算符号为“%”或“Mod”。

语法： 数值型 求余数 （被除数，除数，… ）

参数名 | 描 述
被除数 | 必需的；数值型。
除数 | 必需的；可扩充的；数值型。

示例：


相加

相加 命令 所属类别：算术运算

运算符号为“+”，用途为：1、返回两个数值的和；2、将两个文本首尾连接起来，返回连接后的文本；3、将两个字节集首尾连接起来，返回连接后的字节集。

语法： 通用型 相加 （被加数或文本或字节集，加数或文本或字节集，… ）

参数名 | 描 述
被加数或文本或字节集 | 必需的；通用型。
加数或文本或字节集 | 必需的；可扩充的；通用型。

示例：


相减

相减 命令 所属类别：算术运算

返回两个数值的差，运算符号为“-”。

语法： 数值型 相减 （被减数，减数，… ）

参数名 | 描 述
被减数 | 必需的；数值型。
减数 | 必需的；可扩充的；数值型。

示例：


负

负 命令 所属类别：算术运算

反转一个数值的正负符号并返回反转后的值，运算符号为“-”（放在表达式首）。

语法： 数值型 负 （数值）

参数名 | 描 述
数值 | 必需的；数值型。

示例：


取符号

取符号 命令 所属类别：算术运算

返回一个整数，如果小于零，表明给定数值为负；如果等于零，表明给定数值为零；如果大于零，表明给定数值为正。

语法： 整数型 取符号 （欲取其符号的数值）

参数名 | 描 述
欲取其符号的数值 | 必需的；数值型。

示例：


取绝对值

取绝对值 命令 所属类别：算术运算

如果所提供数值为字节型，则将直接返回该数值。

语法： 数值型 取绝对值 （欲取其绝对值的数值）

参数名 | 描 述
欲取其绝对值的数值 | 必需的；数值型。

示例：


取整

取整 命令 所属类别：算术运算

返回一个小数的整数部分。本命令与“绝对取整”命令不相同之处为： 如果给定小数为负数，则本命令返回小于或等于该小数的第一个负整数，而“绝对取整”命令则会返回大于或等于该小数的第一个负整数。例如，本命令将 -7.8 转换成 -8，而“绝对取整”命令将 -7.8 转换成 -7。

语法： 整数型 取整 （欲取整的小数）

参数名 | 描 述
欲取整的小数 | 必需的；双精度小数型。

示例：


绝对取整

绝对取整 命令 所属类别：算术运算

返回一个小数的整数部分。本命令与“取整”命令不相同之处为： 如果给定小数为负数，则本命令返回大于或等于该小数的第一个负整数，而“取整”命令则会返回小于或等于该小数的第一个负整数。例如，本命令将 -7.8 转换成 -7，而“取整”命令将 -7.8 转换成 -8。

语法： 整数型 绝对取整 （欲取整的小数）

参数名 | 描 述
欲取整的小数 | 必需的；双精度小数型。

示例：


四舍五入

四舍五入 命令 所属类别：算术运算

返回按照指定的方式进行四舍五入运算的结果数值。

语法： 双精度小数型 四舍五入 （欲被四舍五入的数值，［被舍入的位置］）

参数名 | 描 述
欲被四舍五入的数值 | 必需的；双精度小数型。
被舍入的位置 | 可选的；整数型。如果大于0，表示小数点右边应保留的位数；如果等于0，表示舍入到整数；如果小于0，表示小数点左边舍入到的位置。例如：四舍五入 (1056.65, 1) 返回 1056.7； 四舍五入 (1056.65, 0) 返回 1057； 四舍五入 (1056.65, -1) 返回 1060。如果省略本参数，则默认为0。

示例：


求次方

求次方 命令 所属类别：算术运算

返回指定数值的指定次方。

语法： 双精度小数型 求次方 （欲求次方数值，次方数）

参数名 | 描 述
欲求次方数值 | 必需的；双精度小数型。参数值指定欲求其某次方的数值。
次方数 | 必需的；双精度小数型。参数值指定对欲求次方数值的运算指数。

示例：


求平方根

求平方根 命令 所属类别：算术运算

返回指定参数的平方根。

语法： 双精度小数型 求平方根 （欲求其平方根的数值）

参数名 | 描 述
欲求其平方根的数值 | 必需的；双精度小数型。参数值如果小于零将导致计算错误。

示例：


求正弦

求正弦 命令 所属类别：算术运算

返回指定角的正弦值。

语法： 双精度小数型 求正弦 （欲进行计算的角）

参数名 | 描 述
欲进行计算的角 | 必需的；双精度小数型。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 #pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / #pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。

示例：


求余弦

求余弦 命令 所属类别：算术运算

返回指定角的余弦值。

语法： 双精度小数型 求余弦 （欲进行计算的角）

参数名 | 描 述
欲进行计算的角 | 必需的；双精度小数型。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 #pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / #pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。

示例：


求正切

求正切 命令 所属类别：算术运算

返回指定角的正切值。

语法： 双精度小数型 求正切 （欲进行计算的角）

参数名 | 描 述
欲进行计算的角 | 必需的；双精度小数型。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 #pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / #pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。

示例：


求反正切

求反正切 命令 所属类别：算术运算

返回指定数的反正切值。

语法： 双精度小数型 求反正切 （欲求其反正切值的数值）

参数名 | 描 述
欲求其反正切值的数值 | 必需的；双精度小数型。

示例：


求自然对数

求自然对数 命令 所属类别：算术运算

返回指定参数的自然对数值。自然对数是以 e 为底的对数。常量 #e 的值大约是 2.718282。

语法： 双精度小数型 求自然对数 （欲求其自然对数的数值）

参数名 | 描 述
欲求其自然对数的数值 | 必需的；双精度小数型。

示例：


求反对数

求反对数 命令 所属类别：算术运算

返回 e（自然对数的底）的某次方。

语法： 双精度小数型 求反对数 （欲求其反对数的数值）

参数名 | 描 述
欲求其反对数的数值 | 必需的；双精度小数型。如果参数值超过 709.782712893，将导致计算溢出。

示例：


是否运算正确

是否运算正确 命令 所属类别：算术运算

对“求次方”、“求平方根”、“求正弦值”、“求余弦值”、“求正切值”、“求反正切值”、“求自然对数”、“求反对数”等等数学运算命令所计算出来的双精度结果数值进行校验，如果该数值正确有效，返回真。如果该数值是运算错误或运算溢出后的结果，返回假。

语法： 逻辑型 是否运算正确 （欲校验的计算结果）

参数名 | 描 述
欲校验的计算结果 | 必需的；数值型。

示例：


置随机数种子

置随机数种子 命令 所属类别：算术运算

为随机数生成器初始化一个种子值，不同的种子值将导致“取随机数”命令返回不同的随机数系列。

语法： 无返回值 置随机数种子 （［欲置入的种子数值］）

参数名 | 描 述
欲置入的种子数值 | 可选的；整数型。如果省略本参数，将默认使用当前计算机系统的时钟值。

示例：


取随机数

取随机数 命令 所属类别：算术运算

返回一个指定范围内的随机数值。在使用本命令取一系列的随机数之前，应该先使用“置随机数种子”命令为随机数生成器初始化一个种子值。

语法： 整数型 取随机数 （［欲取随机数的最小值］，［欲取随机数的最大值］）

参数名 | 描 述
欲取随机数的最小值 | 可选的；整数型。参数必须大于或等于零。本参数如果被省略，默认为 0 。
欲取随机数的最大值 | 可选的；整数型。参数必须大于或等于零。本参数如果被省略，默认为无限。

示例：


逻辑比较

逻辑比较 类别 跳至：系统核心支持库


等于

等于 命令 所属类别：逻辑比较

被比较值与比较值相同时返回真，否则返回假，运算符号为“=”或“==”。

语法： 逻辑型 等于 （被比较值，比较值）

参数名 | 描 述
被比较值 | 必需的；通用型。被比较值的数据类型可以为所有数据类型。
比较值 | 必需的；通用型。比较值的数据类型可以为所有数据类型，但必须与“被比较值”一致或者可以相互转换。

示例：


不等于

不等于 命令 所属类别：逻辑比较

被比较值与比较值不相同时返回真，否则返回假，运算符号为“<>”或“!=”或“≠”。

语法： 逻辑型 不等于 （被比较值，比较值）

参数名 | 描 述
被比较值 | 必需的；通用型。被比较值的数据类型可以为所有数据类型。
比较值 | 必需的；通用型。比较值的数据类型可以为所有数据类型，但必须与“被比较值”一致或者可以相互转换。

示例：


小于

小于 命令 所属类别：逻辑比较

被比较值小于比较值时返回真，否则返回假，运算符号为“<”。

语法： 逻辑型 小于 （被比较值，比较值）

参数名 | 描 述
被比较值 | 必需的；通用型。被比较值的数据类型可以为数值型、日期时间型、文本型。
比较值 | 必需的；通用型。比较值的数据类型可以为数值型、日期时间型、文本型，且必须与“被比较值”一致或者可以相互转换。

示例：


大于

大于 命令 所属类别：逻辑比较

被比较值大于比较值时返回真，否则返回假，运算符号为“>”。

语法： 逻辑型 大于 （被比较值，比较值）

参数名 | 描 述
被比较值 | 必需的；通用型。被比较值的数据类型可以为数值型、日期时间型、文本型。
比较值 | 必需的；通用型。比较值的数据类型可以为数值型、日期时间型、文本型，且必须与“被比较值”一致或者可以相互转换。

示例：


小于或等于

小于或等于 命令 所属类别：逻辑比较

被比较值小于或等于比较值时返回真，否则返回假，运算符号为“<=”或“≤”。

语法： 逻辑型 小于或等于 （被比较值，比较值）

参数名 | 描 述
被比较值 | 必需的；通用型。被比较值的数据类型可以为数值型、日期时间型、文本型。
比较值 | 必需的；通用型。比较值的数据类型可以为数值型、日期时间型、文本型，且必须与“被比较值”一致或者可以相互转换。

示例：


大于或等于

大于或等于 命令 所属类别：逻辑比较

被比较值大于或等于比较值时返回真，否则返回假，运算符号为“>=”或“≥”。

语法： 逻辑型 大于或等于 （被比较值，比较值）

参数名 | 描 述
被比较值 | 必需的；通用型。被比较值的数据类型可以为数值型、日期时间型、文本型。
比较值 | 必需的；通用型。比较值的数据类型可以为数值型、日期时间型、文本型，且必须与“被比较值”一致或者可以相互转换。

示例：


近似等于

近似等于 命令 所属类别：逻辑比较

当比较文本在被比较文本的首部被包容时返回真，否则返回假，运算符号为“?=”或“≈”。

语法： 逻辑型 近似等于 （被比较文本，比较文本）

参数名 | 描 述
被比较文本 | 必需的；文本型。
比较文本 | 必需的；文本型。

示例：


并且

并且 命令 所属类别：逻辑比较

如果所提供的两个参数逻辑值都为真则返回真，否则返回假，运算符号为“&&”或“And”或“且”。

语法： 逻辑型 并且 （逻辑值一，逻辑值二，… ）

参数名 | 描 述
逻辑值一 | 必需的；逻辑型。
逻辑值二 | 必需的；可扩充的；逻辑型。

示例：


或者

或者 命令 所属类别：逻辑比较

如果所提供的两个参数逻辑值中任意有一个为真则返回真，否则返回假，运算符号为“||”或“Or”或“或”。

语法： 逻辑型 或者 （逻辑值一，逻辑值二，… ）

参数名 | 描 述
逻辑值一 | 必需的；逻辑型。
逻辑值二 | 必需的；可扩充的；逻辑型。

示例：


取反

取反 命令 所属类别：逻辑比较

如果参数值为真则返回假，如果参数值为假则返回真。

语法： 逻辑型 取反 （被反转的逻辑值）

参数名 | 描 述
被反转的逻辑值 | 必需的；逻辑型。

示例：


位运算

位运算 类别 跳至：系统核心支持库


位取反

位取反 命令 所属类别：位运算

将指定数值每一个比特位的值取反后返回。

语法： 数值型 位取反 （欲取反的数值）

参数名 | 描 述
欲取反的数值 | 必需的；数值型。

示例：


位与

位与 命令 所属类别：位运算

如两个数值有某共同比特位为1，则返回值的对应位也为1，否则为0。返回计算后的结果。

语法： 数值型 位与 （位运算数值一，位运算数值二，… ）

参数名 | 描 述
位运算数值一 | 必需的；数值型。
位运算数值二 | 必需的；可扩充的；数值型。

示例：


位或

位或 命令 所属类别：位运算

如两个数值中有一个数值的某一比特位不为零，则返回值的对应位就为1，否则为0。返回计算后的结果。

语法： 数值型 位或 （位运算数值一，位运算数值二，… ）

参数名 | 描 述
位运算数值一 | 必需的；数值型。
位运算数值二 | 必需的；可扩充的；数值型。

示例：


位异或

位异或 命令 所属类别：位运算

如两个数值对应比特位的值不相等，则返回值的对应位就为1，否则为0。返回计算后的结果。

语法： 数值型 位异或 （位运算数值一，位运算数值二，… ）

参数名 | 描 述
位运算数值一 | 必需的；数值型。
位运算数值二 | 必需的；可扩充的；数值型。

示例：


容器操作

容器操作 类别 跳至：系统核心支持库


赋值

赋值 命令 所属类别：容器操作

将指定的常数、常数集、常量、资源、对象或者容器赋于到指定的容器或容器数组中去。运算符号为“=”。

语法： 无返回值 赋值 （被赋值的容器或容器数组，用作赋于的值或资源）

参数名 | 描 述
被赋值的容器或容器数组 | 必需的；通用型，参数数据只能提供容器及容器数组。
用作赋于的值或资源 | 必需的；通用型，参数数据可以同时提供数组或非数组数据。

示例：


连续赋值

连续赋值 命令 所属类别：容器操作

将指定的常数、常数集、常量、资源、对象或者容器赋于到一系列容器或容器数组中去。

语法： 无返回值 连续赋值 （用作赋于的值或资源，被赋值的容器或容器数组，… ）

参数名 | 描 述
用作赋于的值或资源 | 必需的；通用型，参数数据可以同时提供数组或非数组数据。
被赋值的容器或容器数组 | 必需的；可扩充的；通用型，参数数据只能提供容器及容器数组。

示例：


参考

参考 命令 所属类别：容器操作

将指定容器的内容置为参考到其它容器的指针，以后对此容器进行的读写操作将被自动转移到其所参考到的容器。成功返回真，失败返回假。

语法： 逻辑型 参考 （欲参考到其它容器的容器，［参考到的容器或容器数组］）

参数名 | 描 述
欲参考到其它容器的容器 | 必需的；通用型，参数数据只能提供容器。参数值不能为自定义数据类型或者数组的成员，必须为单独定义的非数组容器。
参考到的容器或容器数组 | 可选的；通用型，参数数据只能提供容器及容器数组。参数值所指定容器的数据类型必须与第一个参数所指定容器的数据类型完全一致（数组类型可以不相同），否则命令会失败。如果省略本参数，将清除前参数所指定容器内的参考指针内容，并且重新初始化该容器。以后再对该容器进行读写操作将不会被转移到其它容器，而与普通容器一样在该容器内部进行。

示例：


数组操作

数组操作 类别 跳至：系统核心支持库

重定义数组 | 取数组成员数 | 取数组下标 | 复制数组
加入成员 | 插入成员 | 删除成员 | 清除数组
数组排序 |  |  |


重定义数组

重定义数组 命令 所属类别：数组操作

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

语法： 无返回值 重定义数组 （欲重定义的数组容器，是否保留以前的内容，数组对应维的上限值，… ）

参数名 | 描 述
欲重定义的数组容器 | 必需的；通用型，参数数据只能提供容器数组。
是否保留以前的内容 | 必需的；逻辑型，初始值为“假”。
数组对应维的上限值 | 必需的；可扩充的；整数型。

示例：


取数组成员数

取数组成员数 命令 所属类别：数组操作

取指定数组容器的全部成员数目，如果该容器不为数组，返回-1，因此本命令也可以用作检查指定容器是否为数组容器。

语法： 整数型 取数组成员数 （欲检查的容器）

参数名 | 描 述
欲检查的容器 | 必需的；通用型，参数数据只能提供容器及容器数组。参数值指定欲检查其成员数目的数组容器或者欲检查其是否为数组的容器。

示例：


取数组下标

取数组下标 命令 所属类别：数组操作

返回指定数组维可用的最大下标（最小下标固定为1）。如果给定容器不为数组容器或指定维不存在，返回 0。

语法： 整数型 取数组下标 （欲取某维最大下标的数组容器，［欲取其最大下标的维］）

参数名 | 描 述
欲取某维最大下标的数组容器 | 必需的；通用型，参数数据只能提供容器及容器数组。
欲取其最大下标的维 | 可选的；整数型。1 表示第一维，2 表示第二维，如此类推。如果省略本参数，默认值是 1。

示例：


复制数组

复制数组 命令 所属类别：数组操作

将数组数据复制到指定的数组容器，并根据该数据的大小通过重新定义数组维数自动增加或减少该数组容器的成员数目，使之与所提供数组数据的成员数目完全一致。数组容器如为多维数组，复制完毕后将被转换为单维数组。

语法： 无返回值 复制数组 （复制到的数组容器，待复制的数组数据）

参数名 | 描 述
复制到的数组容器 | 必需的；通用型，参数数据只能提供容器数组。参数值所指定的数组容器不能为库或用户自定义数据类型中的成员。
待复制的数组数据 | 必需的；通用型，参数数据只能提供数组数据。

示例：


加入成员

加入成员 命令 所属类别：数组操作

将数据加入到指定数组容器的尾部，并通过重新定义数组维数自动增加其成员数目。数组容器如为多维数组，加入完毕后将被转换为单维数组。

语法： 无返回值 加入成员 （欲加入成员的数组容器，欲加入的成员数据）

参数名 | 描 述
欲加入成员的数组容器 | 必需的；通用型，参数数据只能提供容器数组。参数值所指定的数组容器不能为库或用户自定义数据类型中的成员。
欲加入的成员数据 | 必需的；通用型，参数数据可以同时提供数组或非数组数据。参数值所指定成员数据的数据类型必须能够与第一个参数所指定的数组容器相匹配。

示例：


插入成员

插入成员 命令 所属类别：数组操作

将数据插入到指定数组容器的指定位置，并通过重新定义数组维数自动增加其成员数目。数组容器如为多维数组，插入完毕后将被转换为单维数组。

语法： 无返回值 插入成员 （欲插入成员的数组容器，欲插入的位置，欲插入的成员数据）

参数名 | 描 述
欲插入成员的数组容器 | 必需的；通用型，参数数据只能提供容器数组。参数值所指定的数组容器不能为库或用户自定义数据类型中的成员。
欲插入的位置 | 必需的；整数型。位置值从 1 开始，如果小于 1 或大于第一个参数所指定数组容器的成员数目 + 1，将会产生运行时错误。
欲插入的成员数据 | 必需的；通用型，参数数据可以同时提供数组或非数组数据。参数值所指定成员数据的数据类型必须能够与第一个参数所指定的数组容器相匹配。

示例：


删除成员

删除成员 命令 所属类别：数组操作

删除指定数组容器中的成员，并通过重新定义数组维数自动减少其成员数目。数组容器如为多维数组，删除完毕后将被转换为单维数组。返回所实际删除的成员数目。

语法： 整数型 删除成员 （欲删除成员的数组容器，欲删除的位置，［欲删除的成员数目］）

参数名 | 描 述
欲删除成员的数组容器 | 必需的；通用型，参数数据只能提供容器数组。参数值所指定的数组容器不能为库或用户自定义数据类型中的成员。
欲删除的位置 | 必需的；整数型。位置值从 1 开始，如果小于 1 或大于第一个参数所指定数组容器的成员数目，将会产生运行时错误。
欲删除的成员数目 | 可选的；整数型。本参数如果被省略，默认为 1 。

示例：


清除数组

清除数组 命令 所属类别：数组操作

删除指定数组容器中的所有成员，释放这些成员所占用的存储空间，重新定义该容器为单维 0 成员数组容器。

语法： 整数型 清除数组 （欲删除成员的数组容器）

参数名 | 描 述
欲删除成员的数组容器 | 必需的；通用型，参数数据只能提供容器数组。参数值所指定的数组容器不能为库或用户自定义数据类型中的成员。

示例：


数组排序

数组排序 命令 所属类别：数组操作

对指定数值数组容器内的所有数组成员进行快速排序，排序结果存放回该数组容器。

语法： 无返回值 数组排序 （欲排序的数值数组容器，［排序方向是否为从小到大］）

参数名 | 描 述
欲排序的数值数组容器 | 必需的；数值型，参数数据只能提供容器数组。
排序方向是否为从小到大 | 可选的；逻辑型。如果参数值为真，排序方向为从小到大，否则为从大到小。如果本参数被省略，默认值为真。

示例：


环境存取

环境存取 类别 跳至：系统核心支持库

取命令行 | 取运行目录 | 取执行文件名 | 读环境变量
写环境变量 |  |  |


取命令行

取命令行 命令 所属类别：环境存取

本命令可以取出在启动易程序时附加在其可执行文件名后面的所有以空格分隔的命令行文本段。

语法： 无返回值 取命令行 （存放被取回命令行文本的数组容器）

参数名 | 描 述
存放被取回命令行文本的数组容器 | 必需的；文本型，参数数据只能提供容器数组。在命令执行完毕后，本容器数组内被顺序填入在启动易程序时附加在其可执行文件名后面的以空格分隔的命令行文本段。容器数组内原有数据被全部销毁，容器数组的维数被自动调整为命令行文本段数。

示例：


取运行目录

取运行目录 命令 所属类别：环境存取

取当前被执行的易程序文件所处的目录。

语法： 文本型 取运行目录 （）

示例：


取执行文件名

取执行文件名 命令 所属类别：环境存取

取当前被执行的易程序文件的名称。

语法： 文本型 取执行文件名 （）

示例：


读环境变量

读环境变量 命令 所属类别：环境存取

返回文本，它关连于一个操作系统环境变量。成功时返回所取得的值，失败则返回空文本。

语法： 文本型 读环境变量 （环境变量名称）

参数名 | 描 述
环境变量名称 | 必需的；文本型。

示例：


写环境变量

写环境变量 命令 所属类别：环境存取

修改或建立指定的操作系统环境变量。成功返回真，失败返回假。

语法： 逻辑型 写环境变量 （环境变量名称，欲写入内容）

参数名 | 描 述
环境变量名称 | 必需的；文本型。
欲写入内容 | 必需的；文本型。

示例：


拼音处理

拼音处理 类别 跳至：系统核心支持库


取所有发音

取所有发音 命令 所属类别：拼音处理

返回包含指定汉字所有拼音编码的文本数组（支持多音字）。目前仅支持国标汉字。

语法： 文本型数组 取所有发音 （欲取其拼音的汉字）

参数名 | 描 述
欲取其拼音的汉字 | 必需的；文本型。只取用文本首部的第一个汉字，如果该文本首部不为国标汉字，命令将返回一个成员数目为 0 的空文本数组。

示例：


取发音数目

取发音数目 命令 所属类别：拼音处理

返回指定汉字的发音数目。

语法： 整数型 取发音数目 （欲取其发音数目的汉字）

参数名 | 描 述
欲取其发音数目的汉字 | 必需的；文本型。只取用文本首部的第一个汉字，如果该文本首部不为国标汉字，命令将返回 0。

示例：


取拼音

取拼音 命令 所属类别：拼音处理

返回包含指定汉字的指定拼音编码的文本。如果该指定拼音编码不存在，将返回空文本。目前仅支持国标汉字。多音字的第一个发音为常用音。

语法： 文本型 取拼音 （欲取其拼音编码的汉字，欲取拼音编码的索引）

参数名 | 描 述
欲取其拼音编码的汉字 | 必需的；文本型。只取用文本首部的第一个汉字，如果该文本首部不为国标汉字，命令将返回一个空文本。
欲取拼音编码的索引 | 必需的；整数型，初始值为“1”。应该在 1 到该汉字的发音数目之间。汉字的发音数目数目可以使用“取发音数目”命令取得。

示例：


取声母

取声母 命令 所属类别：拼音处理

返回包含指定汉字指定拼音编码的声母部分文本。如果指定拼音编码不存在或该汉字此发音无声母，将返回空文本。目前仅支持国标汉字。

语法： 文本型 取声母 （欲取其拼音编码的汉字，欲取拼音编码的索引）

参数名 | 描 述
欲取其拼音编码的汉字 | 必需的；文本型。只取用文本首部的第一个汉字，如果该文本首部不为国标汉字，命令将返回一个空文本。
欲取拼音编码的索引 | 必需的；整数型，初始值为“1”。应该在 1 到该汉字的发音数目之间。汉字的发音数目数目可以使用“取发音数目”命令取得。

示例：


取韵母

取韵母 命令 所属类别：拼音处理

返回包含指定汉字指定拼音编码的韵母部分文本。如果指定拼音编码不存在，将返回空文本。目前仅支持国标汉字。

语法： 文本型 取韵母 （欲取其拼音编码的汉字，欲取拼音编码的索引）

参数名 | 描 述
欲取其拼音编码的汉字 | 必需的；文本型。只取用文本首部的第一个汉字，如果该文本首部不为国标汉字，命令将返回一个空文本。
欲取拼音编码的索引 | 必需的；整数型，初始值为“1”。应该在 1 到该汉字的发音数目之间。汉字的发音数目数目可以使用“取发音数目”命令取得。

示例：


发音比较

发音比较 命令 所属类别：拼音处理

比较两个文本的发音，如果发音相同返回真，否则返回假。对于文本中的非国标汉字部分，将仅进行简单的值比较。

语法： 逻辑型 发音比较 （待比较文本一，待比较文本二，是否支持南方音，［是否为模糊比较］）

参数名 | 描 述
待比较文本一 | 必需的；文本型。
待比较文本二 | 必需的；文本型。
是否支持南方音 | 必需的；逻辑型，初始值为“真”。为真则支持南方音。如果支持南方音，比较时将认为所有相近的发音都相同。如： n 和 l、 z 和 zh、 ie 和 ue 等等。
是否为模糊比较 | 可选的；逻辑型。本参数为真时，当待比较文本一的发音在待比较文本二的首部被包容时即认为比较通过。如果被省略，默认值为假。

示例：


输入字比较

输入字比较 命令 所属类别：拼音处理

将一个拼音输入字文本与另外一个普通文本比较，如果两者相符，返回真，否则返回假。

语法： 逻辑型 输入字比较 （待比较拼音输入字，待比较普通文本，是否支持南方音，［拼音输入字类别］）

参数名 | 描 述
待比较拼音输入字 | 必需的；文本型。拼音输入字有以下三类： 一、首拼及全拼类： 如：“jsj”匹配“计算机”，同时“jisuanji”也匹配“计算机”。系统自动判别该输入字具体是首拼方式还是全拼方式； 二、双拼类： 如：“jisrji”匹配“计算机”，双拼编码的方案与 Windows 系统下的双拼输入法一致； 三、自动判别类： 使用此类别需在拼音输入字的首部加一个半角字符用作判别：分号 (“;”) 代表首拼及全拼类，冒号 (“:”) 代表双拼类，如既不为分号也不为冒号，则默认为首拼及全拼类。如“jsj”、“;jsj”、“;jisuanji”、“:jisrji”都匹配“计算机”。 另：书写拼音输入字时的一些规则： 一、为了匹配目标文本中的大小写英文字母，请在相应位置处使用对应的大写英文字母。如：“jsjA”匹配“计算机a”、“计算机A”； 二、为了匹配目标文本中的半角数字，请在相应位置处使用该数字。如：“jsj1”匹配“计算机1”； 三、为了匹配目标文本中的汉字符号或不知道发音的汉字，请在相应位置处使用该汉字。如：“j算j1”匹配“计算机1”； 四、拼音输入字内不能包含除了“_”以外的所有其他半角符号。
待比较普通文本 | 必需的；文本型。
是否支持南方音 | 必需的；逻辑型，初始值为“真”。为真则支持南方音。如果支持南方音，比较时将认为所有相近的发音都相同。如： n 和 l、 z 和 zh、 ie 和 ue 等等。
拼音输入字类别 | 可选的；整数型。参数值可以为以下常量之一： 1、#首拼及全拼； 2、#双拼； 3、#自动判别。 如果省略本参数，默认为“#自动判别”。

示例：


文本操作

文本操作 类别 跳至：系统核心支持库

取文本长度 | 取文本左边 | 取文本右边 | 取文本中间
字符 | 取代码 | 寻找文本 | 倒找文本
到大写 | 到小写 | 到全角 | 到半角
文本到时间 | 文本到数值 | 到文本 | 删首空
删尾空 | 删首尾空 | 删全部空 | 文本替换
子文本替换 | 取空白文本 | 取重复文本 | 文本比较
分割文本 |  |  |


取文本长度

取文本长度 命令 所属类别：文本操作

取文本型数据的长度，不包含结束0。

语法： 整数型 取文本长度 （文本数据）

参数名 | 描 述
文本数据 | 必需的；文本型。参数值指定欲检查其长度的文本数据。

示例：


取文本左边

取文本左边 命令 所属类别：文本操作

返回一个文本，其中包含指定文本中从左边算起指定数量的字符。

语法： 文本型 取文本左边 （欲取其部分的文本，欲取出字符的数目）

参数名 | 描 述
欲取其部分的文本 | 必需的；文本型。
欲取出字符的数目 | 必需的；整数型。

示例：


取文本右边

取文本右边 命令 所属类别：文本操作

返回一个文本，其中包含指定文本中从右边算起指定数量的字符。

语法： 文本型 取文本右边 （欲取其部分的文本，欲取出字符的数目）

参数名 | 描 述
欲取其部分的文本 | 必需的；文本型。
欲取出字符的数目 | 必需的；整数型。

示例：


取文本中间

取文本中间 命令 所属类别：文本操作

返回一个文本，其中包含指定文本中从指定位置算起指定数量的字符。

语法： 文本型 取文本中间 （欲取其部分的文本，起始取出位置，欲取出字符的数目）

参数名 | 描 述
欲取其部分的文本 | 必需的；文本型。
起始取出位置 | 必需的；整数型。1为首位置，2为第2个位置，如此类推。
欲取出字符的数目 | 必需的；整数型。

示例：


字符

字符 命令 所属类别：文本操作

返回一个文本，其中包含有与指定字符代码相关的字符。

语法： 文本型 字符 （欲取其字符的字符代码）

参数名 | 描 述
欲取其字符的字符代码 | 必需的；字节型。

示例：


取代码

取代码 命令 所属类别：文本操作

返回文本中指定位置处字符的代码。如果指定位置超出文本长度，返回0。

语法： 整数型 取代码 （欲取字符代码的文本，［欲取其代码的字符位置］）

参数名 | 描 述
欲取字符代码的文本 | 必需的；文本型。
欲取其代码的字符位置 | 可选的；整数型。1为首位置，2为第2个位置，如此类推。如果本参数被省略，默认为首位置。

示例：


寻找文本

寻找文本 命令 所属类别：文本操作

返回一个整数值，指定一文本在另一文本中最先出现的位置，位置值从 1 开始。如果未找到，返回-1。

语法： 整数型 寻找文本 （被搜寻的文本，欲寻找的文本，［起始搜寻位置］，是否区分大小写）

参数名 | 描 述
被搜寻的文本 | 必需的；文本型。
欲寻找的文本 | 必需的；文本型。
起始搜寻位置 | 可选的；整数型。位置值从 1 开始。如果本参数被省略，默认为 1 。
是否区分大小写 | 必需的；逻辑型，初始值为“真”。为真区分大小写，为假不区分。

示例：


倒找文本

倒找文本 命令 所属类别：文本操作

返回一个整数值，指定一文本在另一文本中最后出现的位置，位置值从 1 开始。如果未找到，返回-1。

语法： 整数型 倒找文本 （被搜寻的文本，欲寻找的文本，［起始搜寻位置］，是否区分大小写）

参数名 | 描 述
被搜寻的文本 | 必需的；文本型。
欲寻找的文本 | 必需的；文本型。
起始搜寻位置 | 可选的；整数型。位置值从 1 开始。如果本参数被省略，默认为从被搜寻文本的尾部开始。
是否区分大小写 | 必需的；逻辑型，初始值为“真”。为真区分大小写，为假不区分。

示例：


到大写

到大写 命令 所属类别：文本操作

将文本中的小写英文字母变换为大写，返回变换后的结果文本。

语法： 文本型 到大写 （欲变换的文本）

参数名 | 描 述
欲变换的文本 | 必需的；文本型。

示例：


到小写

到小写 命令 所属类别：文本操作

将文本中的大写英文字母变换为小写，返回变换后的结果文本。

语法： 文本型 到小写 （欲变换的文本）

参数名 | 描 述
欲变换的文本 | 必需的；文本型。

示例：


到全角

到全角 命令 所属类别：文本操作

将文本中的半角字母、空格或数字变换为全角，返回变换后的结果文本。

语法： 文本型 到全角 （欲变换的文本）

参数名 | 描 述
欲变换的文本 | 必需的；文本型。

示例：


到半角

到半角 命令 所属类别：文本操作

将文本中的全角字母、空格或数字变换为半角，返回变换后的结果文本。

语法： 文本型 到半角 （欲变换的文本）

参数名 | 描 述
欲变换的文本 | 必需的；文本型。

示例：


文本到时间

文本到时间 命令 所属类别：文本操作

将指定文本转换为时间并返回。如果给定文本不符合书写格式要求导致不能进行转换，将返回现行系统时间。

语法： 日期时间型 文本到时间 （欲转换的文本）

参数名 | 描 述
欲转换的文本 | 必需的；文本型。文本内容应按以下格式之一提供，年份后的时间部分可以省略： 1、1973年11月15日12时30分25秒 2、1973/11/15/12/30/25 3、1973/11/15/12:30:25 4、1973-11-15-12-30-25 5、1973-11-15-12:30:25

示例：


文本到数值

文本到数值 命令 所属类别：文本操作

返回包含于文本内的数值，文本中是一个适当类型的数值。支持全角书写方式。

语法： 数值型 文本到数值 （待转换的文本）

参数名 | 描 述
待转换的文本 | 必需的；文本型。文本内可以包含数值千分位分隔符：逗号。

示例：


到文本

到文本 命令 所属类别：文本操作

返回一个文本，代表指定数值、逻辑值或日期时间被转换后的结果。如果为文本数据，将被直接返回。

语法： 文本型 到文本 （待转换的数据）

参数名 | 描 述
待转换的数据 | 必需的；通用型。参数值只能为数值、逻辑值或日期时间。

示例：


删首空

删首空 命令 所属类别：文本操作

返回一个文本，其中包含被删除了首部全角或半角空格的指定文本。

语法： 文本型 删首空 （欲删除空格的文本）

参数名 | 描 述
欲删除空格的文本 | 必需的；文本型。

示例：


删尾空

删尾空 命令 所属类别：文本操作

返回一个文本，其中包含被删除了尾部全角或半角空格的指定文本。

语法： 文本型 删尾空 （欲删除空格的文本）

参数名 | 描 述
欲删除空格的文本 | 必需的；文本型。

示例：


删首尾空

删首尾空 命令 所属类别：文本操作

返回一个文本，其中包含被删除了首部及尾部全角或半角空格的指定文本。

语法： 文本型 删首尾空 （欲删除空格的文本）

参数名 | 描 述
欲删除空格的文本 | 必需的；文本型。

示例：


删全部空

删全部空 命令 所属类别：文本操作

返回一个文本，其中包含被删除了所有全角或半角空格的指定文本。

语法： 文本型 删全部空 （欲删除空格的文本）

参数名 | 描 述
欲删除空格的文本 | 必需的；文本型。

示例：


文本替换

文本替换 命令 所属类别：文本操作

将指定文本的某一部分用其它的文本替换。

语法： 文本型 文本替换 （欲被替换的文本，起始替换位置，替换长度，［用作替换的文本］）

参数名 | 描 述
欲被替换的文本 | 必需的；文本型。
起始替换位置 | 必需的；整数型。替换的起始位置，1为首位置，2为第2个位置，如此类推。
替换长度 | 必需的；整数型。
用作替换的文本 | 可选的；文本型。如果本参数被省略，则删除文本中的指定部分。

示例：


子文本替换

子文本替换 命令 所属类别：文本操作

返回一个文本，该文本中指定的子文本已被替换成另一子文本，并且替换发生的次数也是被指定的。

语法： 文本型 子文本替换 （欲被替换的文本，欲被替换的子文本，［用作替换的子文本］，［进行替换的起始位置］，［替换进行的次数］，是否区分大小写）

参数名 | 描 述
欲被替换的文本 | 必需的；文本型。
欲被替换的子文本 | 必需的；文本型。
用作替换的子文本 | 可选的；文本型。如果本参数被省略，默认为空文本。
进行替换的起始位置 | 可选的；整数型。参数值指定被替换子文本的起始搜索位置。如果省略，默认从 1 开始。
替换进行的次数 | 可选的；整数型。参数值指定对子文本进行替换的次数。如果省略，默认进行所有可能的替换。
是否区分大小写 | 必需的；逻辑型，初始值为“真”。为真区分大小写，为假不区分。

示例：


取空白文本

取空白文本 命令 所属类别：文本操作

返回具有指定数目半角空格的文本。

语法： 文本型 取空白文本 （重复次数）

参数名 | 描 述
重复次数 | 必需的；整数型。

示例：


取重复文本

取重复文本 命令 所属类别：文本操作

返回一个文本，其中包含指定次数的文本重复结果。

语法： 文本型 取重复文本 （重复次数，待重复文本）

参数名 | 描 述
重复次数 | 必需的；整数型。
待重复文本 | 必需的；文本型。该文本将用于建立返回的文本。如果为空，将返回一个空文本。

示例：


文本比较

文本比较 命令 所属类别：文本操作

如果返回值小于0，表示文本一小于文本二；如果等于0，表示文本一等于文本二；如果大于0，表示文本一大于文本二。如果比较时区分大小写，也可以使用比较运算符进行同样的操作。

语法： 整数型 文本比较 （待比较文本一，待比较文本二，是否区分大小写）

参数名 | 描 述
待比较文本一 | 必需的；文本型。
待比较文本二 | 必需的；文本型。
是否区分大小写 | 必需的；逻辑型，初始值为“真”。为真区分大小写，为假不区分。

示例：


分割文本

分割文本 命令 所属类别：文本操作

将指定文本进行分割，返回分割后的一维文本数组。

语法： 文本型数组 分割文本 （待分割文本，［用作分割的文本］，［要返回的子文本数目］）

参数名 | 描 述
待分割文本 | 必需的；文本型。如果参数值是一个长度为零的文本，则返回一个空数组，即没有任何成员的数组。
用作分割的文本 | 可选的；文本型。参数值用于标识子文本边界。如果被省略，则默认使用半角逗号字符作为分隔符。如果是一个长度为零的文本，则返回的数组仅包含一个成员，即完整的“待分割文本”。
要返回的子文本数目 | 可选的；整数型。如果被省略，则默认返回所有的子文本。

示例：


字节集操作

字节集操作 类别 跳至：系统核心支持库

取字节集长度 | 转换为字节集 | 从字节集转换 | 取字节集左边
取字节集右边 | 取字节集中间 | 寻找字节集 | 倒找字节集
字节集替换 | 子字节集替换 | 取空白字节集 | 取重复字节集
分割字节集 |  |  |


取字节集长度

取字节集长度 命令 所属类别：字节集操作

取字节集型数据的长度。

语法： 整数型 取字节集长度 （字节集数据）

参数名 | 描 述
字节集数据 | 必需的；字节集。参数值指定欲检查其长度的字节集数据。

示例：


转换为字节集

转换为字节集 命令 所属类别：字节集操作

将指定数据转换为字节集后返回转换结果。

语法： 字节集 转换为字节集 （欲转换为字节集的数据）

参数名 | 描 述
欲转换为字节集的数据 | 必需的；通用型。数据类型不能为库或用户自定义数据类型。

示例：


从字节集转换

从字节集转换 命令 所属类别：字节集操作

将字节集转换成指定数据类型的数据，返回转换后的结果。如果该字节集内的数据尺寸小于指定数据类型的尺寸，将产生运行时错误。

语法： 通用型 从字节集转换 （欲转换的字节集，欲转换为的数据类型）

参数名 | 描 述
欲转换的字节集 | 必需的；字节集。
欲转换为的数据类型 | 必需的；整数型。参数值可以为以下常量： 1、#字节型； 2、#短整数型； 3、#整数型； 4、#长整数型； 5、#小数型； 6、#双精度小数型； 7、#逻辑型； 8、#日期时间型； 9、#子程序指针型； 10、#文本型。转换后的数据将自动进行有效性校验及转换处理。

示例：


取字节集左边

取字节集左边 命令 所属类别：字节集操作

返回一个字节集，其中包含指定字节集中从左边算起指定数量的字节。

语法： 字节集 取字节集左边 （欲取其部分的字节集，欲取出字节的数目）

参数名 | 描 述
欲取其部分的字节集 | 必需的；字节集。
欲取出字节的数目 | 必需的；整数型。

示例：


取字节集右边

取字节集右边 命令 所属类别：字节集操作

返回一个字节集，其中包含指定字节集中从右边算起指定数量的字节。

语法： 字节集 取字节集右边 （欲取其部分的字节集，欲取出字节的数目）

参数名 | 描 述
欲取其部分的字节集 | 必需的；字节集。
欲取出字节的数目 | 必需的；整数型。

示例：


取字节集中间

取字节集中间 命令 所属类别：字节集操作

返回一个字节集，其中包含指定字节集中从指定位置算起指定数量的字节。

语法： 字节集 取字节集中间 （欲取其部分的字节集，起始取出位置，欲取出字节的数目）

参数名 | 描 述
欲取其部分的字节集 | 必需的；字节集。
起始取出位置 | 必需的；整数型。1为首位置，2为第2个位置，如此类推。
欲取出字节的数目 | 必需的；整数型。

示例：


寻找字节集

寻找字节集 命令 所属类别：字节集操作

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

语法： 整数型 寻找字节集 （被搜寻的字节集，欲寻找的字节集）

参数名 | 描 述
被搜寻的字节集 | 必需的；字节集。
欲寻找的字节集 | 必需的；字节集。

示例：


倒找字节集

倒找字节集 命令 所属类别：字节集操作

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

语法： 整数型 倒找字节集 （被搜寻的字节集，欲寻找的字节集）

参数名 | 描 述
被搜寻的字节集 | 必需的；字节集。
欲寻找的字节集 | 必需的；字节集。

示例：


字节集替换

字节集替换 命令 所属类别：字节集操作

将指定字节集的某一部分用其它的字节集替换。

语法： 无返回值 字节集替换 （欲替换其部分的字节集，起始替换位置，替换长度，［用作替换的字节集］）

参数名 | 描 述
欲替换其部分的字节集 | 必需的；字节集。
起始替换位置 | 必需的；整数型。替换的起始位置，1为首位置，2为第2个位置，如此类推。
替换长度 | 必需的；整数型。
用作替换的字节集 | 可选的；字节集。如果本参数被省略，则删除字节集中的指定部分。

示例：


子字节集替换

子字节集替换 命令 所属类别：字节集操作

返回一个字节集，该字节集中指定的子字节集已被替换成另一子字节集，并且替换发生的次数也是被指定的。

语法： 字节集 子字节集替换 （欲被替换的字节集，欲被替换的子字节集，［用作替换的子字节集］，［进行替换的起始位置］，［替换进行的次数］）

参数名 | 描 述
欲被替换的字节集 | 必需的；字节集。
欲被替换的子字节集 | 必需的；字节集。
用作替换的子字节集 | 可选的；字节集。如果省略本参数，则默认为空字节集。
进行替换的起始位置 | 可选的；整数型。被替换子字节集的起始搜索位置。如果省略，默认从1开始。
替换进行的次数 | 可选的；整数型。对子字节集进行替换的次数。如果省略，默认进行所有可能的替换。

示例：


取空白字节集

取空白字节集 命令 所属类别：字节集操作

返回具有特定数目 0 字节的字节集。

语法： 字节集 取空白字节集 （零字节数目）

参数名 | 描 述
零字节数目 | 必需的；整数型。

示例：


取重复字节集

取重复字节集 命令 所属类别：字节集操作

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

语法： 字节集 取重复字节集 （重复次数，待重复的字节集）

参数名 | 描 述
重复次数 | 必需的；整数型。
待重复的字节集 | 必需的；字节集。该字节集将用于建立返回的字节集。如果为空，将返回一个空字节集。

示例：


分割字节集

分割字节集 命令 所属类别：字节集操作

将指定字节集进行分割，返回分割后的一维字节集数组。

语法： 字节集数组 分割字节集 （待分割字节集，［用作分割的字节］，［要返回的子字节集数目］）

参数名 | 描 述
待分割字节集 | 必需的；字节集。如果参数值是一个长度为零的字节集，则返回一个空数组，即没有任何成员的数组。
用作分割的字节 | 可选的；字节型。用于标识子字节集边界。本参数如果被省略，则默认使用字节 0 作为分隔符。
要返回的子字节集数目 | 可选的；整数型。如果被省略，则默认返回所有的子字节集。

示例：


数值转换

数值转换 类别 跳至：系统核心支持库

数值到大写 | 数值到人民币 | 数值到格式文本 | 取十六进制文本
取八进制文本 |  |  |


数值到大写

数值到大写 命令 所属类别：数值转换

将数值转换为简体或繁体的大写形式，返回转换后的文本。

语法： 文本型 数值到大写 （欲转换形式的数值，是否转换为简体）

参数名 | 描 述
欲转换形式的数值 | 必需的；双精度小数型。
是否转换为简体 | 必需的；逻辑型，初始值为“假”。如果参数值为假，则转换为繁体。

示例：


数值到人民币

数值到人民币 命令 所属类别：数值转换

将数值转换为人民币金额的简体或繁体大写形式，返回转换后的文本。

语法： 文本型 数值到人民币 （欲转换形式的数值，是否转换为简体）

参数名 | 描 述
欲转换形式的数值 | 必需的；双精度小数型。
是否转换为简体 | 必需的；逻辑型，初始值为“假”。如果参数值为假，则转换为繁体。

示例：


数值到格式文本

数值到格式文本 命令 所属类别：数值转换

返回一个文本，代表指定数值被格式转换后的结果。

语法： 文本型 数值到格式文本 （欲转换为文本的数值，［小数保留位数］，是否进行千分位分隔）

参数名 | 描 述
欲转换为文本的数值 | 必需的；双精度小数型。
小数保留位数 | 可选的；整数型。如果大于0，表示小数点右边应四舍五入保留的位数；如果等于0，表示舍入到整数；如果小于0，表示小数点左边舍入到的位置。例如：数值到格式文本 (1056.65, 1, 假) 返回 “1056.7”； 数值到格式文本 (1056.65, 0, 假) 返回 “1056”； 数值到格式文本 (1056.65, -1, 假) 返回 “1060”。如果省略本参数，则默认为保留所有实际存在的小数位。
是否进行千分位分隔 | 必需的；逻辑型，初始值为“假”。如果参数值为真，数值文本的每个千分位上都将被自动插入一个逗号进行分隔。

示例：


取十六进制文本

取十六进制文本 命令 所属类别：数值转换

返回一个文本，代表指定数值的十六进制形式。

语法： 文本型 取十六进制文本 （欲取进制文本的数值）

参数名 | 描 述
欲取进制文本的数值 | 必需的；整数型。

示例：


取八进制文本

取八进制文本 命令 所属类别：数值转换

返回一个文本，代表指定数值的八进制形式。

语法： 文本型 取八进制文本 （欲取进制文本的数值）

参数名 | 描 述
欲取进制文本的数值 | 必需的；整数型。

示例：


时间操作

时间操作 类别 跳至：系统核心支持库

增减时间 | 取时间间隔 | 取某月天数 | 时间到文本
取时间部分 | 取年份 | 取月份 | 取日期
取星期几 | 取小时 | 取分钟 | 取秒
指定时间 | 取现行时间 | 置现行时间 |


增减时间

增减时间 命令 所属类别：时间操作

返回一个时间，这一时间被加上或减去了一段间隔。如果改变后的时间无效，将自动靠近最近的有效时间。

语法： 日期时间型 增减时间 （时间，被增加部分，增加值）

参数名 | 描 述
时间 | 必需的；日期时间型。
被增加部分 | 必需的；整数型。参数值指定增加或减少时间的哪一部分，可以为以下常量： 1、#年份； 2、#季度； 3、#月份； 4、#周； 5、#日； 6、#小时； 7、#分钟； 8、#秒。
增加值 | 必需的；整数型。相对于被增加部分的增加或减少数值。

示例：


取时间间隔

取时间间隔 命令 所属类别：时间操作

返回一个数值，表示“时间1”减去“时间2”之后的间隔数目。注意：每个星期以星期天为第一天。

语法： 双精度小数型 取时间间隔 （时间1，时间2，取间隔部分）

参数名 | 描 述
时间1 | 必需的；日期时间型。
时间2 | 必需的；日期时间型。
取间隔部分 | 必需的；整数型。参数值指定取时间间隔的哪一部分，可以为以下常量： 1、#年份； 2、#季度； 3、#月份； 4、#周； 5、#日； 6、#小时； 7、#分钟； 8、#秒。

示例：


取某月天数

取某月天数 命令 所属类别：时间操作

返回指定月份所包含的天数。如果给定的月份无效，返回0。

语法： 整数型 取某月天数 （年份，月份）

参数名 | 描 述
年份 | 必需的；整数型。参数值从 100 到 9999。
月份 | 必需的；整数型。参数值从 1 到 12。

示例：


时间到文本

时间到文本 命令 所属类别：时间操作

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

语法： 文本型 时间到文本 （欲转换到文本的时间，［转换部分］）

参数名 | 描 述
欲转换到文本的时间 | 必需的；日期时间型。
转换部分 | 可选的；整数型。参数值可以为以下常量： 1、#全部转换； 2、#日期部分； 3、#时间部分。如果省略了本参数，默认为“#全部转换”。

示例：


取时间部分

取时间部分 命令 所属类别：时间操作

返回一个包含已知时间指定部分的整数。

语法： 整数型 取时间部分 （欲取其部分的时间，欲取的时间部分）

参数名 | 描 述
欲取其部分的时间 | 必需的；日期时间型。
欲取的时间部分 | 必需的；整数型。参数值可以为以下常量： 1、#年份； 2、#季度； 3、#月份； 4、#自年首周数； 5、#日； 6、#小时； 7、#分钟； 8、#秒； 9、#星期几； 10、#自年首天数。其中：自年首周数、自年首天数均从 1 开始。

示例：


取年份

取年份 命令 所属类别：时间操作

返回一个值为 100 到 9999 之间的整数，表示指定时间中的年份。

语法： 整数型 取年份 （时间）

参数名 | 描 述
时间 | 必需的；日期时间型。

示例：


取月份

取月份 命令 所属类别：时间操作

返回一个值为 1 到 12 之间的整数，表示指定时间中的月份。

语法： 整数型 取月份 （时间）

参数名 | 描 述
时间 | 必需的；日期时间型。

示例：


取日期

取日期 命令 所属类别：时间操作

返回一个值为 1 到 31 之间的整数，表示一个月中的某一日。

语法： 整数型 取日期 （时间）

参数名 | 描 述
时间 | 必需的；日期时间型。

示例：


取星期几

取星期几 命令 所属类别：时间操作

返回一个值为 1 到 7 之间的整数，表示一个星期中的某一日。星期日为 1，星期一为 2，依此类推。

语法： 整数型 取星期几 （时间）

参数名 | 描 述
时间 | 必需的；日期时间型。

示例：


取小时

取小时 命令 所属类别：时间操作

返回一个值为 0 到 23 之间的整数，表示一天中的某一小时。

语法： 整数型 取小时 （时间）

参数名 | 描 述
时间 | 必需的；日期时间型。

示例：


取分钟

取分钟 命令 所属类别：时间操作

返回一个值为 0 到 59 之间的整数，表示一小时中的某一分钟。

语法： 整数型 取分钟 （时间）

参数名 | 描 述
时间 | 必需的；日期时间型。

示例：


取秒

取秒 命令 所属类别：时间操作

返回一个值为 0 到 59 之间的整数，表示一分钟中的某一秒。

语法： 整数型 取秒 （时间）

参数名 | 描 述
时间 | 必需的；日期时间型。

示例：


指定时间

指定时间 命令 所属类别：时间操作

返回包含指定年、月、日、小时、分、秒的时间。如果指定了无效时间，将自动使用最相近的有效时间代替。

语法： 日期时间型 指定时间 （年，［月］，［日］，［小时］，［分钟］，［秒］）

参数名 | 描 述
年 | 必需的；整数型。
月 | 可选的；整数型。如果本参数被省略，默认为 1 月。
日 | 可选的；整数型。如果本参数被省略，默认为 1 日。
小时 | 可选的；整数型。如果本参数被省略，默认为 0 时。
分钟 | 可选的；整数型。如果本参数被省略，默认为 0 分钟。
秒 | 可选的；整数型。如果本参数被省略，默认为 0 秒。

示例：


取现行时间

取现行时间 命令 所属类别：时间操作

返回当前系统日期及时间。

语法： 日期时间型 取现行时间 （）

示例：


置现行时间

置现行时间 命令 所属类别：时间操作

设置当前系统日期及时间。成功返回真，失败返回假。

语法： 逻辑型 置现行时间 （欲设置的时间）

参数名 | 描 述
欲设置的时间 | 必需的；日期时间型。

示例：


磁盘操作

磁盘操作 类别 跳至：系统核心支持库

取磁盘总空间 | 取磁盘剩余空间 | 取磁盘卷标 | 置磁盘卷标
改变驱动器 | 改变目录 | 取当前目录 | 创建目录
删除目录 | 复制文件 | 移动文件 | 删除文件
文件更名 | 文件是否存在 | 寻找文件 | 取文件时间
取文件尺寸 | 取文件属性 | 置文件属性 | 取临时文件名
读入文件 | 写到文件 |  |


取磁盘总空间

取磁盘总空间 命令 所属类别：磁盘操作

返回以 1024 字节（KB）为单位的指定磁盘全部空间。如果失败，返回-1。

语法： 整数型 取磁盘总空间 （［磁盘驱动器字符］）

参数名 | 描 述
磁盘驱动器字符 | 可选的；文本型。类似“A”、“B”、“C”等，只取用给定文本的第一个字符。如果本参数被省略，默认使用当前驱动器。

示例：


取磁盘剩余空间

取磁盘剩余空间 命令 所属类别：磁盘操作

返回以 1024 字节（KB）为单位的指定磁盘现行剩余空间。如果失败，返回-1。

语法： 整数型 取磁盘剩余空间 （［磁盘驱动器字符］）

参数名 | 描 述
磁盘驱动器字符 | 可选的；文本型。类似“A”、“B”、“C”等，只取用给定文本的第一个字符。如果本参数被省略，默认使用当前驱动器。

示例：


取磁盘卷标

取磁盘卷标 命令 所属类别：磁盘操作

返回指定磁盘的卷标文本。

语法： 文本型 取磁盘卷标 （［磁盘驱动器字符］）

参数名 | 描 述
磁盘驱动器字符 | 可选的；文本型。类似“A”、“B”、“C”等，只取用给定文本的第一个字符。如果本参数被省略，默认使用当前驱动器。

示例：


置磁盘卷标

置磁盘卷标 命令 所属类别：磁盘操作

设置指定磁盘的卷标文本。成功返回真，失败返回假。

语法： 逻辑型 置磁盘卷标 （［磁盘驱动器字符］，欲置入的卷标文本）

参数名 | 描 述
磁盘驱动器字符 | 可选的；文本型。类似“A”、“B”、“C”等，只取用给定文本的第一个字符。如果本参数被省略，默认使用当前驱动器。
欲置入的卷标文本 | 必需的；文本型。

示例：


改变驱动器

改变驱动器 命令 所属类别：磁盘操作

改变当前的缺省驱动器。成功返回真，失败返回假。

语法： 逻辑型 改变驱动器 （欲改变到的驱动器）

参数名 | 描 述
欲改变到的驱动器 | 必需的；文本型。参数值指明一个存在的驱动器。类似“A”、“B”、“C”等，只取用给定文本的第一个字符。如果使用零长度的文本，则当前的驱动器不会改变。

示例：


改变目录

改变目录 命令 所属类别：磁盘操作

改变当前的目录，但不会改变缺省驱动器位置。成功返回真，失败返回假。

语法： 逻辑型 改变目录 （欲改变到的目录）

参数名 | 描 述
欲改变到的目录 | 必需的；文本型。参数值指明哪个目录将成为新的缺省目录，可能会包含驱动器。如果没有指定驱动器，则在当前的驱动器上改变缺省目录。

示例：


取当前目录

取当前目录 命令 所属类别：磁盘操作

返回一个文本，用来代表当前的目录。如果失败，返回空文本。

语法： 文本型 取当前目录 （）

示例：


创建目录

创建目录 命令 所属类别：磁盘操作

创建一个新的目录。成功返回真，失败返回假。

语法： 逻辑型 创建目录 （欲创建的目录名称）

参数名 | 描 述
欲创建的目录名称 | 必需的；文本型。

示例：


删除目录

删除目录 命令 所属类别：磁盘操作

删除一个存在的目录。成功返回真，失败返回假。

语法： 逻辑型 删除目录 （欲删除的目录名称）

参数名 | 描 述
欲删除的目录名称 | 必需的；文本型。该目录应实际存在并且目录中已没有任何文件或子目录。

示例：


复制文件

复制文件 命令 所属类别：磁盘操作

成功返回真，失败返回假。

语法： 逻辑型 复制文件 （被复制的文件名，复制到的文件名）

参数名 | 描 述
被复制的文件名 | 必需的；文本型。
复制到的文件名 | 必需的；文本型。

示例：


移动文件

移动文件 命令 所属类别：磁盘操作

将文件从一个位置移动到另外一个位置。成功返回真，失败返回假。

语法： 逻辑型 移动文件 （被移动的文件，移动到的位置）

参数名 | 描 述
被移动的文件 | 必需的；文本型。
移动到的位置 | 必需的；文本型。

示例：


删除文件

删除文件 命令 所属类别：磁盘操作

成功返回真，失败返回假。

语法： 逻辑型 删除文件 （欲删除的文件名）

参数名 | 描 述
欲删除的文件名 | 必需的；文本型。

示例：


文件更名

文件更名 命令 所属类别：磁盘操作

重新命名一个文件或目录。成功返回真，失败返回假。

语法： 逻辑型 文件更名 （欲更名的原文件或目录名，欲更改为的现文件或目录名）

参数名 | 描 述
欲更名的原文件或目录名 | 必需的；文本型。
欲更改为的现文件或目录名 | 必需的；文本型。

示例：


文件是否存在

文件是否存在 命令 所属类别：磁盘操作

判断指定的磁盘文件是否真实存在。如存在返回真，否则返回假。

语法： 逻辑型 文件是否存在 （欲测试的文件名称）

参数名 | 描 述
欲测试的文件名称 | 必需的；文本型。

示例：


寻找文件

寻找文件 命令 所属类别：磁盘操作

返回一个文本，用以表示所找到的文件名或目录名，它必须与所要求的名称格式或文件属性相匹配。支持使用多字符 (*) 和单字符 (?) 通配符来指定多重文件。在某子程序中第一次调用本命令时，必须指定“欲寻找文件”参数，否则将返回空文本 (“”)。在第一次调用以后如果想得到其它匹配的文件名，再一次调用本命令，且不要提供欲寻找文件名参数。如果已没有合乎条件的文件，本命令会返回一个空文本。一旦返回值为空文本，要再次调用本命令时，就必须指定“欲寻找文件”参数。不必访问完所有当前匹配的文件名，就可以使用一个新的“欲寻找文件”进行新的寻找。

语法： 文本型 寻找文件 （［欲寻找的文件或目录名称］，［欲寻找的文件属性］）

参数名 | 描 述
欲寻找的文件或目录名称 | 可选的；文本型。可以使用多字符 (*) 和单字符 (?) 通配符来指定多重文件。在非首次寻找文件时，参数值必须为空或被省略。
欲寻找的文件属性 | 可选的；整数型。参数值可以为以下常量值或其和： 1、#只读文件； 2、#隐藏文件； 4、#系统文件； 16、#子目录； 32、#存档文件 。通过将这些常量值加起来可以一次设置多个文件属性。如果省略本参数，默认为搜寻除子目录外的所有文件。

示例：


取文件时间

取文件时间 命令 所属类别：磁盘操作

返回指定文件被创建或最后修改后的日期和时间。如果该文件不存在，将返回现行系统时间。

语法： 日期时间型 取文件时间 （文件名）

参数名 | 描 述
文件名 | 必需的；文本型。

示例：


取文件尺寸

取文件尺寸 命令 所属类别：磁盘操作

返回一个文件的长度，单位是字节。如果该文件不存在，将返回 -1。

语法： 整数型 取文件尺寸 （文件名）

参数名 | 描 述
文件名 | 必需的；文本型。

示例：


取文件属性

取文件属性 命令 所属类别：磁盘操作

返回一个文件或目录的属性。此属性值由以下常量或其和构成： 1、#只读文件； 2、#隐藏文件； 4、#系统文件； 16、#子目录；32、#存档文件 。要判断是否设置了某个属性，在返回值与想要得知的属性值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示设置了这个属性值。如果取文件属性失败，将返回 -1。

语法： 整数型 取文件属性 （文件名）

参数名 | 描 述
文件名 | 必需的；文本型。

示例：


置文件属性

置文件属性 命令 所属类别：磁盘操作

为一个文件设置属性信息。成功返回真，失败返回假。

语法： 逻辑型 置文件属性 （欲设置其属性的文件名称，欲设置为的属性值）

参数名 | 描 述
欲设置其属性的文件名称 | 必需的；文本型。
欲设置为的属性值 | 必需的；整数型。参数值可以为以下常量值或其和： 1、#只读文件； 2、#隐藏文件； 4、#系统文件； 32、#存档文件 。通过将这些常量值加起来可以一次设置多个文件属性。

示例：


取临时文件名

取临时文件名 命令 所属类别：磁盘操作

返回一个在指定目录中确定不存在的 .TMP 全路径文件名称。

语法： 文本型 取临时文件名 （［目录名］）

参数名 | 描 述
目录名 | 可选的；文本型。如果省略本参数，默认将使用系统的标准临时目录。

示例：


读入文件

读入文件 命令 所属类别：磁盘操作

返回一个字节集，其中包含指定文件的所有数据。

语法： 字节集 读入文件 （文件名）

参数名 | 描 述
文件名 | 必需的；文本型。

示例：


写到文件

写到文件 命令 所属类别：磁盘操作

本命令用作将一个或数个字节集顺序写到指定文件中，文件原有内容被覆盖。成功返回真，失败返回假。

语法： 逻辑型 写到文件 （文件名，欲写入文件的数据，… ）

参数名 | 描 述
文件名 | 必需的；文本型。
欲写入文件的数据 | 必需的；可扩充的；字节集。

示例：


文件读写

文件读写 类别 跳至：系统核心支持库

打开文件 | 打开内存文件 | 关闭文件 | 关闭所有文件
锁住文件 | 解锁文件 | 移动读写位置 | 移到文件首
移到文件尾 | 读入字节集 | 写出字节集 | 读入文本
写出文本 | 读入一行 | 写文本行 | 读入数据
写出数据 | 是否在文件尾 | 取读写位置 | 取文件长度
插入字节集 | 插入文本 | 插入文本行 | 删除数据


打开文件

打开文件 命令 所属类别：文件读写

打开一个普通文件，以对文件进行输入或输出。成功返回被打开文件的文件号，失败返回 0。

语法： 整数型 打开文件 （欲打开的文件名称，［打开方式］，［共享方式］）

参数名 | 描 述
欲打开的文件名称 | 必需的；文本型。
打开方式 | 可选的；整数型。参数值说明对文件的操作方式，如果省略本参数，默认为“#读写”。方式值可以为以下常量之一： 1、#读入：从指定文件读入数据，如果该文件不存在则失败； 2、#写出：写出数据到指定文件，如果该文件不存在则失败； 3、#读写：从文件中读入数据或者写出数据到文件，如果该文件不存在则失败； 4、#重写：写出数据到指定文件。如果该文件不存在则先创建一个新文件，如果已经存在就先清除其中的所有数据； 5、#改写：写出数据到指定文件。如果该文件不存在则创建一个新文件，如果已经存在就直接打开； 6、#改读：从文件中读入数据或者写出数据到文件。如果该文件不存在则创建一个新文件，如果已经存在就直接打开。
共享方式 | 可选的；整数型。参数值指定限制其它进程操作此文件的方式。如果省略本参数，默认为“#无限制”。方式值可以为以下常量之一： 1、#无限制：允许其它进程任意读写此文件； 2、#禁止读：禁止其它进程读此文件； 3、#禁止写：禁止其它进程写此文件； 4、#禁止读写：禁止其它进程读写此文件。

示例：


打开内存文件

打开内存文件 命令 所属类别：文件读写

建立一个内存文件，以计算机内存为存储介质对数据进行文件式的快速输入或输出。成功返回被打开文件的文件号，失败返回 0。

语法： 整数型 打开内存文件 （）

示例：


关闭文件

关闭文件 命令 所属类别：文件读写

关闭被打开的各种类型文件。

语法： 无返回值 关闭文件 （欲关闭的文件号）

参数名 | 描 述
欲关闭的文件号 | 必需的；整数型。参数值指明欲关闭的文件号，该文件号由“打开文件”命令所返回。

示例：


关闭所有文件

关闭所有文件 命令 所属类别：文件读写

关闭所有现行被打开的文件。

语法： 无返回值 关闭所有文件 （）

示例：


锁住文件

锁住文件 命令 所属类别：文件读写

在有若干个进程访问同一个文件的环境中，使用本命令拒绝其它用户对被打开文件中的某个区域进行读写访问。成功返回真，失败返回假。

语法： 逻辑型 锁住文件 （欲加锁或解锁的文件号，欲加锁或解锁的位置，欲加锁或解锁的长度，［加锁重试时间］）

参数名 | 描 述
欲加锁或解锁的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲加锁或解锁的位置 | 必需的；整数型。位置值从 0 开始。
欲加锁或解锁的长度 | 必需的；整数型。
加锁重试时间 | 可选的；整数型。本参数指定加锁失败后反复进行重试的毫秒数。如果被省略，默认为 0 ，即一旦失败立即返回。如果参数值提供为 -1 ，则反复进行重试，直到加锁成功为止。

示例：


解锁文件

解锁文件 命令 所属类别：文件读写

解除由“锁住文件”命令对文件所进行的锁定。成功返回真，失败返回假。注意：本命令调用时所提供的参数值必须与调用“锁住文件”命令时所提供的参数值完全一致。

语法： 逻辑型 解锁文件 （欲加锁或解锁的文件号，欲加锁或解锁的位置，欲加锁或解锁的长度）

参数名 | 描 述
欲加锁或解锁的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲加锁或解锁的位置 | 必需的；整数型。位置值从 0 开始。
欲加锁或解锁的长度 | 必需的；整数型。

示例：


移动读写位置

移动读写位置 命令 所属类别：文件读写

在被打开的文件中，设置下一个读或写操作的位置。成功返回真，失败返回假。

语法： 逻辑型 移动读写位置 （欲进行操作的文件号，［起始移动位置］，移动距离）

参数名 | 描 述
欲进行操作的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
起始移动位置 | 可选的；整数型。参数值指定从文件中开始移动的位置。可以为以下常量之一：1、#文件首； 2、#文件尾； 3、#现行位置。如果本参数被省略，默认值为“#文件首”。
移动距离 | 必需的；整数型。参数值指定相对于起始移动位置的移动长度。

示例：


移到文件首

移到文件首 命令 所属类别：文件读写

在被打开的文件中，设置下一个读或写操作的位置到文件首。成功返回真，失败返回假。

语法： 逻辑型 移到文件首 （欲进行操作的文件号）

参数名 | 描 述
欲进行操作的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。

示例：


移到文件尾

移到文件尾 命令 所属类别：文件读写

在被打开的文件中，设置下一个读或写操作的位置到文件尾。成功返回真，失败返回假。

语法： 逻辑型 移到文件尾 （欲进行操作的文件号）

参数名 | 描 述
欲进行操作的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。

示例：


读入字节集

读入字节集 命令 所属类别：文件读写

本命令用作从文件中当前读写位置读取并返回一段字节集数据，实际读入长度（即返回的字节集的尺寸）可能会小于欲读入长度。如果读入失败，将返回一个空字节集并且自动将当前文件读写位置移到文件尾部。

语法： 字节集 读入字节集 （欲读入数据的文件号，欲读入数据的长度）

参数名 | 描 述
欲读入数据的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲读入数据的长度 | 必需的；整数型。

示例：


写出字节集

写出字节集 命令 所属类别：文件读写

本命令用作写出一段或数段字节集数据到文件中当前读写位置处。成功返回真，失败返回假。

语法： 逻辑型 写出字节集 （欲写出数据的文件号，欲写出的字节集数据，… ）

参数名 | 描 述
欲写出数据的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲写出的字节集数据 | 必需的；可扩充的；字节集。

示例：


读入文本

读入文本 命令 所属类别：文件读写

本命令用作从文件中当前读写位置读取并返回一段文本数据，实际读入长度（即返回文本的尺寸）可能会小于欲读入长度。如果该数据中存在字节 0 或 26（文本结束标志），将仅返回该字节之前的数据。如果读入失败，将返回一个空文本并且自动将当前文件读写位置移到文件尾部。

语法： 文本型 读入文本 （欲读入文本数据的文件号，［欲读入文本数据的长度］）

参数名 | 描 述
欲读入文本数据的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲读入文本数据的长度 | 可选的；整数型。如果本参数被省略，默认读入文件中的所有文本数据。

示例：


写出文本

写出文本 命令 所属类别：文件读写

本命令用作写出一段或数段文本数据到文件中当前读写位置处。成功返回真，失败返回假。

语法： 逻辑型 写出文本 （欲写出文本的文件号，欲写出的文本，… ）

参数名 | 描 述
欲写出文本的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲写出的文本 | 必需的；可扩充的；通用型。参数值如果不为文本类型数据，将自动进行转换，如果无法转换（即数据类型为字节集、子程序指针、库或用户自定义数据类型），则不写出此数据。

示例：


读入一行

读入一行 命令 所属类别：文件读写

本命令用作从文件中当前读写位置读取并返回一行文本数据，行末的回车及换行符将被抛弃。如果读入失败，将返回一个空文本并且自动将当前文件读写位置移到文件尾部。

语法： 文本型 读入一行 （欲读入文本数据的文件号）

参数名 | 描 述
欲读入文本数据的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。

示例：


写文本行

写文本行 命令 所属类别：文件读写

本命令用作写出一行或多行文本数据到文件中当前读写位置处，每行的尾部将被自动加上回车及换行符。成功返回真，失败返回假。

语法： 逻辑型 写文本行 （欲写出文本的文件号，欲写出的文本，… ）

参数名 | 描 述
欲写出文本的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲写出的文本 | 必需的；可扩充的；通用型。参数值如果不为文本类型数据，将自动进行转换，如果无法转换（即数据类型为字节集、子程序指针、库或用户自定义数据类型），则不写出此数据。

示例：


读入数据

读入数据 命令 所属类别：文件读写

本命令应该与“写出”命令配合使用，用作从文件中当前读写位置读取格式数据到指定的一系列容器或数组容器中。成功返回真，失败返回假。

语法： 逻辑型 读入数据 （欲读入数据的文件号，存放所读入数据的容器，… ）

参数名 | 描 述
欲读入数据的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
存放所读入数据的容器 | 必需的；可扩充的；通用型，参数数据只能提供容器及容器数组。如果容器的数据类型为用户自定义或库定义数据类型，命令将会失败。

示例：


写出数据

写出数据 命令 所属类别：文件读写

本命令应该与“读入”命令配合使用，用作写出一系列容器或数组容器的格式数据到文件中当前读写位置处。成功返回真，失败返回假。 具体各种数据类型数据的写出格式为： 1、数值型、逻辑型、日期时间型、子程序指针型： 为其所对应的实际数据； 2、文本型： 为文本数据 + 字节 0 ； 3、字节集型： 为字节集数据长度（整数） + 字节集实际数据； 4、以上各种数据类型的数组型数据： 为非数组情况下数据格式的顺序排列。

语法： 逻辑型 写出数据 （欲写出数据的文件号，欲写出的数据，… ）

参数名 | 描 述
欲写出数据的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲写出的数据 | 必需的；可扩充的；通用型，参数数据可以同时提供数组或非数组数据。如果被写出数据的数据类型为用户自定义或库定义数据类型，命令将会失败。

示例：


是否在文件尾

是否在文件尾 命令 所属类别：文件读写

如果指定被打开文件的读写位置已经处于该文件数据的尾部，则返回真，否则返回假。

语法： 逻辑型 是否在文件尾 （文件号，［是否为判断文本已读完］）

参数名 | 描 述
文件号 | 必需的；整数型。参数值指明欲操作的文件号，该文件号必须由“打开文件”命令所返回。
是否为判断文本已读完 | 可选的；逻辑型。如果本参数值为真而且下一即将读入的字节为字节值 0 或 26 等文本终止标记符或者当前读写位置已处于该文件数据的尾部，命令将返回真。如果本参数被省略或为假，将不进行此检查。

示例：


取读写位置

取读写位置 命令 所属类别：文件读写

返回指定被打开文件的当前读/写位置，位置值从 0 开始。如果给定文件号无效或失败，返回 -1 。

语法： 整数型 取读写位置 （文件号）

参数名 | 描 述
文件号 | 必需的；整数型。参数值指明欲操作的文件号，该文件号必须由“打开文件”命令所返回。

示例：


取文件长度

取文件长度 命令 所属类别：文件读写

返回指定被打开文件的尺寸，该尺寸以字节为单位。如果给定文件号无效或失败，返回 -1 。

语法： 整数型 取文件长度 （文件号）

参数名 | 描 述
文件号 | 必需的；整数型。参数值指明欲操作的文件号，该文件号必须由“打开文件”命令所返回。

示例：


插入字节集

插入字节集 命令 所属类别：文件读写

本命令用作插入一段或数段字节集数据到文件中当前读写位置处。成功返回真，失败返回假。

语法： 逻辑型 插入字节集 （欲写出数据的文件号，欲写出的字节集数据，… ）

参数名 | 描 述
欲写出数据的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲写出的字节集数据 | 必需的；可扩充的；字节集。

示例：


插入文本

插入文本 命令 所属类别：文件读写

本命令用作插入一段或数段文本数据到文件中当前读写位置处。成功返回真，失败返回假。

语法： 逻辑型 插入文本 （欲写出文本的文件号，欲写出的文本，… ）

参数名 | 描 述
欲写出文本的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲写出的文本 | 必需的；可扩充的；通用型。参数值如果不为文本类型数据，将自动进行转换，如果无法转换（即数据类型为字节集、子程序指针、库或用户自定义数据类型），则不写出此数据。

示例：


插入文本行

插入文本行 命令 所属类别：文件读写

本命令用作插入一段或数段文本行到文件中当前读写位置处。成功返回真，失败返回假。

语法： 逻辑型 插入文本行 （欲写出文本的文件号，欲写出的文本，… ）

参数名 | 描 述
欲写出文本的文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲写出的文本 | 必需的；可扩充的；通用型。参数值如果不为文本类型数据，将自动进行转换，如果无法转换（即数据类型为字节集、子程序指针、库或用户自定义数据类型），则不写出此数据。

示例：


删除数据

删除数据 命令 所属类别：文件读写

本命令用作在文件中当前读写位置处删除一段字节数据，文件后面的数据顺序前移。成功返回真，失败返回假。

语法： 逻辑型 删除数据 （文件号，欲删除数据的字节数）

参数名 | 描 述
文件号 | 必需的；整数型。该文件号由“打开文件”命令所返回。
欲删除数据的字节数 | 必需的；整数型。

示例：


系统处理

系统处理 类别 跳至：系统核心支持库

运行 | 取剪辑板文本 | 置剪辑板文本 | 剪辑板中可有文本
清除剪辑板 | 取屏幕宽度 | 取屏幕高度 | 取鼠标水平位置
取鼠标垂直位置 | 取颜色数 | 取文本注册表项 | 取数值注册表项
取字节集注册表项 | 写注册表项 | 删除注册表项 | 输入框
信息框 | 鸣叫 | 取启动时间 | 置等待鼠标
恢复鼠标 | 延时 | 取文本注册项 | 取数值注册项
取字节集注册项 | 写注册项 | 删除注册项 | 注册项是否存在


运行

运行 命令 所属类别：系统处理

本命令运行指定的外部命令。如果运行成功，返回真，否则返回假。

语法： 逻辑型 运行 （欲运行的命令行，是否等待程序运行完毕，［被运行程序窗口显示方式］）

参数名 | 描 述
欲运行的命令行 | 必需的；文本型。
是否等待程序运行完毕 | 必需的；逻辑型，初始值为“假”。
被运行程序窗口显示方式 | 可选的；整数型。参数值可以为以下常量之一：1、#隐藏窗口； 2、#普通激活； 3、#最小化激活； 4、#最大化激活； 5、#普通不激活； 6、#最小化不激活。如果省略本参数，默认为“普通激活”方式。

示例：


取剪辑板文本

取剪辑板文本 命令 所属类别：系统处理

返回存放于当前 Windows 系统剪辑板中的文本。如果当前剪辑板中无文本数据，将返回空文本。

语法： 文本型 取剪辑板文本 （）

示例：


置剪辑板文本

置剪辑板文本 命令 所属类别：系统处理

将指定文本存放到当前 Windows 系统剪辑板中去，剪辑板中的原有内容被覆盖。成功返回真，失败返回假。

语法： 逻辑型 置剪辑板文本 （准备置入剪辑板的文本）

参数名 | 描 述
准备置入剪辑板的文本 | 必需的；文本型。

示例：


剪辑板中可有文本

剪辑板中可有文本 命令 所属类别：系统处理

如果当前 Windows 系统剪辑板中有文本数据，则返回真，否则返回假。

语法： 逻辑型 剪辑板中可有文本 （）

示例：


清除剪辑板

清除剪辑板 命令 所属类别：系统处理

清除当前 Windows 系统剪辑板中的所有数据。

语法： 无返回值 清除剪辑板 （）

示例：


取屏幕宽度

取屏幕宽度 命令 所属类别：系统处理

返回屏幕当前显示区域的宽度，单位为像素点。

语法： 整数型 取屏幕宽度 （）

示例：


取屏幕高度

取屏幕高度 命令 所属类别：系统处理

返回屏幕当前显示区域的高度，单位为像素点。

语法： 整数型 取屏幕高度 （）

示例：


取鼠标水平位置

取鼠标水平位置 命令 所属类别：系统处理

返回鼠标指针的当前水平位置，单位为像素点，相对于屏幕左边。

语法： 整数型 取鼠标水平位置 （）

示例：


取鼠标垂直位置

取鼠标垂直位置 命令 所属类别：系统处理

返回鼠标指针的当前垂直位置，单位为像素点，相对于屏幕顶边。

语法： 整数型 取鼠标垂直位置 （）

示例：


取颜色数

取颜色数 命令 所属类别：系统处理

返回当前显示方式所提供的最大颜色显示数目。

语法： 整数型 取颜色数 （）

示例：


取文本注册表项

取文本注册表项 命令 所属类别：系统处理

在 Windows 注册表中返回指定的文本类型注册表项设置值。

语法： 文本型 取文本注册表项 （程序名称，节名称，注册表项名称，［默认文本］）

参数名 | 描 述
程序名称 | 必需的；文本型。包含应用程序的名称，用作在注册表中的入口名。
节名称 | 必需的；文本型。包含欲读入的注册表项所处的节名称。
注册表项名称 | 必需的；文本型。参数值指定欲读入的注册表项在其节中的名称。
默认文本 | 可选的；文本型。如果指定的注册表项不存在，将返回此默认文本。如果指定的注册表项不存在且本参数被省略，将返回一个长度为 0 的空文本。

示例：


取数值注册表项

取数值注册表项 命令 所属类别：系统处理

在 Windows 注册表中返回指定的数值类型注册表项设置值。

语法： 整数型 取数值注册表项 （程序名称，节名称，注册表项名称，［默认数值］）

参数名 | 描 述
程序名称 | 必需的；文本型。包含应用程序的名称，用作在注册表中的入口名。
节名称 | 必需的；文本型。包含欲读入的注册表项所处的节名称。
注册表项名称 | 必需的；文本型。参数值指定欲读入的注册表项在其节中的名称。
默认数值 | 可选的；整数型。如果指定的注册表项不存在，将返回此默认数值。如果指定的注册表项不存在且本参数被省略，将返回数值 0。

示例：


取字节集注册表项

取字节集注册表项 命令 所属类别：系统处理

在 Windows 注册表中返回指定的字节集类型注册表项设置值。

语法： 字节集 取字节集注册表项 （程序名称，节名称，注册表项名称，［默认字节集］）

参数名 | 描 述
程序名称 | 必需的；文本型。包含应用程序的名称，用作在注册表中的入口名。
节名称 | 必需的；文本型。包含欲读入的注册表项所处的节名称。
注册表项名称 | 必需的；文本型。参数值指定欲读入的注册表项在其节中的名称。
默认字节集 | 可选的；字节集。如果指定的注册表项不存在，将返回此默认字节集。如果指定的注册表项不存在且本参数被省略，将返回空字节集。

示例：


写注册表项

写注册表项 命令 所属类别：系统处理

在 Windows 注册表中保存或建立指定的注册表项设置值。成功返回真，否则返回假。

语法： 逻辑型 写注册表项 （程序名称，节名称，注册表项名称，欲写入值）

参数名 | 描 述
程序名称 | 必需的；文本型。包含应用程序的名称，用作在注册表中的入口名。
节名称 | 必需的；文本型。包含欲写入的注册表项所处的节名称。
注册表项名称 | 必需的；文本型。参数值指定欲写入的注册表项在其节中的名称。
欲写入值 | 必需的；通用型。参数值指定欲写入到指定注册表项中的值，只能为数值、文本或者字节集，否则命令将失败。

示例：


删除注册表项

删除注册表项 命令 所属类别：系统处理

在 Windows 注册表中，删除应用程序项目入口、注册表节或注册表项。成功返回真，否则返回假。

语法： 逻辑型 删除注册表项 （程序名称，［节名称］，［注册表项名称］）

参数名 | 描 述
程序名称 | 必需的；文本型。包含应用程序的名称，用作在注册表中的入口名。如果该入口中已不存在节，且下一参数被省略或为空，则将此应用程序入口删除。
节名称 | 可选的；文本型。指定包含被删除注册表项的节名称。如果下一参数被省略或为空，则将此注册表节连同其中所有的注册表项都删除。
注册表项名称 | 可选的；文本型。参数值指定要删除注册表项的名称。

示例：


输入框

输入框 命令 所属类别：系统处理

在一对话框中显示提示，等待用户输入正文并按下按钮。如果用户在确认输入后（按下“确认输入”按钮或回车键）退出，返回真，否则返回假。

语法： 逻辑型 输入框 （［提示信息］，［窗口标题］，［初始文本］，存放输入内容的容器，［输入方式］）

参数名 | 描 述
提示信息 | 可选的；文本型。如果提示信息包含多行，可在各行之间用回车符 (即“字符 (13)”)、换行符 (即“字符 (10)”) 或回车换行符的组合 (即：“字符 (13) + 字符 (10)”) 来分隔。如果提示信息太长或行数过多，超过部分将不会被显示出来。
窗口标题 | 可选的；文本型。参数值指定显示在对话框标题栏中的文本。如果省略，默认为文本“请输入：”。
初始文本 | 可选的；文本型。参数值指定初始设置到对话框输入文本框中的内容。
存放输入内容的容器 | 必需的；通用型，参数数据只能提供容器。参数值所指定的容器可以为数值或文本型，用于以不同的数据类型取回输入内容。
输入方式 | 可选的；整数型。参数值可以为以下常量值： 1、#输入文本； 2、#输入整数； 3、输入小数。如果省略本参数，默认为“#输入文本”。

示例：


信息框

信息框 命令 所属类别：系统处理

在对话框中显示信息，等待用户单击按钮，并返回一个整数告诉用户单击哪一个按钮。该整数为以下常量值之一： 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、#文本右对齐
窗口标题 | 可选的；文本型。参数值指定显示在对话框标题栏中的文本。如果省略，默认为文本“信息：”。

示例：


鸣叫

鸣叫 命令 所属类别：系统处理

通过计算机媒体设备或者喇叭发出一个声音。

语法： 无返回值 鸣叫 （）

示例：


取启动时间

取启动时间 命令 所属类别：系统处理

返回自 Windows 系统启动后到现在为止所经历过的毫秒数。

语法： 整数型 取启动时间 （）

示例：


置等待鼠标

置等待鼠标 命令 所属类别：系统处理

本命令设置现行鼠标的形状为沙漏形，用作在即将长时间执行程序前提示操作者。

语法： 无返回值 置等待鼠标 （）

示例：


恢复鼠标

恢复鼠标 命令 所属类别：系统处理

本命令恢复现行鼠标的原有形状，用作与“置等待鼠标”命令配对使用。

语法： 无返回值 恢复鼠标 （）

示例：


延时

延时 命令 所属类别：系统处理

本命令暂停当前程序的运行并等待指定的时间。

语法： 无返回值 延时 （欲等待的时间）

参数名 | 描 述
欲等待的时间 | 必需的；整数型。本参数指定欲暂停程序执行的时间，单位为毫秒。

示例：


取文本注册项

取文本注册项 命令 所属类别：系统处理

在 Windows 注册表中返回指定的文本类型注册表项设置值。与“取文本注册表项”命令不同的是本命令可以取任意位置处的注册表项。

语法： 文本型 取文本注册项 （根目录，全路径注册项名，［默认文本］）

参数名 | 描 述
根目录 | 必需的；整数型。可以为以下常量值之一： 1、#根类； 2、#现行设置； 3、#现行用户； 4、#本地机器； 5、#所有用户。
全路径注册项名 | 必需的；文本型。
默认文本 | 可选的；文本型。如果指定的注册表项不存在，将返回此默认文本。如果指定的注册表项不存在且本参数被省略，将返回一个长度为 0 的空文本。

示例：


取数值注册项

取数值注册项 命令 所属类别：系统处理

在 Windows 注册表中返回指定的数值类型注册表项设置值。与“取数值注册表项”命令不同的是本命令可以取任意位置处的注册表项。

语法： 整数型 取数值注册项 （根目录，全路径注册项名，［默认数值］）

参数名 | 描 述
根目录 | 必需的；整数型。可以为以下常量值之一： 1、#根类； 2、#现行设置； 3、#现行用户； 4、#本地机器； 5、#所有用户。
全路径注册项名 | 必需的；文本型。
默认数值 | 可选的；整数型。如果指定的注册表项不存在，将返回此默认数值。如果指定的注册表项不存在且本参数被省略，将返回数值 0。

示例：


取字节集注册项

取字节集注册项 命令 所属类别：系统处理

在 Windows 注册表中返回指定的字节集类型注册表项设置值。与“取字节集注册表项”命令不同的是本命令可以取任意位置处的注册表项。

语法： 字节集 取字节集注册项 （根目录，全路径注册项名，［默认字节集］）

参数名 | 描 述
根目录 | 必需的；整数型。可以为以下常量值之一： 1、#根类； 2、#现行设置； 3、#现行用户； 4、#本地机器； 5、#所有用户。
全路径注册项名 | 必需的；文本型。
默认字节集 | 可选的；字节集。如果指定的注册表项不存在，将返回此默认字节集。如果指定的注册表项不存在且本参数被省略，将返回空字节集。

示例：


写注册项

写注册项 命令 所属类别：系统处理

在 Windows 注册表中保存或建立指定的注册表项。成功返回真，否则返回假。与“写注册表项”命令不同的是本命令可以写任意位置处的注册表项。

语法： 逻辑型 写注册项 （根目录，全路径注册项名，欲写入值）

参数名 | 描 述
根目录 | 必需的；整数型。可以为以下常量值之一： 1、#根类； 2、#现行设置； 3、#现行用户； 4、#本地机器； 5、#所有用户。
全路径注册项名 | 必需的；文本型。
欲写入值 | 必需的；通用型。参数值指定欲写入到指定注册表项中的值，只能为数值、文本或者字节集，否则命令将失败。

示例：


删除注册项

删除注册项 命令 所属类别：系统处理

在 Windows 注册表中删除指定注册表项。成功返回真，否则返回假。与“删除注册表项”命令不同的是本命令可以删除任意位置处的注册表项。

语法： 逻辑型 删除注册项 （根目录，全路径注册项名）

参数名 | 描 述
根目录 | 必需的；整数型。可以为以下常量值之一： 1、#根类； 2、#现行设置； 3、#现行用户； 4、#本地机器； 5、#所有用户。
全路径注册项名 | 必需的；文本型。

示例：


注册项是否存在

注册项是否存在 命令 所属类别：系统处理

如果指定注册表项存在，返回真，否则返回假。

语法： 逻辑型 注册项是否存在 （根目录，全路径注册项名）

参数名 | 描 述
根目录 | 必需的；整数型。可以为以下常量值之一： 1、#根类； 2、#现行设置； 3、#现行用户； 4、#本地机器； 5、#所有用户。
全路径注册项名 | 必需的；文本型。

示例：


媒体播放

媒体播放 类别 跳至：系统核心支持库


播放音乐

播放音乐 命令 所属类别：媒体播放

可以播放 .WAV、.MID 声音文件或相应格式的字节集声音数据、声音资源。成功返回真，失败返回假。

语法： 逻辑型 播放音乐 （欲播放的音乐，［是否循环播放］）

参数名 | 描 述
欲播放的音乐 | 必需的；通用型。参数值可以为 .WAV、.MID 声音文件名称或相应格式的字节集声音数据、声音资源。
是否循环播放 | 可选的；逻辑型。为真表示指定音乐将被循环播放，否则仅只播放一次。如果本参数被省略，默认为仅播放一次。

示例：


停止播放

停止播放 命令 所属类别：媒体播放

停止正在播放的音乐。

语法： 无返回值 停止播放 （）

示例：


播放MID

播放MID 命令 所属类别：媒体播放

可以自动连续播放多个 MIDI 声音文件（注意不支持 WAV ）或相应格式的字节集声音数据、声音资源。

语法： 无返回值 播放MID （［播放次数］，［间隔时间］，欲播放的 MIDI 音乐，… ）

参数名 | 描 述
播放次数 | 可选的；整数型。为 -1 表示指定音乐将被循环播放，否则仅只播放指定的次数。如果本参数被省略，默认值为 1 。
间隔时间 | 可选的；整数型。指定 MIDI 音乐之间的播放间隔时间，单位为 0.1 秒。如果本参数被省略，默认值为 0 。
欲播放的 MIDI 音乐 | 必需的；可扩充的；通用型，参数数据可以同时提供数组或非数组数据。参数值可以为 MIDI 声音文件名称或相应格式的字节集声音数据、声音资源。

示例：


播放MP3

播放MP3 命令 所属类别：媒体播放

可以自动连续播放多个 MP3 音乐文件。注意执行本命令需要 mp3.run 外部文件的支持。

语法： 无返回值 播放MP3 （［播放次数］，欲播放的 MP3 文件名，… ）

参数名 | 描 述
播放次数 | 可选的；整数型。为 -1 表示指定音乐将被循环播放，否则仅只播放指定的次数。如果本参数被省略，默认值为 1 。
欲播放的 MP3 文件名 | 必需的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。

示例：


程序调试

程序调试 类别 跳至：系统核心支持库


输出调试文本

输出调试文本 命令 所属类别：程序调试

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

语法： 无返回值 输出调试文本 （准备输出的调试文本信息，… ）

参数名 | 描 述
准备输出的调试文本信息 | 必需的；可扩充的；文本型。

示例：


暂停

暂停 命令 所属类别：程序调试

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

语法： 无返回值 暂停 （）

示例：


检查

检查 命令 所属类别：程序调试

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

语法： 无返回值 检查 （被校验的条件）

参数名 | 描 述
被校验的条件 | 必需的；逻辑型。如果此条件不能成立，即参数值为假，易程序的执行将被暂停且警示。

示例：


是否为调试版

是否为调试版 命令 所属类别：程序调试

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

语法： 逻辑型 是否为调试版 （）

示例：


其他

其他 类别 跳至：系统核心支持库

载入 | 选择 | 多项选择 | 是否为空
是否已创建 | 取数据类型尺寸 | 取颜色值 | 取事件单元
事件转移 | 复制窗口单元 | 处理事件 | 载入图片
卸载图片 | 指针是否有效 |  |


载入

载入 命令 所属类别：其他

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

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

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

示例：


选择

选择 命令 所属类别：其他

根据所提供参数的值，返回两部分中的其中一个。

语法： 通用型 选择 （用作选择的逻辑值，待选择项一，待选择项二）

参数名 | 描 述
用作选择的逻辑值 | 必需的；逻辑型。如果该值为真，将返回第一个待选择项，否则将返回第二个待选择项。
待选择项一 | 必需的；通用型，参数数据可以同时提供数组或非数组数据。如果给定逻辑值为真，命令将返回本选择项。
待选择项二 | 必需的；通用型，参数数据可以同时提供数组或非数组数据。如果给定逻辑值为假，命令将返回本选择项。

示例：


多项选择

多项选择 命令 所属类别：其他

从参数列表项目中选择并返回一个值。

语法： 通用型 多项选择 （索引值，待选择项数据，… ）

参数名 | 描 述
索引值 | 必需的；整数型。命令会根据本索引值来返回选择项列表中的某个值。如果索引值是 1，则命令会返回列表中的第 1 个选择项。如果索引值是 2，则会返回列表中的第 2 个选择项，以此类推。如果索引值小于 1 或者大于最大可选择项，将会产生运行错误。
待选择项数据 | 必需的；可扩充的；通用型，参数数据可以同时提供数组或非数组数据。

示例：


是否为空

是否为空 命令 所属类别：其他

返回一个逻辑值，指出在调用子程序时是否为指定参数提供了数据（该参数必定有“可空”标志），如未提供，返回真，否则返回假。注意：必须在对该参数的值进行修改之前进行测试，如果在修改后进行本测试，返回值将无意义。

语法： 逻辑型 是否为空 （欲测试的参数容器）

参数名 | 描 述
欲测试的参数容器 | 必需的；通用型，参数数据只能提供容器及容器数组。

示例：


是否已创建

是否已创建 命令 所属类别：其他

如果指定的窗口或窗口单元有效且已经被载入或创建，返回真，否则返回假。对于窗口菜单项单元，如果其所处窗口已经被载入，命令将返回真，否则返回假。

语法： 逻辑型 是否已创建 （欲被检查的窗口或窗口单元）

参数名 | 描 述
欲被检查的窗口或窗口单元 | 必需的；通用型。

示例：


取数据类型尺寸

取数据类型尺寸 命令 所属类别：其他

取指定数据类型的数据尺寸，该数据类型不能为文本、字节集、库或用户自定义数据类型。

语法： 整数型 取数据类型尺寸 （欲取其尺寸的数据类型）

参数名 | 描 述
欲取其尺寸的数据类型 | 必需的；整数型。参数值可以为以下常量： 1、#字节型； 2、#短整数型； 3、#整数型； 4、#长整数型； 5、#小数型； 6、#双精度小数型； 7、#逻辑型； 8、#日期时间型； 9、#子程序指针型。

示例：


取颜色值

取颜色值 命令 所属类别：其他

返回一个整数，用来表示一个红绿蓝颜色值。

语法： 整数型 取颜色值 （红色，绿色，蓝色）

参数名 | 描 述
红色 | 必需的；整数型。数值范围从 0 到 255，表示颜色中的红色成份。
绿色 | 必需的；整数型。数值范围从 0 到 255，表示颜色中的绿色成份。
蓝色 | 必需的；整数型。数值范围从 0 到 255，表示颜色中的蓝色成份。

示例：


取事件单元

取事件单元 命令 所属类别：其他

返回一个有效的单元型数据，指定当前所正在处理的事件是从何单元实际产生的。本命令主要用于在事件处理子程序中动态确定事件的来源。注意：只能在处理事件的过程中使用本命令，如果在其它情况下使用，将产生运行时错误。

语法： 通用型 取事件单元 （）

示例：


事件转移

事件转移 命令 所属类别：其他

设置将第一个单元上产生的所有事件转交由第二个同窗口同类型单元的事件处理子程序去处理，就好象此事件是在第二个单元上实际发生的一样。本命令可用来设置用同一事件处理子程序处理来自多个同类型单元的事件。使用时可与“取事件单元”命令、对象的“标记”属性等相配合。设置成功返回真，失败返回假。

语法： 逻辑型 事件转移 （单元一，［单元二］）

参数名 | 描 述
单元一 | 必需的；通用型。参数值指定欲将其事件转移的单元。如果该参数值指定的不是窗口内的单元，而是窗口本身，则不考虑“单元二”参数的设置情况，直接取消被指定窗口上所有单元事件转移设置。
单元二 | 可选的；通用型。参数值指定单元一事件转移到的目的单元，必须与单元一的类型相同且在同一窗口内，否则命令会失败。如果本参数被省略，将取消单元一的原有事件转移设置。

示例：


复制窗口单元

复制窗口单元 命令 所属类别：其他

复制创建与指定窗口单元设计状态完全一致的新单元。该被复制单元将放在原单元的下面，其事件被自动转移到原单元上。如果复制时被复制窗口单元所在的窗口尚未被载入，那么复制出来的窗口单元也不会被立即创建，而会等到其所在窗口将来被载入时一并创建。并且此时复制出来的窗口单元将永久存在，就好象是用户在设计窗口时所加入的一样，不会因为其所在窗口被销毁而被抛弃；如果复制时被复制窗口单元所在的窗口已经被载入，该单元会被立即创建，但此时无论该单元的“可视”属性是真还是假，创建后的单元都将不会被显示，以便于用户进行属性调整。此时复制出来的窗口单元为临时存在，在其所在窗口被销毁后，此窗口单元将被抛弃，下次再载入原窗口时此窗口单元将不复存在。成功返回真，失败返回假。

语法： 逻辑型 复制窗口单元 （欲被复制的窗口单元，存放新创建单元的容器）

参数名 | 描 述
欲被复制的窗口单元 | 必需的；通用型。参数值不能为窗口本身、窗口菜单项单元、选择夹窗口单元。
存放新创建单元的容器 | 必需的；通用型，参数数据只能提供容器。该容器数据类型必须与被复制窗口单元数据类型完全一致，否则命令会失败。

示例：


处理事件

处理事件 命令 所属类别：其他

暂时转让控制权，以便让 Windows 操作系统有机会处理其它的如用户键盘或鼠标输入等事件。直到操作系统处理并发送完程序队列中的所有事件后，命令才会返回。

语法： 无返回值 处理事件 （）

示例：


载入图片

载入图片 命令 所属类别：其他

载入指定图片，以供画板、打印机等对象的“画图片”、“取图片宽度”、“取图片高度”之类成员命令使用。如成功则返回被载入图片的图片号，失败返回 0。

语法： 整数型 载入图片 （欲被载入的图片）

参数名 | 描 述
欲被载入的图片 | 必需的；通用型。参数值可以为 .JPG、.GIF、.BMP、.DIB、.ICO、.CUR 等等被支持格式的图片数据、图片资源或图片文件名。

示例：


卸载图片

卸载图片 命令 所属类别：其他

卸载被载入的图片，图片被卸载后不能再被使用。如果某图片被载入后未被卸载，在易程序退出时将自动被卸载。

语法： 无返回值 卸载图片 （图片号）

参数名 | 描 述
图片号 | 必需的；整数型。参数值必须为调用“载入图片”命令所返回的图片号。

示例：


指针是否有效

指针是否有效 命令 所属类别：其他

如果指定的子程序指针值有效并指向一个实际存在的子程序，则返回真，否则返回假。

语法： 逻辑型 指针是否有效 （欲测试的子程序指针值）

参数名 | 描 述
欲测试的子程序指针值 | 必需的；子程序指针。

示例：


数据库

数据库 类别 跳至：系统核心支持库

是否支持多用户 | 取错误码 | 取错误信息 | 创建
打开 | 替换打开 | 置当前库 | 取当前库
关闭 | 全部关闭 | 取库文件名 | 是否已打开
取记录数 | 取创建时间 | 取字段数 | 取字段名
改字段名 | 取字段类型 | 取字段尺寸 | 新建索引
置当前索引 | 取当前索引 | 更新索引 | 取索引数
取索引名 | 取索引字段 | 置加锁重试时间 | 锁住数据库
解锁数据库 | 锁住增删 | 解增删锁 | 锁住记录
解锁记录 | 全部解锁 | 取平均值 | 求和
取最大值 | 取最小值 | 取最大时间 | 取最小时间
计算数目 | 复制结构 | 复制记录 | 计算排序
排序 | 分类计算 | 添加 | 加记录
加空记录 | 替换 | 修改 | 删除
是否已删除 | 恢复删除 | 彻底删除 | 清空
读 | 写 | 读字段 | 写字段
附加字节集 | 附加备注 | 索引查找 | 查找
到首记录 | 到尾记录 | 跳过 | 取记录号
跳到 | 取标签 | 记录是否存在 | 标签跳转
首记录前 | 尾记录后 | 写出缓存 | 写出所有缓存
编辑 |  |  |


是否支持多用户

是否支持多用户 命令 所属类别：数据库

检查本支持库所提供的数据库功能是否支持多用户同时对数据库操作。如果支持，返回真，否则返回假。

语法： 逻辑型 是否支持多用户 （）

示例：


取错误码

取错误码 命令 所属类别：数据库

可以在记录范围参数语句中用作过滤每一条数据库记录；
如果执行某数据库命令失败，在其后执行本命令可以取回非 0 的数据库错误码值。如果该数据库命令执行成功，执行本命令将返回 0 。

语法： 整数型 取错误码 （）

示例：


取错误信息

取错误信息 命令 所属类别：数据库

可以在记录范围参数语句中用作过滤每一条数据库记录；
如果执行某数据库命令失败，在其后执行本命令可以取回错误信息文本。如果该数据库命令执行成功，执行本命令将返回空文本。

语法： 文本型 取错误信息 （）

示例：


创建

创建 命令 所属类别：数据库

创建指定的数据库文件，如果该数据库文件存在，将被覆盖。成功返回真，失败返回假。

语法： 逻辑型 创建 （欲创建数据库的文件名，字段信息表）

参数名 | 描 述
欲创建数据库的文件名 | 必需的；文本型。
字段信息表 | 必需的；字段信息，参数数据只能提供数组数据。参数数组值中顺序指定本数据库中所有字段的信息。

示例：


打开

打开 命令 所属类别：数据库

打开指定的数据库文件。成功返回真，并自动将当前数据库设置为此数据库，失败返回假。

语法： 逻辑型 打开 （欲打开数据库的文件名，［在程序中使用的别名］，［是否只读］，［共享方式］，［用户代码］，［用户密码］，［索引文件表］，… ）

参数名 | 描 述
欲打开数据库的文件名 | 必需的；文本型。
在程序中使用的别名 | 可选的；文本型。别名为在后面的程序中引用本数据库时可使用的另一个名称。欲引用一个已经被打开的数据库可以使用该数据库本身的名称（数据库名称为数据库文件名的无路径和后缀部分。譬如 c:\my documents\gz.edb ，其数据库名称为 gz ），也可以使用在此处所指定的别名。别名主要用作避开重复的数据库名称或者简化对长数据库名的引用。数据库名称与别名皆不区分大小写，在查找数据库时，系统将优先查找别名。如果本参数被省略，默认为没有别名。
是否只读 | 可选的；逻辑型。参数值说明是否仅对数据库进行读操作，如果省略本参数，默认为假。
共享方式 | 可选的；整数型。参数值指定在多用户环境中限制其它用户操作此数据库的方式。如果省略本参数，默认为“#无限制”。方式值可以为以下常量之一： 1、#无限制：允许其它用户任意操作此数据库； 2、#禁止读：禁止其它用户读此数据库； 3、#禁止写：禁止其它用户写此数据库； 4、#禁止读写：独占使用此数据库，禁止其它用户的任何操作。
用户代码 | 可选的；长整数型。本参数目前尚未被支持，仅用作保留参数位置。
用户密码 | 可选的；长整数型。本参数目前尚未被支持，仅用作保留参数位置。
索引文件表 | 可选的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定本数据库的所有索引文件，它们将被同步打开，以便得到及时更新。

示例：


替换打开

替换打开 命令 所属类别：数据库

打开指定的数据库文件。成功返回真，并自动关闭当前数据库后将当前数据库设置为此数据库，失败返回假。

语法： 逻辑型 替换打开 （欲打开数据库的文件名，［在程序中使用的别名］，［是否只读］，［共享方式］，［用户代码］，［用户密码］，［索引文件表］，… ）

参数名 | 描 述
欲打开数据库的文件名 | 必需的；文本型。
在程序中使用的别名 | 可选的；文本型。别名为在后面的程序中引用本数据库时可使用的另一个名称。欲引用一个已经被打开的数据库可以使用该数据库本身的名称（数据库名称为数据库文件名的无路径和后缀部分。譬如 c:\my documents\gz.edb ，其数据库名称为 gz ），也可以使用在此处所指定的别名。别名主要用作避开重复的数据库名称或者简化对长数据库名的引用。数据库名称与别名皆不区分大小写，在查找数据库时，系统将优先查找别名。如果本参数被省略，默认为没有别名。
是否只读 | 可选的；逻辑型。参数值说明是否仅对数据库进行读操作，如果省略本参数，默认为假。
共享方式 | 可选的；整数型。参数值指定在多用户环境中限制其它用户操作此数据库的方式。如果省略本参数，默认为“#无限制”。方式值可以为以下常量之一： 1、#无限制：允许其它用户任意操作此数据库； 2、#禁止读：禁止其它用户读此数据库； 3、#禁止写：禁止其它用户写此数据库； 4、#禁止读写：独占使用此数据库，禁止其它用户的任何操作。
用户代码 | 可选的；长整数型。本参数目前尚未被支持，仅用作保留参数位置。
用户密码 | 可选的；长整数型。本参数目前尚未被支持，仅用作保留参数位置。
索引文件表 | 可选的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定本数据库的所有索引文件，它们将被同步打开，以便得到及时更新。

示例：


置当前库

置当前库 命令 所属类别：数据库

本命令选择一个已经被打开的数据库为当前数据库，大部分数据库操作命令都针对当前数据库，譬如：记录指针的移动、字段的读写等等。如果指定数据库不存在或者尚未被打开，命令将返回假，否则返回真。

语法： 逻辑型 置当前库 （数据库别名或名称）

参数名 | 描 述
数据库别名或名称 | 必需的；文本型。参数值指定一个已经被打开的数据库。

示例：


取当前库

取当前库 命令 所属类别：数据库

返回当前数据库的别名，如不存在别名，则返回其名称。如果未设置当前数据库，将返回空文本。

语法： 文本型 取当前库 （）

示例：


关闭

关闭 命令 所属类别：数据库

本命令关闭已经被打开的指定数据库。如果没有提供数据库名称，默认为关闭当前数据库。如果当前数据库被关闭，当前数据库状态值将被设置为空，此时可重新使用“置当前库”命令来进行相应设置。

语法： 无返回值 关闭 （［数据库别名或名称］）

参数名 | 描 述
数据库别名或名称 | 可选的；文本型。参数值如果被省略，默认为关闭当前数据库。

示例：


全部关闭

全部关闭 命令 所属类别：数据库

本命令关闭当前已经被打开的所有数据库。

语法： 无返回值 全部关闭 （）

示例：


取库文件名

取库文件名 命令 所属类别：数据库

返回当前数据库的全路径文件名。如果当前数据库不存在，返回空文本。

语法： 文本型 取库文件名 （）

示例：


是否已打开

是否已打开 命令 所属类别：数据库

如果指定数据库文件已经被打开，返回真，否则返回假。

语法： 逻辑型 是否已打开 （欲测试的数据库文件名）

参数名 | 描 述
欲测试的数据库文件名 | 必需的；文本型。

示例：


取记录数

取记录数 命令 所属类别：数据库

返回当前数据库的记录数目。如果没有设置当前数据库或者失败，将返回 0 。

语法： 整数型 取记录数 （）

示例：


取创建时间

取创建时间 命令 所属类别：数据库

返回当前数据库被创建的时间。

语法： 日期时间型 取创建时间 （）

示例：


取字段数

取字段数 命令 所属类别：数据库

返回当前数据库中字段的数目。

语法： 整数型 取字段数 （）

示例：


取字段名

取字段名 命令 所属类别：数据库

返回当前数据库中指定字段的名称。如果指定字段不存在，将返回空文本。

语法： 文本型 取字段名 （字段名称或位置）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。

示例：


改字段名

改字段名 命令 所属类别：数据库

修改当前数据库中指定字段的名称。本命令只有当数据库的共享打开方式为“#禁止读写”时才有效。成功返回真，失败返回假。

语法： 逻辑型 改字段名 （字段名称或位置，字段的新名称）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。
字段的新名称 | 必需的；文本型。

示例：


取字段类型

取字段类型 命令 所属类别：数据库

返回当前数据库中指定字段的类型，字段类型值为以下常量值之一： 1、#字节型； 2、#短整数型； 3、#整数型； 4、#长整数型； 5、#小数型； 6、#双精度小数型； 7、#逻辑型； 8、#日期时间型； 10、#文本型； 11、#字节集型； 12、#备注型。如果指定字段不存在，将返回 0 。

语法： 整数型 取字段类型 （字段名称或位置）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。

示例：


取字段尺寸

取字段尺寸 命令 所属类别：数据库

返回当前数据库中指定字段在记录中所占的尺寸。如果指定字段不存在，将返回 0 。注意：备注型和字节集型字段将返回 4 。

语法： 整数型 取字段尺寸 （字段名称或位置）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。

示例：


新建索引

新建索引 命令 所属类别：数据库

在当前数据库中创建并打开一个索引文件。索引的存在将降低对数据库记录的更新速度，所以除非是较大的数据库（最起码在一千条记录以上），否则一般不用使用索引。成功返回真，失败返回假。

语法： 逻辑型 新建索引 （欲创建索引文件的名称，［索引类型］，［索引选项］，［索引块尺寸］，被索引字段的名称，… ）

参数名 | 描 述
欲创建索引文件的名称 | 必需的；文本型。
索引类型 | 可选的；整数型。参数值可以为以下常量值之一，如果被省略，默认为“#通常索引”： 1、#通常索引； 2、#读音索引： 在文本型索引字段中，所有汉字根据标准读音建立索引； 3、#南方读音索引： 在文本型索引字段中，所有汉字根据南方读音建立索引。
索引选项 | 可选的；整数型。参数值可以为以下常量值之一或者之和： 1、#不区分大小写：文本型索引字段中不区分英文字母的大小写； 2、#忽略所有空格：文本型索引字段中忽略所有的全、半角空格。 如果本参数被省略，默认为 0 。
索引块尺寸 | 可选的；整数型。参数值指定索引文件记录索引项时所使用索引块的大小，以 512 字节为单位，最大值为 10 。如果本参数被省略，默认值为 1 。仅在超大型数据库中需要建立大索引块的索引文件，一般情况下使用默认值即可。
被索引字段的名称 | 必需的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定所有被索引字段的名称。

示例：


置当前索引

置当前索引 命令 所属类别：数据库

为当前数据库指定当前索引，在进行索引查找时将使用当前索引。如果指定索引不存在，将返回假。

语法： 逻辑型 置当前索引 （索引名称）

参数名 | 描 述
索引名称 | 必需的；文本型。索引名称为索引文件名的无后缀部分。譬如“sy.enx”索引文件，其索引名称为“sy”。

示例：


取当前索引

取当前索引 命令 所属类别：数据库

返回当前数据库的当前索引名称。如果未设置当前数据库或无当前索引，返回空文本。

语法： 文本型 取当前索引 （）

示例：


更新索引

更新索引 命令 所属类别：数据库

通过完全重建来更新当前数据库的当前索引。成功返回真，失败返回假。

语法： 逻辑型 更新索引 （）

示例：


取索引数

取索引数 命令 所属类别：数据库

返回当前数据库中已经被打开索引的数目。

语法： 整数型 取索引数 （）

示例：


取索引名

取索引名 命令 所属类别：数据库

返回当前数据库中指定索引的名称。如果指定位置处不存在索引，将返回空文本。

语法： 文本型 取索引名 （索引位置）

参数名 | 描 述
索引位置 | 必需的；整数型。参数值指定索引在当前数据库内所有被打开索引中的位置，从 1 开始。

示例：


取索引字段

取索引字段 命令 所属类别：数据库

返回当前数据库中指定索引内所有被索引字段的名称数组。如果指定位置处不存在索引，将返回空数组。

语法： 文本型数组 取索引字段 （索引位置）

参数名 | 描 述
索引位置 | 必需的；整数型。参数值指定索引在当前数据库内所有被打开索引中的位置，从 1 开始。

示例：


置加锁重试时间

置加锁重试时间 命令 所属类别：数据库

本命令设置对数据库进行加锁时，如果该位置已经被其他用户锁住或者正在被其他用户访问，系统反复重试加锁的时间。当你的数据库可能被多用户同时访问时，必须在程序首使用本命令设置一个合适的时间值。一般情况下，可以设置为 60 秒，或者根据所处网络的传输和通畅速度来具体设置。

语法： 无返回值 置加锁重试时间 （［加锁重试时间］）

参数名 | 描 述
加锁重试时间 | 可选的；整数型。参数值可以为以下值之一： 1、 大于 0 的值。用于指定具体的重试间隔时间，单位为秒； 2、 0 。不重试，第一次加锁失败后立即返回错误（系统初始值）； 3、 -1。一直重试，直到加锁成功。 如果本参数被省略，默认值为 0 。

示例：


锁住数据库

锁住数据库 命令 所属类别：数据库

本命令执行后独占锁住整个当前数据库，拒绝其它用户的任何访问。成功返回真，失败返回假。

语法： 逻辑型 锁住数据库 （）

示例：


解锁数据库

解锁数据库 命令 所属类别：数据库

本命令解除“锁住数据库”命令对当前数据库加的锁。成功返回真，失败返回假。

语法： 逻辑型 解锁数据库 （）

示例：


锁住增删

锁住增删 命令 所属类别：数据库

本命令执行后独占锁住对当前数据库的增删操作，其它用户可以读写已存在的任何记录，但是不能对数据库记录进行增删。也就是说：不能执行改变数据库记录数目的任何操作。注意：由于“删除”命令仅在记录上加上删除标志，并不实际删除记录，所以不在被加锁的范围内。成功返回真，失败返回假。

语法： 逻辑型 锁住增删 （）

示例：


解增删锁

解增删锁 命令 所属类别：数据库

本命令解除“锁住增删”命令对当前数据库加的锁。成功返回真，失败返回假。

语法： 逻辑型 解增删锁 （）

示例：


锁住记录

锁住记录 命令 所属类别：数据库

本命令执行后可以锁住指定的一个或多个记录。成功返回真，失败返回假。

语法： 逻辑型 锁住记录 （记录号，… ）

参数名 | 描 述
记录号 | 必需的；可扩充的；整数型。参数值指定的记录号从 1 开始。

示例：


解锁记录

解锁记录 命令 所属类别：数据库

本命令解除“锁住记录”命令对记录所加的锁。成功返回真，失败返回假。

语法： 逻辑型 解锁记录 （记录号，… ）

参数名 | 描 述
记录号 | 必需的；可扩充的；整数型。参数值指定的记录号从 1 开始。

示例：


全部解锁

全部解锁 命令 所属类别：数据库

本命令解除由“锁住数据库”、“锁住增删”、“锁住记录”等命令对当前数据库加上的所有锁。成功返回真，失败返回假。

语法： 逻辑型 全部解锁 （）

示例：


取平均值

取平均值 命令 所属类别：数据库

本命令根据当前数据库计算并返回某数值型表达式的平均值，命令执行后当前记录指针保持不变。

语法： 双精度小数型 取平均值 （计算表达式，［记录条件］）

参数名 | 描 述
计算表达式 | 必需的；条件语句型。本参数所指定的表达式内必须使用了当前数据库的字段。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。

示例：


求和

求和 命令 所属类别：数据库

本命令根据当前数据库计算并返回某数值型表达式的和，命令执行后当前记录指针保持不变。

语法： 双精度小数型 求和 （计算表达式，［记录条件］）

参数名 | 描 述
计算表达式 | 必需的；条件语句型。本参数所指定的表达式内必须使用了当前数据库的字段。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。

示例：


取最大值

取最大值 命令 所属类别：数据库

本命令根据当前数据库计算并返回某数值型表达式的最大值，当前记录指针被移动到具有最大值的记录。

语法： 双精度小数型 取最大值 （计算表达式，［记录条件］）

参数名 | 描 述
计算表达式 | 必需的；条件语句型。本参数所指定的表达式内必须使用了当前数据库的字段。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。

示例：


取最小值

取最小值 命令 所属类别：数据库

本命令根据当前数据库计算并返回某数值型表达式的最小值，当前记录指针被移动到具有最小值的记录。

语法： 双精度小数型 取最小值 （计算表达式，［记录条件］）

参数名 | 描 述
计算表达式 | 必需的；条件语句型。本参数所指定的表达式内必须使用了当前数据库的字段。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。

示例：


取最大时间

取最大时间 命令 所属类别：数据库

本命令根据当前数据库计算并返回某日期时间型表达式的最大值，当前记录指针被移动到具有最大值的记录。

语法： 日期时间型 取最大时间 （计算表达式，［记录条件］）

参数名 | 描 述
计算表达式 | 必需的；条件语句型。本参数所指定的表达式内必须使用了当前数据库的字段。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。

示例：


取最小时间

取最小时间 命令 所属类别：数据库

本命令根据当前数据库计算并返回某日期时间型表达式的最小值，当前记录指针被移动到具有最小值的记录。

语法： 日期时间型 取最小时间 （计算表达式，［记录条件］）

参数名 | 描 述
计算表达式 | 必需的；条件语句型。本参数所指定的表达式内必须使用了当前数据库的字段。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。

示例：


计算数目

计算数目 命令 所属类别：数据库

本命令返回当前数据库中指定范围记录的数目。命令执行后当前记录指针保持不变。

语法： 整数型 计算数目 （［记录条件］）

参数名 | 描 述
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。

示例：


复制结构

复制结构 命令 所属类别：数据库

复制当前数据库的结构到另外一个数据库。命令执行后当前记录指针保持不变。成功返回真，失败返回假。

语法： 逻辑型 复制结构 （数据库文件名，［字段范围］，… ）

参数名 | 描 述
数据库文件名 | 必需的；文本型。本参数指定欲复制到的数据库文件，该数据库必须不存在或者尚未被打开。如果已经存在，将会被覆盖。
字段范围 | 可选的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定所有欲复制字段的名称。如果被省略，默认为所有字段。

示例：


复制记录

复制记录 命令 所属类别：数据库

复制当前数据库的记录到另外一个数据库。命令执行后当前记录指针保持不变。成功返回真，失败返回假。

语法： 逻辑型 复制记录 （数据库文件名，［记录条件］，［字段范围］，… ）

参数名 | 描 述
数据库文件名 | 必需的；文本型。本参数指定欲复制到的数据库文件，该数据库必须不存在或者尚未被打开。如果已经存在，将会被覆盖。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。
字段范围 | 可选的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定所有欲复制字段的名称。如果被省略，默认为所有字段。

示例：


计算排序

计算排序 命令 所属类别：数据库

根据指定数值表达式的计算值排序复制当前数据库的记录到另外一个数据库。命令执行后当前记录指针保持不变。成功返回真，失败返回假。

语法： 逻辑型 计算排序 （数据库文件名，排序表达式，［排序方向］，［记录条件］，［字段范围］，… ）

参数名 | 描 述
数据库文件名 | 必需的；文本型。本参数指定欲复制到的数据库文件，该数据库必须不存在或者尚未被打开。如果已经存在，将会被覆盖。
排序表达式 | 必需的；条件语句型。本参数所指定的表达式内必须使用了当前数据库的字段，表达式所返回数据的类型必须为数值型。
排序方向 | 可选的；逻辑型。本参数的值如果为真或者被省略，将按照从小到大的顺序排序，否则为从大到小。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。
字段范围 | 可选的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定所有欲复制字段的名称。如果被省略，默认为所有字段。

示例：


排序

排序 命令 所属类别：数据库

根据指定字段排序复制当前数据库的记录到另外一个数据库。命令执行后当前记录指针保持不变。成功返回真，失败返回假。

语法： 逻辑型 排序 （数据库文件名，排序字段，［排序方向］，［记录条件］，［字段范围］，… ）

参数名 | 描 述
数据库文件名 | 必需的；文本型。本参数指定欲复制到的数据库文件，该数据库必须不存在或者尚未被打开。如果已经存在，将会被覆盖。
排序字段 | 必需的；文本型，参数数据可以同时提供数组或非数组数据。本参数的数据可以为字段名文本或者字段名文本数组（用作同时指定多个字段）。
排序方向 | 可选的；逻辑型，参数数据可以同时提供数组或非数组数据。本参数的数据可以为一个逻辑值或者逻辑值数组（用作同时为多个字段指定排序方向）。如果逻辑值为真，对应字段将按照从小到大的顺序排序，否则为从大到小。如果本参数被省略，默认为全部按照从小到大的顺序排序。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。
字段范围 | 可选的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定所有欲复制字段的名称。如果被省略，默认为所有字段。

示例：


分类计算

分类计算 命令 所属类别：数据库

对当前数据库进行分类计算，将结果输出到另外一个数据库。注意所有的备注或字节集字段内容将不会被输出到目的数据库中。 命令执行后当前记录指针保持不变。成功返回真，失败返回假。

语法： 逻辑型 分类计算 （数据库文件名，分类字段，［计算方法］，［记录条件］，［字段范围］，… ）

参数名 | 描 述
数据库文件名 | 必需的；文本型。本参数指定欲复制到的数据库文件，该数据库必须不存在或者尚未被打开。如果已经存在，将会被覆盖。
分类字段 | 必需的；文本型，参数数据可以同时提供数组或非数组数据。本参数的数据可以为字段名文本或者字段名文本数组（用作同时指定多个字段）。
计算方法 | 可选的；整数型。参数值可以为以下常量之一： 1、#取平均值； 2、#求和； 3、#取最大值； 4、#取最小值。 如果本参数被省略，默认为“#求和”。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为当前数据库中的所有记录，否则将仅限于满足此条件的记录。
字段范围 | 可选的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定所有欲复制字段的名称。如果被省略，默认为所有字段。

示例：


添加

添加 命令 所属类别：数据库

将指定数据库中的记录添加到当前数据库。命令执行后当前记录指针保持不变。成功返回真，失败返回假。

语法： 逻辑型 添加 （数据库别名或名称，［记录条件］，［字段范围］，… ）

参数名 | 描 述
数据库别名或名称 | 必需的；文本型。本参数指定一个已打开数据库，命令将从该数据库中获取欲添加的记录数据。
记录条件 | 可选的；条件语句型。如果本参数被省略，默认为添加指定数据库中的所有记录，否则仅添加指定数据库中满足此条件的记录。
字段范围 | 可选的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定所有欲添加字段的名称。如果被省略，默认添加所有同名字段。

示例：


加记录

加记录 命令 所属类别：数据库

本命令在当前数据库的尾部添加一条记录，并将当前记录指针移动到该记录处。成功返回真，失败返回假。

语法： 逻辑型 加记录 （［记录数据］，… ）

参数名 | 描 述
记录数据 | 可选的；可扩充的；通用型。本参数的每一个参数值用作为记录中对应位置处的一个字段提供数据。如果某参数值被省略，则对应位置处字段的内容被设置为初始值。

示例：


加空记录

加空记录 命令 所属类别：数据库

本命令在当前数据库的尾部添加一条空记录，并将当前记录指针移动到该记录上。成功返回真，失败返回假。

语法： 逻辑型 加空记录 （）

示例：


替换

替换 命令 所属类别：数据库

本命令替换当前数据库中的记录数据，当前记录指针保持不变。成功返回真，失败返回假。

语法： 逻辑型 替换 （［替换范围］，字段名称或替换数据，… ）

参数名 | 描 述
替换范围 | 可选的；条件语句型。如果本参数被省略，默认为替换当前记录数据，否则替换所有满足此条件记录的数据。如果欲在所有记录内进行替换，请直接将逻辑值“真”赋予本参数。
字段名称或替换数据 | 必需的；可扩充的；通用型。本参数的每一对参数值顺序指定欲被替换字段的名称及其相应的替换值。替换值的数据类型必须与所对应字段的数据类型一致或可互相转换，否则命令会失败。

示例：


修改

修改 命令 所属类别：数据库

本命令一次性修改当前数据库中当前记录内多个字段的内容，当前记录指针保持不变。成功返回真，失败返回假。

语法： 逻辑型 修改 （［修改数据］，… ）

参数名 | 描 述
修改数据 | 可选的；可扩充的；通用型。本参数的每一个参数值用作替换当前记录中对应位置处的一个字段。如果某参数值被省略，则对应位置处字段的内容将保持不变。

示例：


删除

删除 命令 所属类别：数据库

标记删除当前数据库中的当前记录或者指定范围内的记录，当前记录指针位置保持不变。注意：此命令并不实际删除记录，仅仅只加上删除标记，记录依旧存在并可以读写。成功返回真，失败返回假。

语法： 逻辑型 删除 （［记录范围］）

参数名 | 描 述
记录范围 | 可选的；条件语句型。如果本参数被省略，默认为删除或恢复删除当前记录，否则删除或恢复删除所有满足此条件的记录。如果欲删除或恢复删除全部记录，请直接将逻辑值“真”赋予本参数。

示例：


是否已删除

是否已删除 命令 所属类别：数据库

可以在记录范围参数语句中用作过滤每一条数据库记录；
如果当前数据库的当前记录已经被“删除”命令加上删除标记，返回真，否则返回假。

语法： 逻辑型 是否已删除 （）

示例：


恢复删除

恢复删除 命令 所属类别：数据库

去掉当前数据库中当前记录或者指定范围内记录的删除标记，当前记录指针位置保持不变。成功返回真，失败返回假。

语法： 逻辑型 恢复删除 （［记录范围］）

参数名 | 描 述
记录范围 | 可选的；条件语句型。如果本参数被省略，默认为删除或恢复删除当前记录，否则删除或恢复删除所有满足此条件的记录。如果欲删除或恢复删除全部记录，请直接将逻辑值“真”赋予本参数。

示例：


彻底删除

彻底删除 命令 所属类别：数据库

将当前数据库中所有被加上删除标记的记录从数据库中彻底清除，当前记录指针位置将被移动到数据库首记录。记录被彻底删除后将不复存在，并且无法恢复。注意执行本命令将重组数据库记录，因此速度比较慢。成功返回真，失败返回假。

语法： 逻辑型 彻底删除 （）

示例：


清空

清空 命令 所属类别：数据库

彻底清除当前数据库中的所有记录。成功返回真，失败返回假。

语法： 逻辑型 清空 （）

示例：


读

读 命令 所属类别：数据库

可以在记录范围参数语句中用作过滤每一条数据库记录；
返回当前数据库中当前记录处指定字段的数据内容，所返回数据的类型等同于字段的类型。如果指定字段不存在，将产生运行时错误。执行本命令后使用“取错误码”命令可以判断是否读入成功。

语法： 通用型 读 （字段名称或位置）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。

示例：


写

写 命令 所属类别：数据库

将数据写入到当前数据库中当前记录处的指定字段内。成功返回真，失败返回假。

语法： 逻辑型 写 （字段名称或位置，［欲写入数据］）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。
欲写入数据 | 可选的；通用型。本参数数据的类型必须与所对应字段的数据类型一致或可互相转换。如果本参数被省略，则初始化对应字段中的内容，具体为：数值字段被初始化为零，逻辑字段被初始化为假，日期字段被初始化为 1899 年 12 月 30 日，文本及备注字段被初始化为空文本（“”），字节集字段被初始化为空字节集。

示例：


读字段

读字段 命令 所属类别：数据库

可以在记录范围参数语句中用作过滤每一条数据库记录；
返回指定数据库中当前记录处指定字段的数据内容，所返回数据的类型等同于字段的类型。如果指定字段不存在，将产生运行时错误。本命令与“读”命令的不同之处为本命令可以从非当前数据库中读取字段。执行本命令后使用“取错误码”命令可以判断是否读入成功。

语法： 通用型 读字段 （字段名称或位置，［数据库别名或名称］）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。
数据库别名或名称 | 可选的；文本型。参数值指定一个已经被打开的数据库，该数据库内包含所欲读取的字段。如果被省略，默认为当前数据库。

示例：


写字段

写字段 命令 所属类别：数据库

将数据写入到指定数据库中当前记录处的指定字段内。成功返回真，失败返回假。本命令与“写”命令的不同之处为本命令可以写入非当前数据库中的字段。

语法： 逻辑型 写字段 （字段名称或位置，［数据库别名或名称］，［欲写入数据］）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。
数据库别名或名称 | 可选的；文本型。参数值指定一个已经被打开的数据库，该数据库内包含所欲写入的字段。如果被省略，默认为当前数据库。
欲写入数据 | 可选的；通用型。本参数数据的类型必须与所对应字段的数据类型一致或可互相转换。如果本参数被省略，则初始化对应字段中的内容，具体为：数值字段被初始化为零，逻辑字段被初始化为假，日期字段被初始化为 1899 年 12 月 30 日，文本及备注字段被初始化为空文本（“”），字节集字段被初始化为空字节集。

示例：


附加字节集

附加字节集 命令 所属类别：数据库

将字节集数据添加到当前记录处指定字节集型字段的尾部。成功返回真，失败返回假。

语法： 逻辑型 附加字节集 （字段名称或位置，欲添加的字节集数据，… ）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。
欲添加的字节集数据 | 必需的；可扩充的；字节集。

示例：


附加备注

附加备注 命令 所属类别：数据库

将文本数据添加到当前记录处指定备注型字段的尾部。成功返回真，失败返回假。

语法： 逻辑型 附加备注 （字段名称或位置，欲添加的文本数据，… ）

参数名 | 描 述
字段名称或位置 | 必需的；通用型。参数值可以为一个字段名称文本或者一个字段位置数值，字段位置数值从 1 开始。
欲添加的文本数据 | 必需的；可扩充的；文本型。

示例：


索引查找

索引查找 命令 所属类别：数据库

本命令在当前数据库中使用其当前索引来快速寻找某一记录，寻找从当前记录位置（包括当前记录）处开始。注意为命令所提供的欲搜寻值参数的数目必须与被索引字段的数目一致。如成功找到返回真，并且将当前记录指针移至所找到的记录。如出错或未找到则返回假，当前记录指针位置保持不变。

语法： 逻辑型 索引查找 （欲搜寻值，… ）

参数名 | 描 述
欲搜寻值 | 必需的；可扩充的；通用型。本参数数据的类型必须与索引字段表中对应位置处字段的类型一致。

示例：


查找

查找 命令 所属类别：数据库

本命令从当前数据库中当前记录位置处（包括当前记录）开始寻找符合给定条件的记录。如成功找到返回真，并且将当前记录指针移至所找到的记录。如出错或未找到则返回假，当前记录指针位置保持不变。

语法： 逻辑型 查找 （查找条件）

参数名 | 描 述
查找条件 | 必需的；条件语句型。参数值指定欲查找记录应该满足的条件。

示例：


到首记录

到首记录 命令 所属类别：数据库

将当前数据库中当前记录指针移动到数据库的第一条记录上。

语法： 无返回值 到首记录 （）

示例：


到尾记录

到尾记录 命令 所属类别：数据库

将当前数据库中当前记录指针移动到数据库的最后一条记录上。成功返回真，失败返回假。

语法： 逻辑型 到尾记录 （）

示例：


跳过

跳过 命令 所属类别：数据库

将当前数据库中当前记录指针向前或者向后移动数条记录。成功返回真，失败返回假。

语法： 逻辑型 跳过 （［欲跳过的记录数］）

参数名 | 描 述
欲跳过的记录数 | 可选的；整数型。参数值如果为负数，则向前移动，否则向后移动。如果本参数被省略，默认值为 1 ，即向后移动一条记录。

示例：


取记录号

取记录号 命令 所属类别：数据库

可以在记录范围参数语句中用作过滤每一条数据库记录；
返回当前数据库中当前记录指针所指向记录的记录号。如果当前记录指针在首记录前，返回 0 ；如果在尾记录后，返回值为记录总数加一。

语法： 整数型 取记录号 （）

示例：


跳到

跳到 命令 所属类别：数据库

改变当前数据库中的当前记录指针到指定的记录号。成功返回真，失败返回假。

语法： 逻辑型 跳到 （欲跳到的记录号）

参数名 | 描 述
欲跳到的记录号 | 必需的；整数型。参数值所指定的记录号从 1 开始，即首记录的记录号为 1 ，依此类推。

示例：


取标签

取标签 命令 所属类别：数据库

可以在记录范围参数语句中用作过滤每一条数据库记录；
在数据库的存在期间，同一数据库内任何时候任何一条记录（包括已经被实际删除的记录）都有一个唯一的非 0 正整数标签值，使用本命令可以取回当前数据库当前记录的这一标签值。此标签值可以用来在记录间跳转或者在多用户环境中查看记录是否已经被其它用户实际删除。如果命令执行失败，将返回 0 。

语法： 整数型 取标签 （）

示例：


记录是否存在

记录是否存在 命令 所属类别：数据库

如果当前数据库中存在具有指定标签值的记录，命令返回真，否则返回假。本命令可以用作在多用户环境中检查某记录是否被其它用户实际删除。

语法： 逻辑型 记录是否存在 （记录的标签值）

参数名 | 描 述
记录的标签值 | 必需的；整数型。

示例：


标签跳转

标签跳转 命令 所属类别：数据库

使用本命令可以改变当前数据库中的当前记录指针到具有指定标签的记录。如成功找到返回真，并且将当前记录指针移至该记录。如出错或未找到则返回假，当前记录指针位置保持不变。

语法： 逻辑型 标签跳转 （记录的标签值）

参数名 | 描 述
记录的标签值 | 必需的；整数型。

示例：


首记录前

首记录前 命令 所属类别：数据库

如果当前数据库的当前记录指针已在首记录的前面，返回真，否则返回假。

语法： 逻辑型 首记录前 （）

示例：


尾记录后

尾记录后 命令 所属类别：数据库

如果当前数据库的当前记录指针已在尾记录的后面，返回真，否则返回假。

语法： 逻辑型 尾记录后 （）

示例：


写出缓存

写出缓存 命令 所属类别：数据库

为了加快对数据库数据的存取速度，对数据库所进行的写操作将首先被保存在写缓存区内，等候一段时间后才会被自动写入到数据库文件中。使用本命令可以将当前数据库停留在写缓存区内的数据立即写入数据库磁盘文件中，以确保对当前数据库进行的所有写操作都真实地反映到了数据库文件中。一般情况下无需使用本命令。

语法： 无返回值 写出缓存 （）

示例：


写出所有缓存

写出所有缓存 命令 所属类别：数据库

将所有数据库停留在写缓存区内的数据都立即写入到对应的数据库磁盘文件中。一般情况下无需使用本命令。

语法： 无返回值 写出所有缓存 （）

示例：


编辑

编辑 命令 所属类别：数据库

提供一个对话框，用作查看或编辑修改当前数据库的记录，起始位置从当前记录开始。本命令退出后当前记录指针被移动到首记录。

语法： 无返回值 编辑 （［标题］，［编辑方式］，［字段范围］，… ）

参数名 | 描 述
标题 | 可选的；文本型。本参数指定对话框的标题，如果被省略，默认为“数据库记录编辑”。
编辑方式 | 可选的；整数型。可以为 0 或者以下常量值的组合： 1、#禁止修改； 2、#禁止添加； 4、#禁止删除； 8、#禁止自动判断（注：在默认情况下，系统将自动判断当前字节集字段的内容是否为图片或者声音，然后以对应的方式显示。使用本常量值可以禁止此功能）。 如果被省略，默认值为 0 。
字段范围 | 可选的；可扩充的；文本型，参数数据可以同时提供数组或非数组数据。本参数的各参数值顺序指定所有欲编辑字段的名称。如果被省略，默认为所有字段。

示例：


窗口

窗口 包容型窗口单元 跳至：系统核心支持库

本类型对象的方法被除开功能型外所有的窗口单元共享。

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
标题 | 边框 | 底色 | 底图
底图方式 | 背景音乐 | 播放次数 | 控制按钮
最大化按钮 | 最小化按钮 | 位置 | 可否移动
图标 | 回车下移焦点 | Esc键关闭 | F1键打开帮助
帮助文件名 | 帮助标志值 | 在任务条中显示 | 随意移动
外形 |  |  |

方法：

取窗口句柄 | 销毁 | 获取焦点 | 可有焦点
取用户区宽度 | 取用户区高度 | 禁止重画 | 允许重画
需全部重画 | 需部分重画 | 不需重画 | 刷新
移动 | 调整层次 | 弹出菜单 | 发送信息
投递信息 | 取标记单元 | 置外形图片 |

自有事件：

创建完毕 | 可否被关闭 | 将被销毁 | 位置被改变
尺寸被改变 | 被激活 | 被取消激活 | 空闲
首次激活 |  |  |

基本事件：


左边 (窗口)

左边 基本属性

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


顶边 (窗口)

顶边 基本属性

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


宽度 (窗口)

宽度 基本属性

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


高度 (窗口)

高度 基本属性

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


标记 (窗口)

标记 基本属性

数据类型：文本型；

示例：

参见： 示例的书写格式、基本数据类型


可视 (窗口)

可视 基本属性

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


禁止 (窗口)

禁止 基本属性

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


鼠标指针 (窗口)

鼠标指针 基本属性

数据类型：字节集；

示例：

参见： 示例的书写格式、基本数据类型


标题 (窗口)

标题 属性 所属对象：窗口

数据类型：文本型；本属性指定窗口的标题文本。

示例：

参见： 示例的书写格式、基本数据类型


边框 (窗口)

边框 属性 所属对象：窗口

数据类型：整数型；本属性指定窗口边框的类型。

可供选择的属性值：
0、无边框
1、普通可调边框
2、普通固定边框
3、窄标题可调边框
4、窄标题固定边框
5、镜框式可调边框
6、镜框式固定边框

示例：

参见： 示例的书写格式、基本数据类型


底色 (窗口)

底色 属性 所属对象：窗口

数据类型：整数型；本属性指定窗口背景的颜色。

示例：

参见： 示例的书写格式、基本数据类型


底图 (窗口)

底图 属性 所属对象：窗口

数据类型：字节集；本属性指定显示在窗口背景上的图片。

示例：

参见： 示例的书写格式、基本数据类型


底图方式 (窗口)

底图方式 属性 所属对象：窗口

数据类型：整数型；如果设定了底图，本属性指定窗口背景上底图的显示方式。

可供选择的属性值：
0、图片居左上
1、图片平铺
2、图片居中

示例：

参见： 示例的书写格式、基本数据类型


背景音乐 (窗口)

背景音乐 属性 所属对象：窗口

数据类型：字节集；本属性指定当窗口调入时自动开始播放的音乐。

示例：

参见： 示例的书写格式、基本数据类型


播放次数 (窗口)

播放次数 属性 所属对象：窗口

数据类型：整数型；本属性指定背景音乐的播放次数。

可供选择的属性值：
0、循环播放
1、仅播放一次
2、不播放

示例：

参见： 示例的书写格式、基本数据类型


控制按钮 (窗口)

控制按钮 属性 所属对象：窗口

数据类型：逻辑型；本属性设置是否显示窗口上的所有控制按钮及窗口控制菜单。

示例：

参见： 示例的书写格式、基本数据类型


最大化按钮 (窗口)

最大化按钮 属性 所属对象：窗口

数据类型：逻辑型；本属性设置是否显示窗口右上角的最大化或还原按钮。

示例：

参见： 示例的书写格式、基本数据类型


最小化按钮 (窗口)

最小化按钮 属性 所属对象：窗口

数据类型：逻辑型；本属性设置是否显示窗口右上角的最小化按钮。

示例：

参见： 示例的书写格式、基本数据类型


位置 (窗口)

位置 属性 所属对象：窗口

数据类型：整数型；本属性设置窗口的位置及状态。

可供选择的属性值：
0、通常
1、居中
2、最小化
3、最大化

示例：

参见： 示例的书写格式、基本数据类型


可否移动 (窗口)

可否移动 属性 所属对象：窗口

数据类型：逻辑型；本属性设置窗口位置能否被移动。

示例：

参见： 示例的书写格式、基本数据类型


图标 (窗口)

图标 属性 所属对象：窗口

数据类型：字节集；本属性设置窗口左上角所显示的图标。

示例：

参见： 示例的书写格式、基本数据类型


回车下移焦点 (窗口)

回车下移焦点 属性 所属对象：窗口

数据类型：逻辑型；本属性如果设置为真，运行时当用户在本窗口上按下回车键后，将自动将当前焦点转移到下一个单元。本属性如果设置为假，当用户在本窗口上按下回车键后，将等同于按下具有“默认”属性的按钮。

示例：

参见： 示例的书写格式、基本数据类型


Esc键关闭 (窗口)

Esc键关闭 属性 所属对象：窗口

数据类型：逻辑型；本属性设置运行时用户是否可以用 Esc 键关闭本窗口。

示例：

参见： 示例的书写格式、基本数据类型


F1键打开帮助 (窗口)

F1键打开帮助 属性 所属对象：窗口

数据类型：逻辑型；本属性设置运行时用户是否可以用 F1 键打开有关本窗口的帮助信息。

示例：

参见： 示例的书写格式、基本数据类型


帮助文件名 (窗口)

帮助文件名 属性 所属对象：窗口

数据类型：文本型；指定欲打开帮助文件的名称，如果没有指定帮助文件，将使用默认帮助文件名称，即本易程序的文件名称（不含其后缀）＋“.hlp”后缀。

示例：

参见： 示例的书写格式、基本数据类型


帮助标志值 (窗口)

帮助标志值 属性 所属对象：窗口

数据类型：整数型；用于在帮助文件中指定相应的帮助标志数值。本属性如果为零，则显示帮助主题。

示例：

参见： 示例的书写格式、基本数据类型


在任务条中显示 (窗口)

在任务条中显示 属性 所属对象：窗口

数据类型：逻辑型；设置本窗口是否出现在 Windows 系统的任务条中。

示例：

参见： 示例的书写格式、基本数据类型


随意移动 (窗口)

随意移动 属性 所属对象：窗口

数据类型：逻辑型；设置当用户在窗口上任何位置按下鼠标左键后是否进入窗口整体移动模式。

示例：

参见： 示例的书写格式、基本数据类型


外形 (窗口)

外形 属性 所属对象：窗口

数据类型：整数型；设置窗口的外形。

可供选择的属性值：
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、五边形箭头

示例：

参见： 示例的书写格式、基本数据类型


取窗口句柄 (窗口)

取窗口句柄 方法 所属对象：窗口

为高级用户提供，初级用户无需掌握；
取出本窗口或窗口单元的窗口句柄（即HWND），如本窗口或窗口单元尚未创建或已被销毁，则返回0。

语法： 整数型 窗口单元．取窗口句柄 （）

示例：


销毁 (窗口)

销毁 方法 所属对象：窗口

销毁本窗口或窗口单元。窗口被销毁后，所有在载入本窗口之后对本窗口及其内窗口单元所进行的修改或设置都将被抛弃。窗口被销毁后如想再次使用必须重新装载。

语法： 无返回值 窗口单元．销毁 （）

示例：


获取焦点 (窗口)

获取焦点 方法 所属对象：窗口

将焦点移动到窗口单元。如果对窗口使用本方法，窗口将自动把焦点转移到第一个有能力保留焦点的窗口单元上去。

语法： 无返回值 窗口单元．获取焦点 （）

示例：


可有焦点 (窗口)

可有焦点 方法 所属对象：窗口

如果当前窗口单元具有焦点，则返回真，否则返回假。

语法： 逻辑型 窗口单元．可有焦点 （）

示例：


取用户区宽度 (窗口)

取用户区宽度 方法 所属对象：窗口

返回窗口或窗口单元用户区域的宽度，单位为像素点。对窗口而言，用户区域为窗口区域减去标题栏、菜单栏、边框后的区域；对窗口单元而言，用户区域等同于其窗口单元区域。

语法： 整数型 窗口单元．取用户区宽度 （）

示例：


取用户区高度 (窗口)

取用户区高度 方法 所属对象：窗口

返回窗口或窗口单元用户区域的高度，单位为像素点。对窗口而言，用户区域为窗口区域减去标题栏、菜单栏、边框后的区域；对窗口单元而言，用户区域等同于其窗口单元区域。

语法： 整数型 窗口单元．取用户区高度 （）

示例：


禁止重画 (窗口)

禁止重画 方法 所属对象：窗口

禁止窗口或窗口单元重画，以避免当频繁进行操作时引起闪烁。注意调用本命令后必须调用“允许重画”命令进行恢复。

语法： 无返回值 窗口单元．禁止重画 （）

示例：


允许重画 (窗口)

允许重画 方法 所属对象：窗口

重新允许被禁止的窗口或窗口单元重画。

语法： 无返回值 窗口单元．允许重画 （）

示例：


需全部重画 (窗口)

需全部重画 方法 所属对象：窗口

通知 Windows 系统本窗口或窗口单元上的显示内容需要在以后被全部重画。

语法： 无返回值 窗口单元．需全部重画 （）

示例：


需部分重画 (窗口)

需部分重画 方法 所属对象：窗口

通知 Windows 系统本窗口或窗口单元上的显示内容需要在以后被部分重画。

语法： 无返回值 窗口单元．需部分重画 （欲重画区域的左边，欲重画区域的顶边，欲重画区域的宽度，欲重画区域的高度）

参数名 | 描 述
欲重画区域的左边 | 必需的；整数型。单位为像素点，相对于用户区域的左边。
欲重画区域的顶边 | 必需的；整数型。单位为像素点，相对于用户区域的顶边。
欲重画区域的宽度 | 必需的；整数型。单位为像素点。
欲重画区域的高度 | 必需的；整数型。单位为像素点。

示例：


不需重画 (窗口)

不需重画 方法 所属对象：窗口

通知 Windows 系统本窗口或窗口单元不再需要被重画，保留现有的全部显示内容。

语法： 无返回值 窗口单元．不需重画 （）

示例：


刷新 (窗口)

刷新 方法 所属对象：窗口

如果本窗口或窗口单元上的显示内容需要被全部或部分重画，则立即进行重画更新，否则不进行任何操作直接返回。

语法： 无返回值 窗口单元．刷新 （）

示例：


移动 (窗口)

移动 方法 所属对象：窗口

改变窗口或窗口单元的位置或尺寸。

语法： 无返回值 窗口单元．移动 （［左边］，［顶边］，［宽度］，［高度］）

参数名 | 描 述
左边 | 可选的；整数型。单位为像素点。如被省略或等于 -1 ，则不改变左边原位置。
顶边 | 可选的；整数型。单位为像素点。如被省略或等于 -1 ，则不改变顶边原位置。
宽度 | 可选的；整数型。单位为像素点。如被省略或等于 -1 ，则不改变原宽度。
高度 | 可选的；整数型。单位为像素点。如被省略或等于 -1 ，则不改变原高度。

示例：


调整层次 (窗口)

调整层次 方法 所属对象：窗口

改变窗口或窗口单元的现行所处层次。

语法： 无返回值 窗口单元．调整层次 （［欲调整到的层次］）

参数名 | 描 述
欲调整到的层次 | 可选的；整数型。可以为以下常量之一： 1、#顶层； 2、#底层； 3、#最高层； 4、#次高层。如果被省略，默认为“#顶层”。

示例：


弹出菜单 (窗口)

弹出菜单 方法 所属对象：窗口

用于在窗口上的当前鼠标位置或指定坐标位置显示弹出式菜单，如果调用对象为窗口单元，则自动使用其所在的窗口。

语法： 无返回值 窗口单元．弹出菜单 （欲弹出的菜单，［水平显示位置］，［垂直显示位置］）

参数名 | 描 述
欲弹出的菜单 | 必需的；菜单。指定菜单内必须包含有子菜单，且所处窗口必须与调用对象窗口一致。
水平显示位置 | 可选的；整数型。单位为像素点，相对于屏幕左边。如果被省略，将自动使用当前鼠标位置。
垂直显示位置 | 可选的；整数型。单位为像素点，相对于屏幕顶边。如果被省略，将自动使用当前鼠标位置。

示例：


发送信息 (窗口)

发送信息 方法 所属对象：窗口

将指定信息发送到窗口或窗口单元，并等待且取回信息反馈值。

语法： 整数型 窗口单元．发送信息 （信息值，参数1，参数2）

参数名 | 描 述
信息值 | 必需的；整数型。
参数1 | 必需的；整数型，初始值为“0”。
参数2 | 必需的；整数型，初始值为“0”。

示例：


投递信息 (窗口)

投递信息 方法 所属对象：窗口

将指定信息发送到窗口或窗口单元，不等待直接返回。

语法： 无返回值 窗口单元．投递信息 （信息值，参数1，参数2）

参数名 | 描 述
信息值 | 必需的；整数型。
参数1 | 必需的；整数型，初始值为“0”。
参数2 | 必需的；整数型，初始值为“0”。

示例：


取标记单元 (窗口)

取标记单元 方法 所属对象：窗口

返回当前窗口中具有指定标记数值文本的单元。如果不存在，将产生运行时错误。

语法： 通用型 窗口单元．取标记单元 （欲寻找单元的标记数值）

参数名 | 描 述
欲寻找单元的标记数值 | 必需的；整数型。即该单元的“标记”属性文本的数值形式。

示例：


置外形图片 (窗口)

置外形图片 方法 所属对象：窗口

使用图片来设置窗口的外形，注意图片类型不能为图标及鼠标指针。另外，图片的轮廓应该尽量简单，以免影响窗口的刷新速度。如果调用对象为窗口单元，将自动使用其所在的窗口。成功返回真，失败返回假。

语法： 逻辑型 窗口单元．置外形图片 （图片数据，［透明颜色］）

参数名 | 描 述
图片数据 | 必需的；通用型。参数值可以为 .JPG、.GIF、.BMP、.DIB 等等被支持格式的图片数据、图片资源或图片文件名。
透明颜色 | 可选的；整数型。指定图片中透明部分的颜色。如果被省略，默认为白色。

示例：


创建完毕 (窗口)

创建完毕 事件 所属对象：窗口

当窗口及其中的所有单元均被创建后在显示之前产生此事件，用户可以在响应此事件期间做一些初始化工作。本事件为该窗口的第一个事件。

语法： 无返回值 _窗口_创建完毕 （）

示例：


可否被关闭 (窗口)

可否被关闭 事件 所属对象：窗口

在窗口被关闭之前产生此事件，用于询问窗口可否被关闭。如果返回假则不允许窗口被关闭，返回真或不返回值允许关闭。

语法： 逻辑型 _窗口_可否被关闭 （）

示例：


将被销毁 (窗口)

将被销毁 事件 所属对象：窗口

当窗口将被销毁前产生此事件。窗口被销毁后所有对此窗口及其内部单元的修改都将被作废。

语法： 无返回值 _窗口_将被销毁 （）

示例：


位置被改变 (窗口)

位置被改变 事件 所属对象：窗口

当窗口的位置被改变时产生此事件。

语法： 无返回值 _窗口_位置被改变 （）

示例：


尺寸被改变 (窗口)

尺寸被改变 事件 所属对象：窗口

当窗口的尺寸被改变后产生此事件。

语法： 无返回值 _窗口_尺寸被改变 （）

示例：


被激活 (窗口)

被激活 事件 所属对象：窗口

当窗口转换为激活状态时产生此事件。

语法： 无返回值 _窗口_被激活 （）

示例：


被取消激活 (窗口)

被取消激活 事件 所属对象：窗口

当窗口转换为非激活状态时产生此事件。

语法： 无返回值 _窗口_被取消激活 （）

示例：


空闲 (窗口)

空闲 事件 所属对象：窗口

当系统正处于空闲状态时产生此事件，用户可以在响应此事件时做一些后台处理工作。如果事件处理子程序返回假或者不返回值，在此次空闲期间系统将不再产生空闲事件（可以降低 CPU 占用率）。如果返回真，系统将继续产生空闲事件。

语法： 逻辑型 _窗口_空闲 （已空闲时间）

参数名 | 描 述
已空闲时间 | 整数型；指示自系统本次进入空闲状态后到现在所经过的空闲时间，单位为毫秒。用户程序在空闲状态下所进行的大工作量操作最好等到此值较大时进行。

示例：


首次激活 (窗口)

首次激活 事件 所属对象：窗口

当窗口创建完毕后被首次激活显示时产生此事件，在此事件及此事件后用户可以开始在窗口内的画板单元上写出内容。

语法： 无返回值 _窗口_首次激活 （）

示例：


编辑框

编辑框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
内容 | 边框 | 文本颜色 | 背景颜色
字体 | 隐藏选择 | 最大允许长度 | 是否允许多行
滚动条 | 对齐方式 | 输入方式 | 密码遮盖字符
转换方式 | 调节器方式 | 调节器底限值 | 调节器上限值
起始选择位置 | 被选择字符数 | 被选择文本 |

方法：

加入文本

自有事件：

内容被改变 调节钮被按下

基本事件：


内容 (编辑框)

内容 属性 所属对象：编辑框

数据类型：文本型；

示例：

参见： 示例的书写格式、基本数据类型


边框 (编辑框)

边框 属性 所属对象：编辑框

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (编辑框)

文本颜色 属性 所属对象：编辑框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (编辑框)

背景颜色 属性 所属对象：编辑框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (编辑框)

字体 属性 所属对象：编辑框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


隐藏选择 (编辑框)

隐藏选择 属性 所属对象：编辑框

数据类型：逻辑型；本属性指定失去输入焦点后是否还显示当前被选择的区域。

示例：

参见： 示例的书写格式、基本数据类型


最大允许长度 (编辑框)

最大允许长度 属性 所属对象：编辑框

数据类型：整数型；本属性设置最大允许输入到本单元中的字符数目，如为0则输入字符数目不受限制。

示例：

参见： 示例的书写格式、基本数据类型


是否允许多行 (编辑框)

是否允许多行 属性 所属对象：编辑框

数据类型：逻辑型；本属性设置本单元是否允许输入多行文本。

示例：

参见： 示例的书写格式、基本数据类型


滚动条 (编辑框)

滚动条 属性 所属对象：编辑框

数据类型：整数型；滚动条只有在多行方式下才有效。

可供选择的属性值：
0、无
1、横向滚动条
2、纵向滚动条
3、横向及纵向滚动条

示例：

参见： 示例的书写格式、基本数据类型


对齐方式 (编辑框)

对齐方式 属性 所属对象：编辑框

数据类型：整数型；

可供选择的属性值：
0、左对齐
1、居中
2、右对齐

示例：

参见： 示例的书写格式、基本数据类型


输入方式 (编辑框)

输入方式 属性 所属对象：编辑框

数据类型：整数型；

可供选择的属性值：
0、通常方式
1、只读方式
2、密码输入
3、整数文本输入
4、小数文本输入
5、输入字节
6、输入短整数
7、输入整数
8、输入长整数
9、输入小数
10、输入双精度小数
11、输入日期时间

示例：

参见： 示例的书写格式、基本数据类型


密码遮盖字符 (编辑框)

密码遮盖字符 属性 所属对象：编辑框

数据类型：文本型；本属性设置当输入方式为“密码输入”时输入字符后显示在输入框中的替代字符。

示例：

参见： 示例的书写格式、基本数据类型


转换方式 (编辑框)

转换方式 属性 所属对象：编辑框

数据类型：整数型；

可供选择的属性值：
0、无
1、大写->小写
2、小写->大写

示例：

参见： 示例的书写格式、基本数据类型


调节器方式 (编辑框)

调节器方式 属性 所属对象：编辑框

数据类型：整数型；调节器只有在单行方式下才有效。

可供选择的属性值：
0、无调节器
1、自动调节器
2、手动调节器

示例：

参见： 示例的书写格式、基本数据类型


调节器底限值 (编辑框)

调节器底限值 属性 所属对象：编辑框

数据类型：整数型；只有在自动调节器方式下才有效。

示例：

参见： 示例的书写格式、基本数据类型


调节器上限值 (编辑框)

调节器上限值 属性 所属对象：编辑框

数据类型：整数型；只有在自动调节器方式下才有效。

示例：

参见： 示例的书写格式、基本数据类型


起始选择位置 (编辑框)

起始选择位置 属性 所属对象：编辑框

数据类型：整数型；返回或设置所选择文本的起始点；0 为位置 1 ，1 为位置 2，如此类推。如果没有文本被选中，则指出光标位置。如果设置位置时使用值 -1，则将当前光标位置移动到文本尾部。当类型为“不可编辑下拉式”时，本属性无效。

示例：

参见： 示例的书写格式、基本数据类型


被选择字符数 (编辑框)

被选择字符数 属性 所属对象：编辑框

数据类型：整数型；返回或设置所选择的字符数。如果设置字符数时使用值 -1，则选择文本框内的所有字符。

示例：

参见： 示例的书写格式、基本数据类型


被选择文本 (编辑框)

被选择文本 属性 所属对象：编辑框

数据类型：文本型；设计时不可用；返回或替换当前所选择的文本。

示例：

参见： 示例的书写格式、基本数据类型


加入文本 (编辑框)

加入文本 方法 所属对象：编辑框

将指定文本加入到编辑框内容的尾部。

语法： 无返回值 编辑框．加入文本 （欲加入文本，… ）

参数名 | 描 述
欲加入文本 | 必需的；可扩充的；文本型。

示例：


内容被改变 (编辑框)

内容被改变 事件 所属对象：编辑框

当编辑框的内容被修改后即产生此事件。

语法： 无返回值 _编辑框_内容被改变 （）

示例：


调节钮被按下 (编辑框)

调节钮被按下 事件 所属对象：编辑框

只有调节器方式为“手动调节器”时才会产生此事件。

语法： 无返回值 _编辑框_调节钮被按下 （按钮值）

参数名 | 描 述
按钮值 | 整数型；如果按下的是调节器的向上箭头按钮，参数值为 1，否则为 -1。

示例：


图片框

图片框 包容型窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
边框 | 背景颜色 | 图片 | 显示方式
播放动画 |  |  |

基本事件：


边框 (图片框)

边框 属性 所属对象：图片框

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (图片框)

背景颜色 属性 所属对象：图片框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


图片 (图片框)

图片 属性 所属对象：图片框

数据类型：字节集；本属性指定显示在图片框上的图片。

示例：

参见： 示例的书写格式、基本数据类型


显示方式 (图片框)

显示方式 属性 所属对象：图片框

数据类型：整数型；如果设定了图片，本属性指定图片框上图片的显示方式。

可供选择的属性值：
0、图片居左上
1、缩放图片
2、图片居中

示例：

参见： 示例的书写格式、基本数据类型


播放动画 (图片框)

播放动画 属性 所属对象：图片框

数据类型：逻辑型；当图片为 GIF 动画格式时，通过改变此属性可控制其播放或停止。如在设计时置本属性为真，运行时动画在图片框被创建后即自动开始播放。

示例：

参见： 示例的书写格式、基本数据类型


外形框

外形框 包容型窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
背景颜色 | 外形 | 线条效果 | 线型
线宽 | 线条颜色 | 填充颜色 |

基本事件：


背景颜色 (外形框)

背景颜色 属性 所属对象：外形框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


外形 (外形框)

外形 属性 所属对象：外形框

数据类型：整数型；

可供选择的属性值：
0、矩形
1、正方形
2、椭圆
3、圆
4、圆角矩形
5、圆角正方形
6、横向线
7、纵向线

示例：

参见： 示例的书写格式、基本数据类型


线条效果 (外形框)

线条效果 属性 所属对象：外形框

数据类型：整数型；

可供选择的属性值：
0、通常
1、凹入
2、凸出

示例：

参见： 示例的书写格式、基本数据类型


线型 (外形框)

线型 属性 所属对象：外形框

数据类型：整数型；

可供选择的属性值：
0、无
1、直线
2、划线
3、点线
4、点划线
5、双点划线

示例：

参见： 示例的书写格式、基本数据类型


线宽 (外形框)

线宽 属性 所属对象：外形框

数据类型：整数型；注意：仅在线条效果为“通常”且线型为“直线”时才有效。

示例：

参见： 示例的书写格式、基本数据类型


线条颜色 (外形框)

线条颜色 属性 所属对象：外形框

数据类型：整数型；注意：仅在线条效果为“通常”时才有效。

示例：

参见： 示例的书写格式、基本数据类型


填充颜色 (外形框)

填充颜色 属性 所属对象：外形框

数据类型：整数型；注意：仅在外形不为线条时才有效。

示例：

参见： 示例的书写格式、基本数据类型


画板

画板 包容型窗口单元 跳至：系统核心支持库

默认不接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
边框 | 画板背景色 | 底图 | 底图方式
自动重画 | 绘画单位 | 画笔类型 | 画出方式
画笔粗细 | 画笔颜色 | 刷子类型 | 刷子颜色
文本颜色 | 文本背景颜色 | 字体 | 画板宽度
画板高度 |  |  |

方法：

取设备句柄 | 清除 | 取点 | 画点
画直线 | 画椭圆 | 画弧线 | 画弦
画饼 | 画矩形 | 画渐变矩形 | 填充矩形
画圆角矩形 | 翻转矩形区 | 画多边形 | 置写出位置
写文本行 | 滚动写行 | 写出 | 定位写出
取宽度 | 取高度 | 画图片 | 取图片宽度
取图片高度 | 复制 |  |

自有事件：

绘画

基本事件：


边框 (画板)

边框 属性 所属对象：画板

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


画板背景色 (画板)

画板背景色 属性 所属对象：画板

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


底图 (画板)

底图 属性 所属对象：画板

数据类型：字节集；本属性指定显示在画板背景上的图片。

示例：

参见： 示例的书写格式、基本数据类型


底图方式 (画板)

底图方式 属性 所属对象：画板

数据类型：整数型；如果设定了底图，本属性指定画板背景上底图的显示方式。

可供选择的属性值：
0、图片居左上
1、图片平铺
2、图片居中

示例：

参见： 示例的书写格式、基本数据类型


自动重画 (画板)

自动重画 属性 所属对象：画板

数据类型：逻辑型；如果本属性设置为真，系统将自动把所有在画板上进行的绘画操作的结果保存到内存中，当以后需要重画时，系统简单地把所保存的绘画结果复制到画板上，而不再产生“绘画”事件。采用本属性需要消耗一定数量的内存。

示例：

参见： 示例的书写格式、基本数据类型


绘画单位 (画板)

绘画单位 属性 所属对象：画板

数据类型：整数型；本属性指定绘画时所使用的单位，坐标系的 X 轴从左到右，Y 轴从上到下。

可供选择的属性值：
0、像素点
1、0.1毫米
2、0.01毫米
3、0.01英寸
4、0.001英寸
5、1/1440英寸

示例：

参见： 示例的书写格式、基本数据类型


画笔类型 (画板)

画笔类型 属性 所属对象：画板

数据类型：整数型；

可供选择的属性值：
0、空笔
1、直线
2、划线
3、点线
4、点划线
5、双点划线
6、内直线

示例：

参见： 示例的书写格式、基本数据类型


画出方式 (画板)

画出方式 属性 所属对象：画板

数据类型：整数型；有关各种画出方式的说明为： 0、黑色：始终画出黑色；1、非或笔：或笔的相反；2、与非笔：背景色以及画笔反相二者共有颜色的组合；3、非复制笔：复制笔的相反；4、与笔非：画笔以及已有颜色反相二者共有颜色的组合；5、反转：已有颜色的反相；6、异或笔：画笔的颜色以及已有颜色的组合，只取其一；7、非与笔：与笔的相反；8、与笔：画笔和已有二者共有颜色的组合；9、非异或笔：异或笔的相反；10、无操作：原有保持不变。该设置实际上关闭画笔；11、或非笔：已有颜色与画笔颜色反相的组合；12、复制笔（缺省值）：画笔颜色；13、或笔非：画笔颜色与已有颜色的反相的组合；14、或笔：画笔颜色与已有颜色的组合；15、白色：始终画出白色。

可供选择的属性值：
0、黑色
1、非或笔
2、与非笔
3、非复制笔
4、与笔非
5、反转
6、异或笔
7、非与笔
8、与笔
9、非异或笔
10、无操作
11、或非笔
12、复制笔
13、或笔非
14、或笔
15、白色

示例：

参见： 示例的书写格式、基本数据类型


画笔粗细 (画板)

画笔粗细 属性 所属对象：画板

数据类型：整数型；使用现行绘画单位，如果为0，表示画笔的粗细为一个像素点。注意：当画笔类型为划线、点线、点划线、双点划线时，本属性无效，画笔宽度始终为一个像素点。

示例：

参见： 示例的书写格式、基本数据类型


画笔颜色 (画板)

画笔颜色 属性 所属对象：画板

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


刷子类型 (画板)

刷子类型 属性 所属对象：画板

数据类型：整数型；各种格式刷子将使用当前文本背景颜色作为刷子背景颜色。

可供选择的属性值：
0、空刷子
1、颜色刷子
2、右斜线
3、直交叉线
4、斜交叉线
5、左斜线
6、横线
7、竖线
8、5%色点
9、10%色点
10、20%色点
11、25%色点
12、30%色点
13、40%色点
14、50%色点
15、60%色点
16、70%色点
17、75%色点
18、80%色点
19、90%色点
20、浅色上对角线
21、浅色下对角线
22、深色上对角线
23、深色下对角线
24、宽上对角线
25、宽下对角线
26、浅色竖线
27、浅色横线
28、窄竖线
29、窄横线
30、深色竖线
31、深色横线
32、上对角虚线
33、下对角虚线
34、横虚线
35、竖虚线
36、小纸屑
37、大纸屑
38、之字形
39、波浪线
40、对角砖形
41、横向砖形
42、纺织物
43、方格呢
44、草皮
45、虚格线
46、点式菱形
47、瓦形
48、棚架
49、球体
50、小网格
51、大网格
52、小棋盘
53、大棋盘
54、空心菱形
55、实心菱形

示例：

参见： 示例的书写格式、基本数据类型


刷子颜色 (画板)

刷子颜色 属性 所属对象：画板

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (画板)

文本颜色 属性 所属对象：画板

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


文本背景颜色 (画板)

文本背景颜色 属性 所属对象：画板

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (画板)

字体 属性 所属对象：画板

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


画板宽度 (画板)

画板宽度 属性 所属对象：画板

数据类型：整数型；只读；本属性提供了目前画板的宽度，使用现行绘画单位。属性值等于“画板”窗口单元的用户区域宽度。

示例：

参见： 示例的书写格式、基本数据类型


画板高度 (画板)

画板高度 属性 所属对象：画板

数据类型：整数型；只读；本属性提供了目前画板的高度，使用现行绘画单位。属性值等于“画板”窗口单元的用户区域高度。

示例：

参见： 示例的书写格式、基本数据类型


取设备句柄 (画板)

取设备句柄 方法 所属对象：画板

为高级用户提供，初级用户无需掌握；
如当前用户程序正在处理本画板所产生的“绘画”事件，则返回画板所对应的设备句柄（即HDC），否则返回 0。

语法： 整数型 画板．取设备句柄 （）

示例：


清除 (画板)

清除 方法 所属对象：画板

清除画板上指定区域的内容并将当前文本写出位置移动到被清除区左上角。

语法： 无返回值 画板．清除 （［清除区左上角横坐标］，［清除区左上角纵坐标］，［清除区宽度］，［清除区高度］）

参数名 | 描 述
清除区左上角横坐标 | 可选的；整数型。使用当前绘画单位，相对于画板左上角。如果被省略，默认为 0 。
清除区左上角纵坐标 | 可选的；整数型。使用当前绘画单位，相对于画板左上角。如果被省略，默认为 0 。
清除区宽度 | 可选的；整数型。使用当前绘画单位。如果被省略，默认为清除区左边到画板右边之间的宽度。
清除区高度 | 可选的；整数型。使用当前绘画单位。如果被省略，默认为清除区顶边到画板底边之间的高度。

示例：


取点 (画板)

取点 方法 所属对象：画板

返回画板上指定点的颜色值。如果失败，将返回 -1。

语法： 整数型 画板．取点 （点横坐标，点纵坐标）

参数名 | 描 述
点横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
点纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画点 (画板)

画点 方法 所属对象：画板

语法： 无返回值 画板．画点 （点横坐标，点纵坐标，欲画入点的颜色值）

参数名 | 描 述
点横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
点纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
欲画入点的颜色值 | 必需的；整数型。

示例：


画直线 (画板)

画直线 方法 所属对象：画板

使用画笔在画板上画出一条直线。

语法： 无返回值 画板．画直线 （起始点横坐标，起始点纵坐标，结束点横坐标，结束点纵坐标）

参数名 | 描 述
起始点横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
起始点纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
结束点横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
结束点纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画椭圆 (画板)

画椭圆 方法 所属对象：画板

语法： 无返回值 画板．画椭圆 （椭圆左上角横坐标，椭圆左上角纵坐标，椭圆右下角横坐标，椭圆右下角纵坐标）

参数名 | 描 述
椭圆左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画弧线 (画板)

画弧线 方法 所属对象：画板

使用画笔在画板上画出一条弧线。

语法： 无返回值 画板．画弧线 （椭圆左上角横坐标，椭圆左上角纵坐标，椭圆右下角横坐标，椭圆右下角纵坐标，弧线起始点横坐标，弧线起始点纵坐标，弧线终止点横坐标，弧线终止点纵坐标）

参数名 | 描 述
椭圆左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点横坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点纵坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点横坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点纵坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画弦 (画板)

画弦 方法 所属对象：画板

语法： 无返回值 画板．画弦 （椭圆左上角横坐标，椭圆左上角纵坐标，椭圆右下角横坐标，椭圆右下角纵坐标，弧线起始点横坐标，弧线起始点纵坐标，弧线终止点横坐标，弧线终止点纵坐标）

参数名 | 描 述
椭圆左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点横坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点纵坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点横坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点纵坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画饼 (画板)

画饼 方法 所属对象：画板

语法： 无返回值 画板．画饼 （椭圆左上角横坐标，椭圆左上角纵坐标，椭圆右下角横坐标，椭圆右下角纵坐标，弧线起始点横坐标，弧线起始点纵坐标，弧线终止点横坐标，弧线终止点纵坐标）

参数名 | 描 述
椭圆左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点横坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点纵坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点横坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点纵坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画矩形 (画板)

画矩形 方法 所属对象：画板

使用画笔在画板上画出一个矩形，矩形的内部使用刷子填充。

语法： 无返回值 画板．画矩形 （矩形左上角横坐标，矩形左上角纵坐标，矩形右下角横坐标，矩形右下角纵坐标）

参数名 | 描 述
矩形左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画渐变矩形 (画板)

画渐变矩形 方法 所属对象：画板

语法： 无返回值 画板．画渐变矩形 （矩形区域左边，矩形区域顶边，矩形区域宽度，矩形区域高度，［渐变方向］，首渐变颜色，其它渐变颜色，… ）

参数名 | 描 述
矩形区域左边 | 必需的；整数型。
矩形区域顶边 | 必需的；整数型。
矩形区域宽度 | 必需的；整数型。
矩形区域高度 | 必需的；整数型。
渐变方向 | 可选的；整数型。参数值可以为以下常量值之一： 1、#从上到下； 2、#从左到右； 3、从左上到右下； 4、从右上到左下； 5、从下到上； 6、从右到左； 7、从右下到左上； 8、从左下到右上。 如果本参数被省略，默认为“#从左到右”。
首渐变颜色 | 必需的；整数型。
其它渐变颜色 | 必需的；可扩充的；整数型。

示例：


填充矩形 (画板)

填充矩形 方法 所属对象：画板

将画板上指定的矩形区域用当前刷子填充。

语法： 无返回值 画板．填充矩形 （矩形左上角横坐标，矩形左上角纵坐标，矩形右下角横坐标，矩形右下角纵坐标）

参数名 | 描 述
矩形左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画圆角矩形 (画板)

画圆角矩形 方法 所属对象：画板

使用画笔在画板上画出一个圆角矩形，圆角矩形的内部使用刷子填充。

语法： 无返回值 画板．画圆角矩形 （矩形左上角横坐标，矩形左上角纵坐标，矩形右下角横坐标，矩形右下角纵坐标，圆角宽度，［圆角高度］）

参数名 | 描 述
矩形左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
圆角宽度 | 必需的；整数型。使用当前绘画单位。
圆角高度 | 可选的；整数型。使用当前绘画单位。如果省略本参数，默认与圆角宽度相等。

示例：


翻转矩形区 (画板)

翻转矩形区 方法 所属对象：画板

将画板上指定矩形区域的颜色翻转过来。

语法： 无返回值 画板．翻转矩形区 （矩形左上角横坐标，矩形左上角纵坐标，矩形右下角横坐标，矩形右下角纵坐标）

参数名 | 描 述
矩形左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画多边形 (画板)

画多边形 方法 所属对象：画板

如果所画的多边形没有闭合，将自动闭合。

语法： 无返回值 画板．画多边形 （多边形顶点，［顶点数目］）

参数名 | 描 述
多边形顶点 | 必需的；整数型，参数数据只能提供数组数据。本参数数组顺序记录多边形各顶点的横向及纵向坐标值。使用当前绘画单位，相对于画板或打印纸左上角。
顶点数目 | 可选的；整数型。本参数指定多边形顶点的总数目。如果被省略，默认为数组中所记录的顶点数目。

示例：


置写出位置 (画板)

置写出位置 方法 所属对象：画板

设置下次使用“写文本行”或“写出”命令输出数据时的位置。

语法： 无返回值 画板．置写出位置 （［横向写出位置］，［纵向写出位置］）

参数名 | 描 述
横向写出位置 | 可选的；整数型。如果本参数被省略，则使用现行横向写出位置。使用当前绘画单位，相对于画板或打印纸左上角。
纵向写出位置 | 可选的；整数型。如果本参数被省略，则使用现行纵向写出位置。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


写文本行 (画板)

写文本行 方法 所属对象：画板

在当前写出位置写出指定的文本、数值、逻辑值或日期时间，并将现行写出位置调整到下行行首。

语法： 无返回值 画板．写文本行 （［欲写出数据］，… ）

参数名 | 描 述
欲写出数据 | 可选的；可扩充的；通用型。参数值只能为文本、数值、逻辑值或日期时间。如果本参数被省略，则写出一个空行。

示例：


滚动写行 (画板)

滚动写行 方法 所属对象：画板

在当前写出位置写出指定的文本、数值、逻辑值或日期时间，并将现行写出位置调整到下行行首。如果现行画板高度无法容纳当前所要写出的行，则自动向上滚动画板内容。

语法： 无返回值 画板．滚动写行 （［欲写出数据］，… ）

参数名 | 描 述
欲写出数据 | 可选的；可扩充的；通用型。参数值只能为文本、数值、逻辑值或日期时间。如果本参数被省略，则写出一个空行。

示例：


写出 (画板)

写出 方法 所属对象：画板

在当前写出位置处写出指定的文本、数值、逻辑值或日期时间。自动调整现行写出位置到所写出数据的末位置。

语法： 无返回值 画板．写出 （［欲写出数据］，… ）

参数名 | 描 述
欲写出数据 | 可选的；可扩充的；通用型。参数值只能为文本、数值、逻辑值或日期时间。如果本参数被省略，则写出一个空行。

示例：


定位写出 (画板)

定位写出 方法 所属对象：画板

在指定写出位置处写出指定的文本、数值、逻辑值或日期时间，不改变现行写出位置。

语法： 无返回值 画板．定位写出 （［横向写出位置］，［纵向写出位置］，欲写出数据，… ）

参数名 | 描 述
横向写出位置 | 可选的；整数型。如果本参数被省略，则使用现行横向写出位置。使用当前绘画单位，相对于画板或打印纸左上角。
纵向写出位置 | 可选的；整数型。如果本参数被省略，则使用现行纵向写出位置。使用当前绘画单位，相对于画板或打印纸左上角。
欲写出数据 | 必需的；可扩充的；通用型。参数值只能为文本、数值、逻辑值或日期时间。

示例：


取宽度 (画板)

取宽度 方法 所属对象：画板

返回指定数据的写出宽度，使用当前绘画单位。

语法： 整数型 画板．取宽度 （欲取其宽度或高度的数据）

参数名 | 描 述
欲取其宽度或高度的数据 | 必需的；通用型。参数值只能为文本、数值、逻辑值或日期时间。

示例：


取高度 (画板)

取高度 方法 所属对象：画板

返回指定数据的写出高度，使用当前绘画单位。

语法： 整数型 画板．取高度 （欲取其宽度或高度的数据）

参数名 | 描 述
欲取其宽度或高度的数据 | 必需的；通用型。参数值只能为文本、数值、逻辑值或日期时间。

示例：


画图片 (画板)

画图片 方法 所属对象：画板

语法： 无返回值 画板．画图片 （图片号，图片左边画出位置，图片顶边画出位置，［图片画出宽度］，［图片画出高度］，［图片画出方法］）

参数名 | 描 述
图片号 | 必需的；整数型。参数值必须为调用“载入图片”命令所返回的图片号。
图片左边画出位置 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
图片顶边画出位置 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
图片画出宽度 | 可选的；整数型。如果本参数被省略，则使用图片本身的宽度。使用当前绘画单位。
图片画出高度 | 可选的；整数型。如果本参数被省略，则使用图片本身的高度。使用当前绘画单位。
图片画出方法 | 可选的；整数型。本参数定义在将图像绘制到对象（画板 / 打印机）上时对图像执行的位操作。对“图标”类型图片无效。可以为以下常量值之一或者其它自定义操作码： 1、#拷贝； 2、#翻转拷贝； 3、#位异或； 4、#位或； 5、#位与 如果省略本参数，默认为“#拷贝”。

示例：


取图片宽度 (画板)

取图片宽度 方法 所属对象：画板

返回指定图片的宽度，使用当前绘画单位。

语法： 整数型 画板．取图片宽度 （图片号）

参数名 | 描 述
图片号 | 必需的；整数型。参数值必须为调用“载入图片”命令所返回的图片号。

示例：


取图片高度 (画板)

取图片高度 方法 所属对象：画板

返回指定图片的高度，使用当前绘画单位。

语法： 整数型 画板．取图片高度 （图片号）

参数名 | 描 述
图片号 | 必需的；整数型。参数值必须为调用“载入图片”命令所返回的图片号。

示例：


复制 (画板)

复制 方法 所属对象：画板

将源画板（本命令的调用画板对象）中指定区域的内容快速复制到目的画板中的指定位置，使用源和目的画板各自的当前绘画单位。如果源画板当前不可视，其“自动重画”属性必须为真。

语法： 无返回值 画板．复制 （［欲复制区域的左边］，［欲复制区域的顶边］，［欲复制区域的宽度］，［欲复制区域的高度］，［复制到的目的画板］，［欲复制到位置左边］，［欲复制到位置顶边］，［复制方法］）

参数名 | 描 述
欲复制区域的左边 | 可选的；整数型。如果本参数被省略，默认值为 0 。使用源画板的当前绘画单位。
欲复制区域的顶边 | 可选的；整数型。如果本参数被省略，默认值为 0 。使用源画板的当前绘画单位。
欲复制区域的宽度 | 可选的；整数型。如果本参数被省略，默认等同于源画板的宽度。使用源画板的当前绘画单位。
欲复制区域的高度 | 可选的；整数型。如果本参数被省略，默认等同于源画板的高度。使用源画板的当前绘画单位。
复制到的目的画板 | 可选的；画板。如果本参数被省略，默认为复制到源画板对象。
欲复制到位置左边 | 可选的；整数型。如果本参数被省略，默认值为 0 。使用目的画板的当前绘画单位。
欲复制到位置顶边 | 可选的；整数型。如果本参数被省略，默认值为 0 。使用目的画板的当前绘画单位。
复制方法 | 可选的；整数型。本参数定义在将画板内容复制到目的画板上时对图像执行的位操作。可以为以下常量值之一或者其它自定义操作码： 1、#拷贝； 2、#翻转拷贝； 3、#位异或； 4、#位或； 5、#位与。 如果省略本参数，默认为“#拷贝”。

示例：


绘画 (画板)

绘画 事件 所属对象：画板

当画板中的全部或一部分区域需要被重新绘制时即产生此事件。用户程序在响应此事件期间在画板上所进行的任何绘制操作均被限制在“需重画区”参数所指定的区域内。

语法： 无返回值 _画板_绘画 （重画区左边，重画区上边，重画区右边，重画区下边）

参数名 | 描 述
重画区左边 | 整数型；本参数提供目前画板中需要更新的矩形区域的左边，使用现行绘画单位，用作提高绘画速度，一般情况下可以不处理。
重画区上边 | 整数型；本参数提供目前画板中需要更新的矩形区域的顶边，使用现行绘画单位，用作提高绘画速度，一般情况下可以不处理。
重画区右边 | 整数型；本参数提供目前画板中需要更新的矩形区域的右边，使用现行绘画单位，用作提高绘画速度，一般情况下可以不处理。
重画区下边 | 整数型；本参数提供目前画板中需要更新的矩形区域的底边，使用现行绘画单位，用作提高绘画速度，一般情况下可以不处理。

示例：


分组框

分组框 包容型窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
标题 | 对齐方式 | 文本颜色 | 背景颜色
字体 |  |  |

基本事件：


标题 (分组框)

标题 属性 所属对象：分组框

数据类型：文本型；如果希望某一字符成为本分组框中第一个可停留焦点单元的访问键，可以在该字符前面加上一个 & 字符。

示例：

参见： 示例的书写格式、基本数据类型


对齐方式 (分组框)

对齐方式 属性 所属对象：分组框

数据类型：整数型；

可供选择的属性值：
0、左边
1、居中
2、右边

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (分组框)

文本颜色 属性 所属对象：分组框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (分组框)

背景颜色 属性 所属对象：分组框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (分组框)

字体 属性 所属对象：分组框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


标签

标签 窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
标题 | 效果 | 边框 | 渐变边框宽度
渐变边框颜色1 | 渐变边框颜色2 | 渐变边框颜色3 | 字体
文本颜色 | 背景颜色 | 底图 | 底图方式
渐变背景方式 | 渐变背景颜色1 | 渐变背景颜色2 | 渐变背景颜色3
横向对齐方式 | 是否自动折行 | 纵向对齐方式 |

基本事件：


标题 (标签)

标题 属性 所属对象：标签

数据类型：文本型；如果希望某一字符成为本标签后可停留焦点单元的访问键，可以在该字符前面加上一个 & 字符。

示例：

参见： 示例的书写格式、基本数据类型


效果 (标签)

效果 属性 所属对象：标签

数据类型：整数型；

可供选择的属性值：
0、通常
1、凹入
2、凸出
3、阴影

示例：

参见： 示例的书写格式、基本数据类型


边框 (标签)

边框 属性 所属对象：标签

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式
6、渐变镜框式

示例：

参见： 示例的书写格式、基本数据类型


渐变边框宽度 (标签)

渐变边框宽度 属性 所属对象：标签

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


渐变边框颜色1 (标签)

渐变边框颜色1 属性 所属对象：标签

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


渐变边框颜色2 (标签)

渐变边框颜色2 属性 所属对象：标签

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


渐变边框颜色3 (标签)

渐变边框颜色3 属性 所属对象：标签

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (标签)

字体 属性 所属对象：标签

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (标签)

文本颜色 属性 所属对象：标签

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (标签)

背景颜色 属性 所属对象：标签

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


底图 (标签)

底图 属性 所属对象：标签

数据类型：字节集；本属性指定显示在标签背景上的图片。

示例：

参见： 示例的书写格式、基本数据类型


底图方式 (标签)

底图方式 属性 所属对象：标签

数据类型：整数型；如果设定了底图，本属性指定标签背景上底图的显示方式。

可供选择的属性值：
0、图片居左上
1、图片平铺
2、图片居中

示例：

参见： 示例的书写格式、基本数据类型


渐变背景方式 (标签)

渐变背景方式 属性 所属对象：标签

数据类型：整数型；本属性只有在未设定底图的前提下才有效。

可供选择的属性值：
0、无渐变背景
1、从上到下
2、从左到右
3、从左上到右下
4、从右上到左下
5、从下到上
6、从右到左
7、从右下到左上
8、从左下到右上

示例：

参见： 示例的书写格式、基本数据类型


渐变背景颜色1 (标签)

渐变背景颜色1 属性 所属对象：标签

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


渐变背景颜色2 (标签)

渐变背景颜色2 属性 所属对象：标签

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


渐变背景颜色3 (标签)

渐变背景颜色3 属性 所属对象：标签

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


横向对齐方式 (标签)

横向对齐方式 属性 所属对象：标签

数据类型：整数型；

可供选择的属性值：
0、左对齐
1、居中
2、右对齐

示例：

参见： 示例的书写格式、基本数据类型


是否自动折行 (标签)

是否自动折行 属性 所属对象：标签

数据类型：逻辑型；本属性设定当文本内容超出右界后是否自动转到下一行显示。

示例：

参见： 示例的书写格式、基本数据类型


纵向对齐方式 (标签)

纵向对齐方式 属性 所属对象：标签

数据类型：整数型；如果选用自动折行则本属性无效。

可供选择的属性值：
0、顶对齐
1、居中
2、底对齐

示例：

参见： 示例的书写格式、基本数据类型


按钮

按钮 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
图片 | 类型 | 标题 | 横向对齐方式
纵向对齐方式 | 字体 |  |

自有事件：

被单击

基本事件：


图片 (按钮)

图片 属性 所属对象：按钮

数据类型：字节集；本属性指定显示在按钮上的图片。

示例：

参见： 示例的书写格式、基本数据类型


类型 (按钮)

类型 属性 所属对象：按钮

数据类型：整数型；当在窗口上按下Enter键时，如果没有将窗口的“回车下移输入点”属性设置为真，则等同于按下了具有“默认”类型的按钮。因此具有“默认”类型的按钮在同一窗口上应当只有一个。“通常”类型的按钮无对应的操作默认键。

可供选择的属性值：
0、通常
1、默认

示例：

参见： 示例的书写格式、基本数据类型


标题 (按钮)

标题 属性 所属对象：按钮

数据类型：文本型；标题只有在图片为空时才有效，如果希望某一字符成为此按钮的访问键，可以在该字符前面加上一个 & 字符。

示例：

参见： 示例的书写格式、基本数据类型


横向对齐方式 (按钮)

横向对齐方式 属性 所属对象：按钮

数据类型：整数型；

可供选择的属性值：
0、左边
1、居中
2、右边

示例：

参见： 示例的书写格式、基本数据类型


纵向对齐方式 (按钮)

纵向对齐方式 属性 所属对象：按钮

数据类型：整数型；

可供选择的属性值：
0、顶边
1、居中
2、底边

示例：

参见： 示例的书写格式、基本数据类型


字体 (按钮)

字体 属性 所属对象：按钮

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


被单击 (按钮)

被单击 事件 所属对象：按钮

当单击按钮后即产生此事件。

语法： 无返回值 _按钮_被单击 （）

示例：


选择框

选择框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
图片 | 按钮形式 | 平面 | 标题
标题居左 | 横向对齐方式 | 纵向对齐方式 | 文本颜色
背景颜色 | 字体 | 选中 |

自有事件：

被单击

基本事件：


图片 (选择框)

图片 属性 所属对象：选择框

数据类型：字节集；本属性指定显示在选择框上的图片。

示例：

参见： 示例的书写格式、基本数据类型


按钮形式 (选择框)

按钮形式 属性 所属对象：选择框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


平面 (选择框)

平面 属性 所属对象：选择框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


标题 (选择框)

标题 属性 所属对象：选择框

数据类型：文本型；标题只有在图片为空时才有效，如果希望某一字符成为此选择框的访问键，可以在该字符前面加上一个 & 字符。

示例：

参见： 示例的书写格式、基本数据类型


标题居左 (选择框)

标题居左 属性 所属对象：选择框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


横向对齐方式 (选择框)

横向对齐方式 属性 所属对象：选择框

数据类型：整数型；

可供选择的属性值：
0、左边
1、居中
2、右边

示例：

参见： 示例的书写格式、基本数据类型


纵向对齐方式 (选择框)

纵向对齐方式 属性 所属对象：选择框

数据类型：整数型；

可供选择的属性值：
0、顶边
1、居中
2、底边

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (选择框)

文本颜色 属性 所属对象：选择框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (选择框)

背景颜色 属性 所属对象：选择框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (选择框)

字体 属性 所属对象：选择框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


选中 (选择框)

选中 属性 所属对象：选择框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


被单击 (选择框)

被单击 事件 所属对象：选择框

当单击选择框后即产生此事件。

语法： 无返回值 _选择框_被单击 （）

示例：


单选框

单选框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
图片 | 按钮形式 | 平面 | 标题
标题居左 | 横向对齐方式 | 纵向对齐方式 | 文本颜色
背景颜色 | 字体 | 选中 |

自有事件：

被单击

基本事件：


图片 (单选框)

图片 属性 所属对象：单选框

数据类型：字节集；本属性指定显示在单选框上的图片。

示例：

参见： 示例的书写格式、基本数据类型


按钮形式 (单选框)

按钮形式 属性 所属对象：单选框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


平面 (单选框)

平面 属性 所属对象：单选框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


标题 (单选框)

标题 属性 所属对象：单选框

数据类型：文本型；标题只有在图片为空时才有效，如果希望某一字符成为此单选框的访问键，可以在该字符前面加上一个 & 字符。

示例：

参见： 示例的书写格式、基本数据类型


标题居左 (单选框)

标题居左 属性 所属对象：单选框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


横向对齐方式 (单选框)

横向对齐方式 属性 所属对象：单选框

数据类型：整数型；

可供选择的属性值：
0、左边
1、居中
2、右边

示例：

参见： 示例的书写格式、基本数据类型


纵向对齐方式 (单选框)

纵向对齐方式 属性 所属对象：单选框

数据类型：整数型；

可供选择的属性值：
0、顶边
1、居中
2、底边

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (单选框)

文本颜色 属性 所属对象：单选框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (单选框)

背景颜色 属性 所属对象：单选框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (单选框)

字体 属性 所属对象：单选框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


选中 (单选框)

选中 属性 所属对象：单选框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


被单击 (单选框)

被单击 事件 所属对象：单选框

当单击单选框后即产生此事件。

语法： 无返回值 _单选框_被单击 （）

示例：


组合框

组合框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
类型 | 内容 | 最大文本长度 | 起始选择位置
被选择字符数 | 被选择文本 | 自动排序 | 行间距
文本颜色 | 背景颜色 | 字体 | 现行选中项

方法：

取顶端可见项目 | 置顶端可见项目 | 取项目数 | 取项目数值
置项目数值 | 取项目文本 | 置项目文本 | 加入项目
插入项目 | 删除项目 | 清空 | 选择

自有事件：

列表项被选择 | 编辑内容被改变 | 将弹出列表 | 列表被关闭
双击选择 |  |  |

基本事件：


类型 (组合框)

类型 属性 所属对象：组合框

数据类型：整数型；

可供选择的属性值：
0、可编辑列表式
1、可编辑下拉式
2、不可编辑下拉式

示例：

参见： 示例的书写格式、基本数据类型


内容 (组合框)

内容 属性 所属对象：组合框

数据类型：文本型；本属性指定在下拉列表框编辑部分中的文本内容。当类型为“不可编辑下拉式”时，本属性无效。

示例：

参见： 示例的书写格式、基本数据类型


最大文本长度 (组合框)

最大文本长度 属性 所属对象：组合框

数据类型：整数型；本属性指定在下拉列表框的编辑部分所允许输入的最大文本长度，为0表示没有限制。当类型为“不可编辑下拉式”时，本属性无效。

示例：

参见： 示例的书写格式、基本数据类型


起始选择位置 (组合框)

起始选择位置 属性 所属对象：组合框

数据类型：整数型；返回或设置所选择文本的起始点；0 为位置 1 ，1 为位置 2，如此类推。如果没有文本被选中，则指出光标位置。如果设置位置时使用值 -1，则将当前光标位置移动到文本尾部。当类型为“不可编辑下拉式”时，本属性无效。

示例：

参见： 示例的书写格式、基本数据类型


被选择字符数 (组合框)

被选择字符数 属性 所属对象：组合框

数据类型：整数型；返回或设置所选择的字符数。如果设置字符数时使用值 -1，则选择所有文本。当类型为“不可编辑下拉式”时，本属性无效。

示例：

参见： 示例的书写格式、基本数据类型


被选择文本 (组合框)

被选择文本 属性 所属对象：组合框

数据类型：文本型；设计时不可用；返回或替换当前在下拉列表框编辑部分中所选择的文本。当类型为“不可编辑下拉式”时，本属性无效。

示例：

参见： 示例的书写格式、基本数据类型


自动排序 (组合框)

自动排序 属性 所属对象：组合框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


行间距 (组合框)

行间距 属性 所属对象：组合框

数据类型：整数型；本属性指定各列表项目行之间的间距尺寸。

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (组合框)

文本颜色 属性 所属对象：组合框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (组合框)

背景颜色 属性 所属对象：组合框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (组合框)

字体 属性 所属对象：组合框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


现行选中项 (组合框)

现行选中项 属性 所属对象：组合框

数据类型：整数型；本属性指定下拉列表框中现行被选中的列表项目的位置，位置值从 0 开始， -1 表示现行没有被选中的列表项。

示例：

参见： 示例的书写格式、基本数据类型


取顶端可见项目 (组合框)

取顶端可见项目 方法 所属对象：组合框

返回组合框列表部分中当前最顶端可见项目的索引。0 为项目一，1 为项目二，如此类推。失败返回 -1 。

语法： 整数型 组合框．取顶端可见项目 （）

示例：


置顶端可见项目 (组合框)

置顶端可见项目 方法 所属对象：组合框

设置组合框列表部分中当前最顶端的可见项目，必要时将自动滚动组合框的列表部分。成功返回真，失败返回假。

语法： 逻辑型 组合框．置顶端可见项目 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


取项目数 (组合框)

取项目数 方法 所属对象：组合框

语法： 整数型 组合框．取项目数 （）

示例：


取项目数值 (组合框)

取项目数值 方法 所属对象：组合框

返回与指定项目相关联的数值。如果指定项目不存在，将返回 -1 。

语法： 整数型 组合框．取项目数值 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


置项目数值 (组合框)

置项目数值 方法 所属对象：组合框

设置与指定项目相关联的数值。成功返回真，失败返回假。

语法： 逻辑型 组合框．置项目数值 （项目索引，欲置入的项目数值）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。
欲置入的项目数值 | 必需的；整数型。该项目数值与指定项目相关联。

示例：


取项目文本 (组合框)

取项目文本 方法 所属对象：组合框

返回指定项目的文本。如果指定项目不存在，将返回空文本。

语法： 文本型 组合框．取项目文本 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


置项目文本 (组合框)

置项目文本 方法 所属对象：组合框

设置指定项目的文本。成功返回真，失败返回假。

语法： 逻辑型 组合框．置项目文本 （项目索引，欲置入的项目文本）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。
欲置入的项目文本 | 必需的；文本型。

示例：


加入项目 (组合框)

加入项目 方法 所属对象：组合框

加入指定项目到组合框列表部分的尾部，成功返回加入后该项目所处的位置，失败返回 -1 。

语法： 整数型 组合框．加入项目 （欲加入项目的文本，［与欲加入项目相关的数值］）

参数名 | 描 述
欲加入项目的文本 | 必需的；文本型。
与欲加入项目相关的数值 | 可选的；整数型。如果省略本参数，默认值为 0。

示例：


插入项目 (组合框)

插入项目 方法 所属对象：组合框

插入指定项目到组合框列表部分的指定位置处，成功返回插入后该项目所处的位置，失败返回 -1 。

语法： 整数型 组合框．插入项目 （欲插入的位置，欲插入项目的文本，［与欲插入项目相关的数值］）

参数名 | 描 述
欲插入的位置 | 必需的；整数型。0 为项目位置一，1 为项目位置二，如此类推。
欲插入项目的文本 | 必需的；文本型。
与欲插入项目相关的数值 | 可选的；整数型。如果省略本参数，默认值为 0。

示例：


删除项目 (组合框)

删除项目 方法 所属对象：组合框

删除组合框列表部分指定位置处的项目。成功返回真，失败返回假。

语法： 逻辑型 组合框．删除项目 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


清空 (组合框)

清空 方法 所属对象：组合框

删除组合框列表部分中的所有项目。

语法： 无返回值 组合框．清空 （）

示例：


选择 (组合框)

选择 方法 所属对象：组合框

在所有项目中寻找首部包含指定文本的项目，如找到，则选中它，并返回该项目的位置索引，否则返回 -1。

语法： 整数型 组合框．选择 （欲选择的项目文本）

参数名 | 描 述
欲选择的项目文本 | 必需的；文本型。

示例：


列表项被选择 (组合框)

列表项被选择 事件 所属对象：组合框

语法： 无返回值 _组合框_列表项被选择 （）

示例：


编辑内容被改变 (组合框)

编辑内容被改变 事件 所属对象：组合框

语法： 无返回值 _组合框_编辑内容被改变 （）

示例：


将弹出列表 (组合框)

将弹出列表 事件 所属对象：组合框

在将弹出组合框的列表部分之前产生此事件。在处理此事件时，可以即时填充组合框中的列表项目。

语法： 无返回值 _组合框_将弹出列表 （）

示例：


列表被关闭 (组合框)

列表被关闭 事件 所属对象：组合框

在关闭被弹出的组合框列表部分后产生此事件。

语法： 无返回值 _组合框_列表被关闭 （）

示例：


双击选择 (组合框)

双击选择 事件 所属对象：组合框

当使用鼠标左键在某列表项目上双击时产生此事件。

语法： 无返回值 _组合框_双击选择 （）

示例：


列表框

列表框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
边框 | 自动排序 | 多列 | 行间距
文本颜色 | 背景颜色 | 字体 | 允许选择多项
现行选中项 |  |  |

方法：

取顶端可见项目 | 置顶端可见项目 | 取项目数 | 取项目数值
置项目数值 | 取项目文本 | 置项目文本 | 取已选择项目数
取所有被选择项目 | 是否被选择 | 选择项目 | 取焦点项目
置焦点项目 | 加入项目 | 插入项目 | 删除项目
清空 | 选择 |  |

自有事件：

列表项被选择 双击选择

基本事件：


边框 (列表框)

边框 属性 所属对象：列表框

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


自动排序 (列表框)

自动排序 属性 所属对象：列表框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


多列 (列表框)

多列 属性 所属对象：列表框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


行间距 (列表框)

行间距 属性 所属对象：列表框

数据类型：整数型；本属性指定各列表项目行之间的间距尺寸。

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (列表框)

文本颜色 属性 所属对象：列表框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (列表框)

背景颜色 属性 所属对象：列表框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (列表框)

字体 属性 所属对象：列表框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


允许选择多项 (列表框)

允许选择多项 属性 所属对象：列表框

数据类型：逻辑型；本属性指定是否允许用户同时选择列表框中的多个列表项。

示例：

参见： 示例的书写格式、基本数据类型


现行选中项 (列表框)

现行选中项 属性 所属对象：列表框

数据类型：整数型；本属性指定列表框中现行被选中列表项目的位置，位置值从0开始，-1表示现行没有被选中的列表项。如果“允许选择多项”属性为真，则本属性无效，其值恒为 -1。

示例：

参见： 示例的书写格式、基本数据类型


取顶端可见项目 (列表框)

取顶端可见项目 方法 所属对象：列表框

返回列表框中当前最顶端可见项目的索引。0 为项目一，1 为项目二，如此类推。失败返回 -1 。

语法： 整数型 列表框．取顶端可见项目 （）

示例：


置顶端可见项目 (列表框)

置顶端可见项目 方法 所属对象：列表框

设置列表框中当前最顶端的可见项目，必要时将自动滚动列表框。成功返回真，失败返回假。

语法： 逻辑型 列表框．置顶端可见项目 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


取项目数 (列表框)

取项目数 方法 所属对象：列表框

语法： 整数型 列表框．取项目数 （）

示例：


取项目数值 (列表框)

取项目数值 方法 所属对象：列表框

返回与指定项目相关联的数值。如果指定项目不存在，将返回 -1 。

语法： 整数型 列表框．取项目数值 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


置项目数值 (列表框)

置项目数值 方法 所属对象：列表框

设置与指定项目相关联的数值。成功返回真，失败返回假。

语法： 逻辑型 列表框．置项目数值 （项目索引，欲置入的项目数值）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。
欲置入的项目数值 | 必需的；整数型。该项目数值与指定项目相关联。

示例：


取项目文本 (列表框)

取项目文本 方法 所属对象：列表框

返回指定项目的文本。如果指定项目不存在，将返回空文本。

语法： 文本型 列表框．取项目文本 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


置项目文本 (列表框)

置项目文本 方法 所属对象：列表框

设置指定项目的文本。成功返回真，失败返回假。

语法： 逻辑型 列表框．置项目文本 （项目索引，欲置入的项目文本）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。
欲置入的项目文本 | 必需的；文本型。

示例：


取已选择项目数 (列表框)

取已选择项目数 方法 所属对象：列表框

返回已被选择项目的数目。

语法： 整数型 列表框．取已选择项目数 （）

示例：


取所有被选择项目 (列表框)

取所有被选择项目 方法 所属对象：列表框

返回一个整数数组，內含所有当前被选择项目的位置索引。如果当前没有被选择项目，返回空数组。

语法： 整数型数组 列表框．取所有被选择项目 （）

示例：


是否被选择 (列表框)

是否被选择 方法 所属对象：列表框

如果指定项目被选择，则返回真，否则返回假。

语法： 逻辑型 列表框．是否被选择 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


选择项目 (列表框)

选择项目 方法 所属对象：列表框

选择或取消选择指定项目。成功返回真，失败返回假。

语法： 逻辑型 列表框．选择项目 （欲选择或取消选择的项目索引，［欲置入的项目选择状态］）

参数名 | 描 述
欲选择或取消选择的项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。
欲置入的项目选择状态 | 可选的；逻辑型。如果省略本参数或者参数值为真，则选择该项目，否则取消对该项目的选择。

示例：


取焦点项目 (列表框)

取焦点项目 方法 所属对象：列表框

本命令仅在多选列表框中使用，用作返回当前焦点项目的位置索引。如果在单选列表框中使用本命令，将返回当前被选择项目的位置索引。

语法： 整数型 列表框．取焦点项目 （）

示例：


置焦点项目 (列表框)

置焦点项目 方法 所属对象：列表框

本命令仅在多选列表框中使用，用作设置当前焦点项目。如果在单选列表框中使用本命令，将设置当前被选择项目。成功返回真，失败返回假。

语法： 逻辑型 列表框．置焦点项目 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


加入项目 (列表框)

加入项目 方法 所属对象：列表框

加入指定项目到列表框的尾部，成功返回加入后该项目所处的位置，失败返回 -1 。

语法： 整数型 列表框．加入项目 （欲加入项目的文本，［与欲加入项目相关的数值］）

参数名 | 描 述
欲加入项目的文本 | 必需的；文本型。
与欲加入项目相关的数值 | 可选的；整数型。如果省略本参数，默认值为 0。

示例：


插入项目 (列表框)

插入项目 方法 所属对象：列表框

插入指定项目到列表框的指定位置处，成功返回插入后该项目所处的位置，失败返回 -1 。

语法： 整数型 列表框．插入项目 （欲插入的位置，欲插入项目的文本，［与欲插入项目相关的数值］）

参数名 | 描 述
欲插入的位置 | 必需的；整数型。0 为项目位置一，1 为项目位置二，如此类推。
欲插入项目的文本 | 必需的；文本型。
与欲插入项目相关的数值 | 可选的；整数型。如果省略本参数，默认值为 0。

示例：


删除项目 (列表框)

删除项目 方法 所属对象：列表框

删除列表框指定位置处的项目。成功返回真，失败返回假。

语法： 逻辑型 列表框．删除项目 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


清空 (列表框)

清空 方法 所属对象：列表框

删除列表框中的所有项目。

语法： 无返回值 列表框．清空 （）

示例：


选择 (列表框)

选择 方法 所属对象：列表框

在所有项目中寻找首部包含指定文本的项目，如找到，则选中它，并返回该项目的位置索引，否则返回 -1 。本命令仅在单选列表框中使用，如果在多选列表框中使用，将返回 -1 。

语法： 整数型 列表框．选择 （欲选择的项目文本）

参数名 | 描 述
欲选择的项目文本 | 必需的；文本型。

示例：


列表项被选择 (列表框)

列表项被选择 事件 所属对象：列表框

如果当前所选择的列表项或区域被改变即产生此事件。

语法： 无返回值 _列表框_列表项被选择 （）

示例：


双击选择 (列表框)

双击选择 事件 所属对象：列表框

当使用鼠标左键在某列表项目上双击时产生此事件。

语法： 无返回值 _列表框_双击选择 （）

示例：


选择列表框

选择列表框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
边框 | 自动排序 | 多列 | 行间距
单选 | 字体 | 现行选中项 |

方法：

取顶端可见项目 | 置顶端可见项目 | 取项目数 | 取项目数值
置项目数值 | 取项目文本 | 置项目文本 | 加入项目
插入项目 | 删除项目 | 清空 | 选择
是否被选中 | 选中项目 | 是否被允许 | 允许

自有事件：

列表项被选择 选中状态被改变 双击选择

基本事件：


边框 (选择列表框)

边框 属性 所属对象：选择列表框

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


自动排序 (选择列表框)

自动排序 属性 所属对象：选择列表框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


多列 (选择列表框)

多列 属性 所属对象：选择列表框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


行间距 (选择列表框)

行间距 属性 所属对象：选择列表框

数据类型：整数型；本属性指定各列表项目行之间的间距尺寸。

示例：

参见： 示例的书写格式、基本数据类型


单选 (选择列表框)

单选 属性 所属对象：选择列表框

数据类型：逻辑型；本属性指定是否只允许选择一项列表项。

示例：

参见： 示例的书写格式、基本数据类型


字体 (选择列表框)

字体 属性 所属对象：选择列表框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


现行选中项 (选择列表框)

现行选中项 属性 所属对象：选择列表框

数据类型：整数型；本属性指定列表框中现行被选中的列表项目的位置，位置值从0开始，-1表示现行没有被选中的列表项。

示例：

参见： 示例的书写格式、基本数据类型


取顶端可见项目 (选择列表框)

取顶端可见项目 方法 所属对象：选择列表框

返回列表框中当前最顶端可见项目的索引。0 为项目一，1 为项目二，如此类推。失败返回 -1 。

语法： 整数型 选择列表框．取顶端可见项目 （）

示例：


置顶端可见项目 (选择列表框)

置顶端可见项目 方法 所属对象：选择列表框

设置列表框中当前最顶端的可见项目，必要时将自动滚动列表框。成功返回真，失败返回假。

语法： 逻辑型 选择列表框．置顶端可见项目 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


取项目数 (选择列表框)

取项目数 方法 所属对象：选择列表框

语法： 整数型 选择列表框．取项目数 （）

示例：


取项目数值 (选择列表框)

取项目数值 方法 所属对象：选择列表框

返回与指定项目相关联的数值。如果指定项目不存在，将返回 -1 。

语法： 整数型 选择列表框．取项目数值 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


置项目数值 (选择列表框)

置项目数值 方法 所属对象：选择列表框

设置与指定项目相关联的数值。成功返回真，失败返回假。

语法： 逻辑型 选择列表框．置项目数值 （项目索引，欲置入的项目数值）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。
欲置入的项目数值 | 必需的；整数型。该项目数值与指定项目相关联。

示例：


取项目文本 (选择列表框)

取项目文本 方法 所属对象：选择列表框

返回指定项目的文本。如果指定项目不存在，将返回空文本。

语法： 文本型 选择列表框．取项目文本 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


置项目文本 (选择列表框)

置项目文本 方法 所属对象：选择列表框

设置指定项目的文本。成功返回真，失败返回假。

语法： 逻辑型 选择列表框．置项目文本 （项目索引，欲置入的项目文本）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。
欲置入的项目文本 | 必需的；文本型。

示例：


加入项目 (选择列表框)

加入项目 方法 所属对象：选择列表框

加入指定项目到列表框的尾部，成功返回加入后该项目所处的位置，失败返回 -1 。

语法： 整数型 选择列表框．加入项目 （欲加入项目的文本，［与欲加入项目相关的数值］）

参数名 | 描 述
欲加入项目的文本 | 必需的；文本型。
与欲加入项目相关的数值 | 可选的；整数型。如果省略本参数，默认值为 0。

示例：


插入项目 (选择列表框)

插入项目 方法 所属对象：选择列表框

插入指定项目到列表框的指定位置处，成功返回插入后该项目所处的位置，失败返回 -1 。

语法： 整数型 选择列表框．插入项目 （欲插入的位置，欲插入项目的文本，［与欲插入项目相关的数值］）

参数名 | 描 述
欲插入的位置 | 必需的；整数型。0 为项目位置一，1 为项目位置二，如此类推。
欲插入项目的文本 | 必需的；文本型。
与欲插入项目相关的数值 | 可选的；整数型。如果省略本参数，默认值为 0。

示例：


删除项目 (选择列表框)

删除项目 方法 所属对象：选择列表框

删除列表框指定位置处的项目。成功返回真，失败返回假。

语法： 逻辑型 选择列表框．删除项目 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


清空 (选择列表框)

清空 方法 所属对象：选择列表框

删除列表框中的所有项目。

语法： 无返回值 选择列表框．清空 （）

示例：


选择 (选择列表框)

选择 方法 所属对象：选择列表框

在所有项目中寻找首部包含指定文本的项目，如找到，则选中它，并返回该项目的位置索引，否则返回 -1。

语法： 整数型 选择列表框．选择 （欲选择的项目文本）

参数名 | 描 述
欲选择的项目文本 | 必需的；文本型。

示例：


是否被选中 (选择列表框)

是否被选中 方法 所属对象：选择列表框

如果与指定项目对应的选择框被选中，则返回真，否则返回假。

语法： 逻辑型 选择列表框．是否被选中 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


选中项目 (选择列表框)

选中项目 方法 所属对象：选择列表框

选中或取消选中与指定项目对应的选择框。成功返回真，失败返回假。

语法： 逻辑型 选择列表框．选中项目 （欲选择或取消选择的项目索引，［欲置入的项目选择状态］）

参数名 | 描 述
欲选择或取消选择的项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。
欲置入的项目选择状态 | 可选的；逻辑型。如果省略本参数或者参数值为真，则选择该项目，否则取消对该项目的选择。

示例：


是否被允许 (选择列表框)

是否被允许 方法 所属对象：选择列表框

如果与指定项目对应的选择框被允许操作，则返回真，否则返回假。

语法： 逻辑型 选择列表框．是否被允许 （项目索引）

参数名 | 描 述
项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。

示例：


允许 (选择列表框)

允许 方法 所属对象：选择列表框

允许或禁止对指定项目进行选择操作。成功返回真，失败返回假。

语法： 逻辑型 选择列表框．允许 （欲允许或禁止操作的项目索引，［允许或禁止］）

参数名 | 描 述
欲允许或禁止操作的项目索引 | 必需的；整数型。0 为项目一，1 为项目二，如此类推。
允许或禁止 | 可选的；逻辑型。如果省略本参数或者参数值为真，则允许该项目，否则禁止对该项目进行选中操作。

示例：


列表项被选择 (选择列表框)

列表项被选择 事件 所属对象：选择列表框

如果当前所选择的列表项被改变即产生此事件。

语法： 无返回值 _选择列表框_列表项被选择 （）

示例：


选中状态被改变 (选择列表框)

选中状态被改变 事件 所属对象：选择列表框

语法： 无返回值 _选择列表框_选中状态被改变 （）

示例：


双击选择 (选择列表框)

双击选择 事件 所属对象：选择列表框

当使用鼠标左键在某列表项目上双击时产生此事件。

语法： 无返回值 _选择列表框_双击选择 （）

示例：


横向滚动条

横向滚动条 窗口单元 跳至：系统核心支持库

默认不接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
最小位置 | 最大位置 | 页改变值 | 行改变值
位置 | 允许拖动跟踪 |  |

自有事件：

位置被改变

基本事件：


最小位置 (横向滚动条)

最小位置 属性 所属对象：横向滚动条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


最大位置 (横向滚动条)

最大位置 属性 所属对象：横向滚动条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


页改变值 (横向滚动条)

页改变值 属性 所属对象：横向滚动条

数据类型：整数型；本属性指定当用户在滚动条的空隙处单击后滚动条位置的增减数值。

示例：

参见： 示例的书写格式、基本数据类型


行改变值 (横向滚动条)

行改变值 属性 所属对象：横向滚动条

数据类型：整数型；本属性指定当用户按下滚动条的左右箭头按钮后滚动条位置的增减数值。

示例：

参见： 示例的书写格式、基本数据类型


位置 (横向滚动条)

位置 属性 所属对象：横向滚动条

数据类型：整数型；本属性设定滚动条的现行位置。

示例：

参见： 示例的书写格式、基本数据类型


允许拖动跟踪 (横向滚动条)

允许拖动跟踪 属性 所属对象：横向滚动条

数据类型：逻辑型；本属性设定当用户拖动滚动条的位置盒的过程中是否产生位置改变事件。

示例：

参见： 示例的书写格式、基本数据类型


位置被改变 (横向滚动条)

位置被改变 事件 所属对象：横向滚动条

语法： 无返回值 _横向滚动条_位置被改变 （）

示例：


纵向滚动条

纵向滚动条 窗口单元 跳至：系统核心支持库

默认不接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
最小位置 | 最大位置 | 页改变值 | 行改变值
位置 | 允许拖动跟踪 |  |

自有事件：

位置被改变

基本事件：


最小位置 (纵向滚动条)

最小位置 属性 所属对象：纵向滚动条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


最大位置 (纵向滚动条)

最大位置 属性 所属对象：纵向滚动条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


页改变值 (纵向滚动条)

页改变值 属性 所属对象：纵向滚动条

数据类型：整数型；本属性指定当用户在滚动条的空隙处单击后滚动条位置的增减数值。

示例：

参见： 示例的书写格式、基本数据类型


行改变值 (纵向滚动条)

行改变值 属性 所属对象：纵向滚动条

数据类型：整数型；本属性指定当用户按下滚动条的上下箭头按钮后滚动条位置的增减数值。

示例：

参见： 示例的书写格式、基本数据类型


位置 (纵向滚动条)

位置 属性 所属对象：纵向滚动条

数据类型：整数型；本属性设定滚动条的现行位置。

示例：

参见： 示例的书写格式、基本数据类型


允许拖动跟踪 (纵向滚动条)

允许拖动跟踪 属性 所属对象：纵向滚动条

数据类型：逻辑型；本属性设定当用户拖动滚动条的位置盒的过程中是否产生位置改变事件。

示例：

参见： 示例的书写格式、基本数据类型


位置被改变 (纵向滚动条)

位置被改变 事件 所属对象：纵向滚动条

语法： 无返回值 _纵向滚动条_位置被改变 （）

示例：


进度条

进度条 窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
边框 | 方向 | 显示方式 | 最小位置
最大位置 | 位置 |  |

基本事件：


边框 (进度条)

边框 属性 所属对象：进度条

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


方向 (进度条)

方向 属性 所属对象：进度条

数据类型：整数型；

可供选择的属性值：
0、横向
1、纵向

示例：

参见： 示例的书写格式、基本数据类型


显示方式 (进度条)

显示方式 属性 所属对象：进度条

数据类型：整数型；

可供选择的属性值：
0、分块
1、连续

示例：

参见： 示例的书写格式、基本数据类型


最小位置 (进度条)

最小位置 属性 所属对象：进度条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


最大位置 (进度条)

最大位置 属性 所属对象：进度条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


位置 (进度条)

位置 属性 所属对象：进度条

数据类型：整数型；本属性设定进度条的现行位置。

示例：

参见： 示例的书写格式、基本数据类型


滑块条

滑块条 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
边框 | 方向 | 刻度类型 | 单位刻度值
允许选择 | 首选择位置 | 选择长度 | 页改变值
行改变值 | 最小位置 | 最大位置 | 位置

自有事件：

位置被改变

基本事件：


边框 (滑块条)

边框 属性 所属对象：滑块条

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


方向 (滑块条)

方向 属性 所属对象：滑块条

数据类型：整数型；

可供选择的属性值：
0、横向
1、纵向

示例：

参见： 示例的书写格式、基本数据类型


刻度类型 (滑块条)

刻度类型 属性 所属对象：滑块条

数据类型：整数型；

可供选择的属性值：
0、无
1、上/左
2、下/右
3、双向

示例：

参见： 示例的书写格式、基本数据类型


单位刻度值 (滑块条)

单位刻度值 属性 所属对象：滑块条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


允许选择 (滑块条)

允许选择 属性 所属对象：滑块条

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


首选择位置 (滑块条)

首选择位置 属性 所属对象：滑块条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


选择长度 (滑块条)

选择长度 属性 所属对象：滑块条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


页改变值 (滑块条)

页改变值 属性 所属对象：滑块条

数据类型：整数型；本属性指定当用户在空隙处单击后滑块条位置的增减数值。

示例：

参见： 示例的书写格式、基本数据类型


行改变值 (滑块条)

行改变值 属性 所属对象：滑块条

数据类型：整数型；本属性指定当用户拖动滑块时滑块条位置的每次增减数值。

示例：

参见： 示例的书写格式、基本数据类型


最小位置 (滑块条)

最小位置 属性 所属对象：滑块条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


最大位置 (滑块条)

最大位置 属性 所属对象：滑块条

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


位置 (滑块条)

位置 属性 所属对象：滑块条

数据类型：整数型；本属性设定滑块条的现行位置。

示例：

参见： 示例的书写格式、基本数据类型


位置被改变 (滑块条)

位置被改变 事件 所属对象：滑块条

语法： 无返回值 _滑块条_位置被改变 （）

示例：


选择夹

选择夹 包容型窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
表头方向 | 允许多行表头 | 字体 | 现行子夹
隐藏自身 |  |  |

方法：

取子夹数目 取子夹名称 置子夹名称

自有事件：

被单击 将改变子夹 子夹被改变

基本事件：


表头方向 (选择夹)

表头方向 属性 所属对象：选择夹

数据类型：整数型；

可供选择的属性值：
0、上
1、下
2、左
3、右

示例：

参见： 示例的书写格式、基本数据类型


允许多行表头 (选择夹)

允许多行表头 属性 所属对象：选择夹

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (选择夹)

字体 属性 所属对象：选择夹

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


现行子夹 (选择夹)

现行子夹 属性 所属对象：选择夹

数据类型：整数型；设计时不可用；本属性指定现行被选中子夹的索引，索引值从 0 开始。

示例：

参见： 示例的书写格式、基本数据类型


隐藏自身 (选择夹)

隐藏自身 属性 所属对象：选择夹

数据类型：逻辑型；本属性可以用来动态切换数个同一位置处子单元群的显示。此时选择夹本身不会被显示，但用户可以通过改变其“现行子夹”属性来显示指定子夹内的所有子单元。注意在设计时为方便用户定位子单元，表头方向始终为下。

示例：

参见： 示例的书写格式、基本数据类型


取子夹数目 (选择夹)

取子夹数目 方法 所属对象：选择夹

语法： 整数型 选择夹．取子夹数目 （）

示例：


取子夹名称 (选择夹)

取子夹名称 方法 所属对象：选择夹

语法： 文本型 选择夹．取子夹名称 （子夹索引）

参数名 | 描 述
子夹索引 | 必需的；整数型。1 代表子夹一，2 代表子夹二，如此类推。

示例：


置子夹名称 (选择夹)

置子夹名称 方法 所属对象：选择夹

置入成功返回真，否则返回假。

语法： 逻辑型 选择夹．置子夹名称 （子夹索引，欲置入的子夹名称）

参数名 | 描 述
子夹索引 | 必需的；整数型。1 代表子夹一，2 代表子夹二，如此类推。
欲置入的子夹名称 | 必需的；文本型。

示例：


被单击 (选择夹)

被单击 事件 所属对象：选择夹

当在选择夹上单击后产生此事件。

语法： 无返回值 _选择夹_被单击 （）

示例：


将改变子夹 (选择夹)

将改变子夹 事件 所属对象：选择夹

当现行被选择子夹即将被改变时产生此事件。返回假中止此改变，返回真或不返回值则允许此改变。

语法： 逻辑型 _选择夹_将改变子夹 （）

示例：


子夹被改变 (选择夹)

子夹被改变 事件 所属对象：选择夹

当现行被选择子夹已经被改变时产生此事件。

语法： 无返回值 _选择夹_子夹被改变 （）

示例：


影像框

影像框 窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
文件名 | 居中播放 | 透明背景 | 播放
播放次数 |  |  |

基本事件：


文件名 (影像框)

文件名 属性 所属对象：影像框

数据类型：文本型；本属性指定欲播放的影像文件的名称。

示例：

参见： 示例的书写格式、基本数据类型


居中播放 (影像框)

居中播放 属性 所属对象：影像框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


透明背景 (影像框)

透明背景 属性 所属对象：影像框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


播放 (影像框)

播放 属性 所属对象：影像框

数据类型：逻辑型；如果指定了有效的影像文件，通过改变此属性可控制其播放或停止。如在设计时置本属性为真，运行时影像文件在影像框被创建后即自动开始播放。

示例：

参见： 示例的书写格式、基本数据类型


播放次数 (影像框)

播放次数 属性 所属对象：影像框

数据类型：整数型；指定影像的播放次数。如为 -1，则无限次地循环播放。

示例：

参见： 示例的书写格式、基本数据类型


日期框

日期框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
允许编辑 | 附件类型 | 今天 | 最小日期
最大日期 | 字体 | 边框 |

自有事件：

选择日期被改变

基本事件：


允许编辑 (日期框)

允许编辑 属性 所属对象：日期框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


附件类型 (日期框)

附件类型 属性 所属对象：日期框

数据类型：整数型；

可供选择的属性值：
0、下拉月历
1、调节器

示例：

参见： 示例的书写格式、基本数据类型


今天 (日期框)

今天 属性 所属对象：日期框

数据类型：日期时间型；指定或读取现行日期，如果不设定，则自动取现行日期。

示例：

参见： 示例的书写格式、基本数据类型


最小日期 (日期框)

最小日期 属性 所属对象：日期框

数据类型：日期时间型；

示例：

参见： 示例的书写格式、基本数据类型


最大日期 (日期框)

最大日期 属性 所属对象：日期框

数据类型：日期时间型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (日期框)

字体 属性 所属对象：日期框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


边框 (日期框)

边框 属性 所属对象：日期框

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


选择日期被改变 (日期框)

选择日期被改变 事件 所属对象：日期框

当现行被选择的日期被改变后产生此事件。

语法： 无返回值 _日期框_选择日期被改变 （）

示例：


月历

月历 窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
不显示今天 | 不圈注今天 | 开始星期首日 | 显示星期序号
滚动月数 | 今天 | 最小日期 | 最大日期
允许选择多天 | 最多选择天数 | 首选择日 | 尾选择日
字体 | 文本颜色 | 背景颜色 | 内背景颜色
标题颜色 | 标题背景颜色 | 非本月颜色 | 边框

自有事件：

选择日期被改变

基本事件：


不显示今天 (月历)

不显示今天 属性 所属对象：月历

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


不圈注今天 (月历)

不圈注今天 属性 所属对象：月历

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


开始星期首日 (月历)

开始星期首日 属性 所属对象：月历

数据类型：整数型；

可供选择的属性值：
0、星期一
1、星期二
2、星期三
3、星期四
4、星期五
5、星期六
6、星期日

示例：

参见： 示例的书写格式、基本数据类型


显示星期序号 (月历)

显示星期序号 属性 所属对象：月历

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


滚动月数 (月历)

滚动月数 属性 所属对象：月历

数据类型：整数型；本属性指定当按下滚动按钮改变当前显示月时，一次跳过的月的数目。

示例：

参见： 示例的书写格式、基本数据类型


今天 (月历)

今天 属性 所属对象：月历

数据类型：日期时间型；指定现行日期，如果不设定，则自动取系统时间中记录的现行日期。

示例：

参见： 示例的书写格式、基本数据类型


最小日期 (月历)

最小日期 属性 所属对象：月历

数据类型：日期时间型；指定能被显示的最小日期。

示例：

参见： 示例的书写格式、基本数据类型


最大日期 (月历)

最大日期 属性 所属对象：月历

数据类型：日期时间型；指定能被显示的最大日期。

示例：

参见： 示例的书写格式、基本数据类型


允许选择多天 (月历)

允许选择多天 属性 所属对象：月历

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


最多选择天数 (月历)

最多选择天数 属性 所属对象：月历

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


首选择日 (月历)

首选择日 属性 所属对象：月历

数据类型：日期时间型；指定现行被选择区域的首日期。如果不允许选择多天，则本属性指定现行被选择的日期。

示例：

参见： 示例的书写格式、基本数据类型


尾选择日 (月历)

尾选择日 属性 所属对象：月历

数据类型：日期时间型；指定现行被选择区域的尾日期。如果不允许选择多天，则本属性无效。

示例：

参见： 示例的书写格式、基本数据类型


字体 (月历)

字体 属性 所属对象：月历

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (月历)

文本颜色 属性 所属对象：月历

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (月历)

背景颜色 属性 所属对象：月历

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


内背景颜色 (月历)

内背景颜色 属性 所属对象：月历

数据类型：整数型；指定用来实际显示月历部分的背景颜色。

示例：

参见： 示例的书写格式、基本数据类型


标题颜色 (月历)

标题颜色 属性 所属对象：月历

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


标题背景颜色 (月历)

标题背景颜色 属性 所属对象：月历

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


非本月颜色 (月历)

非本月颜色 属性 所属对象：月历

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


边框 (月历)

边框 属性 所属对象：月历

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


选择日期被改变 (月历)

选择日期被改变 事件 所属对象：月历

当现行被选择的日期或区域被改变后产生此事件。

语法： 无返回值 _月历_选择日期被改变 （）

示例：


驱动器框

驱动器框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
驱动器 | 类型 | 文本颜色 | 背景颜色
字体 |  |  |

自有事件：

驱动器被改变

基本事件：


驱动器 (驱动器框)

驱动器 属性 所属对象：驱动器框

数据类型：文本型；设计时不可用；指定当前驱动器符，如果不指定，默认为当前驱动器。驱动器符为大写字母 A - Z。

示例：

参见： 示例的书写格式、基本数据类型


类型 (驱动器框)

类型 属性 所属对象：驱动器框

数据类型：整数型；指定可用的驱动器类型。

可供选择的属性值：
0、全部驱动器
1、可抽取式驱动器
2、固定驱动器
3、光盘驱动器
4、网络驱动器
5、内存虚拟驱动器

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (驱动器框)

文本颜色 属性 所属对象：驱动器框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (驱动器框)

背景颜色 属性 所属对象：驱动器框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (驱动器框)

字体 属性 所属对象：驱动器框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


驱动器被改变 (驱动器框)

驱动器被改变 事件 所属对象：驱动器框

语法： 无返回值 _驱动器框_驱动器被改变 （）

示例：


目录框

目录框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
目录 | 边框 | 背景颜色 | 字体

自有事件：

目录被改变

基本事件：


目录 (目录框)

目录 属性 所属对象：目录框

数据类型：文本型；设计时不可用；

示例：

参见： 示例的书写格式、基本数据类型


边框 (目录框)

边框 属性 所属对象：目录框

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (目录框)

背景颜色 属性 所属对象：目录框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (目录框)

字体 属性 所属对象：目录框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


目录被改变 (目录框)

目录被改变 事件 所属对象：目录框

语法： 无返回值 _目录框_目录被改变 （）

示例：


文件框

文件框 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
目录 | 被选择文件 | 允许选择多项 | 通配符
通常 | 存档 | 只读 | 系统
隐藏 | 最小日期 | 最大日期 | 边框
文本颜色 | 背景颜色 | 字体 |

自有事件：

选择文件被改变 双击选择

基本事件：


目录 (文件框)

目录 属性 所属对象：文件框

数据类型：文本型；设计时不可用；

示例：

参见： 示例的书写格式、基本数据类型


被选择文件 (文件框)

被选择文件 属性 所属对象：文件框

数据类型：文本型；只读；记录所有现行被选择的文件，注意不包含路径。如果有多个文件被选择，各文件名之间用分号“;”隔开。

示例：

参见： 示例的书写格式、基本数据类型


允许选择多项 (文件框)

允许选择多项 属性 所属对象：文件框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


通配符 (文件框)

通配符 属性 所属对象：文件框

数据类型：文本型；指定允许进入文件框的文件类型。可以同时指定多个通配符，各通配符之间用分号“;”隔开。

示例：

参见： 示例的书写格式、基本数据类型


通常 (文件框)

通常 属性 所属对象：文件框

数据类型：逻辑型；指定是否允许没有设置存档、只读、系统、隐藏文件属性的文件进入。

示例：

参见： 示例的书写格式、基本数据类型


存档 (文件框)

存档 属性 所属对象：文件框

数据类型：逻辑型；指定是否允许设置了存档文件属性的文件进入。

示例：

参见： 示例的书写格式、基本数据类型


只读 (文件框)

只读 属性 所属对象：文件框

数据类型：逻辑型；指定是否允许设置了只读文件属性的文件进入。

示例：

参见： 示例的书写格式、基本数据类型


系统 (文件框)

系统 属性 所属对象：文件框

数据类型：逻辑型；指定是否允许设置了系统文件属性的文件进入。

示例：

参见： 示例的书写格式、基本数据类型


隐藏 (文件框)

隐藏 属性 所属对象：文件框

数据类型：逻辑型；指定是否允许设置了隐藏文件属性的文件进入。

示例：

参见： 示例的书写格式、基本数据类型


最小日期 (文件框)

最小日期 属性 所属对象：文件框

数据类型：日期时间型；指定允许进入的文件的最小日期。

示例：

参见： 示例的书写格式、基本数据类型


最大日期 (文件框)

最大日期 属性 所属对象：文件框

数据类型：日期时间型；指定允许进入的文件的最大日期。

示例：

参见： 示例的书写格式、基本数据类型


边框 (文件框)

边框 属性 所属对象：文件框

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (文件框)

文本颜色 属性 所属对象：文件框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (文件框)

背景颜色 属性 所属对象：文件框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (文件框)

字体 属性 所属对象：文件框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


选择文件被改变 (文件框)

选择文件被改变 事件 所属对象：文件框

语法： 无返回值 _文件框_选择文件被改变 （）

示例：


双击选择 (文件框)

双击选择 事件 所属对象：文件框

当使用鼠标左键在某列表项目上双击时产生此事件。

语法： 无返回值 _文件框_双击选择 （）

示例：


颜色选择器

颜色选择器 窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
颜色 | 允许透明 |  |

自有事件：

颜色被改变

基本事件：


颜色 (颜色选择器)

颜色 属性 所属对象：颜色选择器

数据类型：整数型；颜色数值为红绿蓝颜色值或“#透明”常量值。

示例：

参见： 示例的书写格式、基本数据类型


允许透明 (颜色选择器)

允许透明 属性 所属对象：颜色选择器

数据类型：逻辑型；指定是否允许透明色。

示例：

参见： 示例的书写格式、基本数据类型


颜色被改变 (颜色选择器)

颜色被改变 事件 所属对象：颜色选择器

语法： 无返回值 _颜色选择器_颜色被改变 （）

示例：


超级链接框

超级链接框 窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
标题 | 类型 | 电子信箱地址 | Internet地址
文本颜色 | 访问后的颜色 | 热点颜色 | 背景颜色
边框 | 字体 |  |

方法：

跳转

基本事件：


标题 (超级链接框)

标题 属性 所属对象：超级链接框

数据类型：文本型；

示例：

参见： 示例的书写格式、基本数据类型


类型 (超级链接框)

类型 属性 所属对象：超级链接框

数据类型：整数型；

可供选择的属性值：
0、电子信箱地址
1、Internet地址

示例：

参见： 示例的书写格式、基本数据类型


电子信箱地址 (超级链接框)

电子信箱地址 属性 所属对象：超级链接框

数据类型：文本型；

示例：

参见： 示例的书写格式、基本数据类型


Internet地址 (超级链接框)

Internet地址 属性 所属对象：超级链接框

数据类型：文本型；

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (超级链接框)

文本颜色 属性 所属对象：超级链接框

数据类型：整数型；正常情况下时的文本显示颜色。

示例：

参见： 示例的书写格式、基本数据类型


访问后的颜色 (超级链接框)

访问后的颜色 属性 所属对象：超级链接框

数据类型：整数型；被访问过后的文本显示颜色。

示例：

参见： 示例的书写格式、基本数据类型


热点颜色 (超级链接框)

热点颜色 属性 所属对象：超级链接框

数据类型：整数型；鼠标移动到单元上时的文本显示颜色。

示例：

参见： 示例的书写格式、基本数据类型


背景颜色 (超级链接框)

背景颜色 属性 所属对象：超级链接框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


边框 (超级链接框)

边框 属性 所属对象：超级链接框

数据类型：整数型；

可供选择的属性值：
0、无边框
1、凹入式
2、凸出式
3、浅凹入式
4、镜框式
5、单线边框式

示例：

参见： 示例的书写格式、基本数据类型


字体 (超级链接框)

字体 属性 所属对象：超级链接框

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


跳转 (超级链接框)

跳转 方法 所属对象：超级链接框

跳转到指定的邮件或 Internet 地址。

语法： 无返回值 超级链接框．跳转 （）

示例：


调节器

调节器 窗口单元 跳至：系统核心支持库

不能接受输入焦点；

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
方向 | 热点跟踪 |  |

自有事件：

调节钮被按下

基本事件：


方向 (调节器)

方向 属性 所属对象：调节器

数据类型：整数型；

可供选择的属性值：
0、横向
1、纵向

示例：

参见： 示例的书写格式、基本数据类型


热点跟踪 (调节器)

热点跟踪 属性 所属对象：调节器

数据类型：逻辑型；指定当鼠标移动到单元上时是否显示热点状态。

示例：

参见： 示例的书写格式、基本数据类型


调节钮被按下 (调节器)

调节钮被按下 事件 所属对象：调节器

语法： 无返回值 _调节器_调节钮被按下 （按钮值）

参数名 | 描 述
按钮值 | 整数型；如果按下的是调节器的向上箭头按钮，参数值为 1，否则为 -1。

示例：


通用对话框

通用对话框 功能型窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
类型 | 标题 | 文件名 | 过滤器
初始过滤器 | 初始目录 | 默认文件后缀 | 创建时提示
文件必须存在 | 文件覆盖提示 | 目录必须存在 | 不改变目录
字体颜色 | 加粗 | 倾斜 | 删除线
下划线 | 字体名称 | 字体大小 | 帮助文件名
帮助命令 | 帮助标志值 |  |

方法：

打开


类型 (通用对话框)

类型 属性 所属对象：通用对话框

数据类型：整数型；

可供选择的属性值：
0、打开文件
1、保存文件
2、字体选择
3、打开帮助

示例：

参见： 示例的书写格式、基本数据类型


标题 (通用对话框)

标题 属性 所属对象：通用对话框

数据类型：文本型；仅适用于打开文件和保存文件对话框。

示例：

参见： 示例的书写格式、基本数据类型


文件名 (通用对话框)

文件名 属性 所属对象：通用对话框

数据类型：文本型；从本属性中读取的文件名包括驱动器符和全路径目录，同时本属性也用作初始对话框中的文件名编辑框。

示例：

参见： 示例的书写格式、基本数据类型


过滤器 (通用对话框)

过滤器 属性 所属对象：通用对话框

数据类型：文本型；过滤器文本由单个或多个成对的文本串组成，每对文本串的第一个描述显示形式，如：“文本文件（*.txt）”；第二个指定实际的过滤匹配符，如：“*.txt”，所有各文本串之间用“|”号隔开。

示例：

参见： 示例的书写格式、基本数据类型


初始过滤器 (通用对话框)

初始过滤器 属性 所属对象：通用对话框

数据类型：整数型；指定初始的过滤器，0为第一个过滤器。

示例：

参见： 示例的书写格式、基本数据类型


初始目录 (通用对话框)

初始目录 属性 所属对象：通用对话框

数据类型：文本型；指定当打开对话框时所自动跳转到的目录。

示例：

参见： 示例的书写格式、基本数据类型


默认文件后缀 (通用对话框)

默认文件后缀 属性 所属对象：通用对话框

数据类型：文本型；指定当用户没有输入文件的后缀名称时所自动使用的文件后缀名称。

示例：

参见： 示例的书写格式、基本数据类型


创建时提示 (通用对话框)

创建时提示 属性 所属对象：通用对话框

数据类型：逻辑型；当类型为打开文件对话框时，如果用户指定了一个不存在的文件名称，是否提示用户即将创建它。

示例：

参见： 示例的书写格式、基本数据类型


文件必须存在 (通用对话框)

文件必须存在 属性 所属对象：通用对话框

数据类型：逻辑型；当类型为打开文件对话框时，是否允许用户指定一个不存在的文件。

示例：

参见： 示例的书写格式、基本数据类型


文件覆盖提示 (通用对话框)

文件覆盖提示 属性 所属对象：通用对话框

数据类型：逻辑型；当类型为保存文件对话框时，如果用户指定了一个已经存在的文件，是否询问用户确定覆盖此文件。

示例：

参见： 示例的书写格式、基本数据类型


目录必须存在 (通用对话框)

目录必须存在 属性 所属对象：通用对话框

数据类型：逻辑型；是否允许用户指定一个不存在的目录。

示例：

参见： 示例的书写格式、基本数据类型


不改变目录 (通用对话框)

不改变目录 属性 所属对象：通用对话框

数据类型：逻辑型；在对话框关闭后是否自动返回到进入对话框时的文件目录。

示例：

参见： 示例的书写格式、基本数据类型


字体颜色 (通用对话框)

字体颜色 属性 所属对象：通用对话框

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


加粗 (通用对话框)

加粗 属性 所属对象：通用对话框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


倾斜 (通用对话框)

倾斜 属性 所属对象：通用对话框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


删除线 (通用对话框)

删除线 属性 所属对象：通用对话框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


下划线 (通用对话框)

下划线 属性 所属对象：通用对话框

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


字体名称 (通用对话框)

字体名称 属性 所属对象：通用对话框

数据类型：文本型；如果不指定字体名称和字体大小，将自动使用标准的Windows图形字体。如果指定了字体大小但没有指定字体名称，将自动使用“宋体”。

示例：

参见： 示例的书写格式、基本数据类型


字体大小 (通用对话框)

字体大小 属性 所属对象：通用对话框

数据类型：整数型；如果不指定字体名称和字体大小，将自动使用标准的Windows图形字体。

示例：

参见： 示例的书写格式、基本数据类型


帮助文件名 (通用对话框)

帮助文件名 属性 所属对象：通用对话框

数据类型：文本型；指定欲打开帮助文件的名称，如果没有指定帮助文件，将使用默认帮助文件名称，即本易程序的文件名称（不含其后缀）＋“.hlp”后缀。

示例：

参见： 示例的书写格式、基本数据类型


帮助命令 (通用对话框)

帮助命令 属性 所属对象：通用对话框

数据类型：整数型；

可供选择的属性值：
0、显示帮助主题
1、显示指定标志信息
2、弹出指定标志信息
3、确定帮助已显示
4、显示帮助软件使用方法
5、退出帮助

示例：

参见： 示例的书写格式、基本数据类型


帮助标志值 (通用对话框)

帮助标志值 属性 所属对象：通用对话框

数据类型：整数型；仅在帮助命令为“显示指定标志信息”和“弹出指定标志信息”时才有效，用于指定相应的帮助标志数值。

示例：

参见： 示例的书写格式、基本数据类型


打开 (通用对话框)

打开 方法 所属对象：通用对话框

打开当前类型的对话框，返回一个逻辑值。对于类型为“打开文件”、“保存文件”、“字体选择”的对话框，如果为真，表示用户已通过该对话框输入了有效数据，否则表示用户取消了该对话框，且没有输入任何有效数据。对于类型为“打开帮助”的对话框，如打开帮助成功则返回真，否则返回假。

语法： 逻辑型 通用对话框．打开 （）

示例：


时钟

时钟 功能型窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
时钟周期 |  |  |

自有事件：

周期事件


时钟周期 (时钟)

时钟周期 属性 所属对象：时钟

数据类型：整数型；指定时钟事件产生的周期，单位为毫秒。如果设定为0，则无时钟事件产生。

示例：

参见： 示例的书写格式、基本数据类型


周期事件 (时钟)

周期事件 事件 所属对象：时钟

每当经过了指定的时钟周期，将自动产生此事件。

语法： 无返回值 _时钟_周期事件 （）

示例：


打印机

打印机 功能型窗口单元 跳至：系统核心支持库

属性：

左边 | 顶边 | 宽度 | 高度
标记 | 可视 | 禁止 | 鼠标指针
绘画单位 | 画笔类型 | 画出方式 | 画笔粗细
画笔颜色 | 刷子类型 | 刷子颜色 | 文本颜色
文本背景颜色 | 字体 | 打印作业名 | 打印份数
多份打印方式 | 最小页号 | 最大页号 | 首页页号
末页页号 | 打印选择区 | 左边空 | 顶边空
右边空 | 底边空 | 当前页号 | 已打印份数
打印区宽度 | 打印区高度 | 打印被中止 |

方法：

取设备句柄 | 开始打印 | 结束打印 | 取消打印
换页 | 开始下一份 | 画点 | 画直线
画椭圆 | 画弧线 | 画弦 | 画饼
画矩形 | 画渐变矩形 | 填充矩形 | 画圆角矩形
画多边形 | 置写出位置 | 写文本行 | 写出
定位写出 | 取宽度 | 取高度 | 画图片
取图片宽度 | 取图片高度 |  |


绘画单位 (打印机)

绘画单位 属性 所属对象：打印机

数据类型：整数型；本属性指定绘画时所使用的单位，坐标系的 X 轴从左到右，Y 轴从上到下。

可供选择的属性值：
0、像素点
1、0.1毫米
2、0.01毫米
3、0.01英寸
4、0.001英寸
5、1/1440英寸

示例：

参见： 示例的书写格式、基本数据类型


画笔类型 (打印机)

画笔类型 属性 所属对象：打印机

数据类型：整数型；

可供选择的属性值：
0、空笔
1、直线
2、划线
3、点线
4、点划线
5、双点划线
6、内直线

示例：

参见： 示例的书写格式、基本数据类型


画出方式 (打印机)

画出方式 属性 所属对象：打印机

数据类型：整数型；有关各种画出方式的说明为： 0、黑色：始终画出黑色；1、非或笔：或笔的相反；2、与非笔：背景色以及画笔反相二者共有颜色的组合；3、非复制笔：复制笔的相反；4、与笔非：画笔以及已有颜色反相二者共有颜色的组合；5、反转：已有颜色的反相；6、异或笔：画笔的颜色以及已有颜色的组合，只取其一；7、非与笔：与笔的相反；8、与笔：画笔和已有二者共有颜色的组合；9、非异或笔：异或笔的相反；10、无操作：原有保持不变。该设置实际上关闭画笔；11、或非笔：已有颜色与画笔颜色反相的组合；12、复制笔（缺省值）：画笔颜色；13、或笔非：画笔颜色与已有颜色的反相的组合；14、或笔：画笔颜色与已有颜色的组合；15、白色：始终画出白色。

可供选择的属性值：
0、黑色
1、非或笔
2、与非笔
3、非复制笔
4、与笔非
5、反转
6、异或笔
7、非与笔
8、与笔
9、非异或笔
10、无操作
11、或非笔
12、复制笔
13、或笔非
14、或笔
15、白色

示例：

参见： 示例的书写格式、基本数据类型


画笔粗细 (打印机)

画笔粗细 属性 所属对象：打印机

数据类型：整数型；使用现行绘画单位，如果为0，表示画笔的粗细为一个像素点。注意：当画笔类型为划线、点线、点划线、双点划线时，本属性无效，画笔宽度始终为一个像素点。

示例：

参见： 示例的书写格式、基本数据类型


画笔颜色 (打印机)

画笔颜色 属性 所属对象：打印机

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


刷子类型 (打印机)

刷子类型 属性 所属对象：打印机

数据类型：整数型；各种格式刷子将使用当前文本背景颜色作为刷子背景颜色。

可供选择的属性值：
0、空刷子
1、颜色刷子
2、右斜线
3、直交叉线
4、斜交叉线
5、左斜线
6、横线
7、竖线
8、5%色点
9、10%色点
10、20%色点
11、25%色点
12、30%色点
13、40%色点
14、50%色点
15、60%色点
16、70%色点
17、75%色点
18、80%色点
19、90%色点
20、浅色上对角线
21、浅色下对角线
22、深色上对角线
23、深色下对角线
24、宽上对角线
25、宽下对角线
26、浅色竖线
27、浅色横线
28、窄竖线
29、窄横线
30、深色竖线
31、深色横线
32、上对角虚线
33、下对角虚线
34、横虚线
35、竖虚线
36、小纸屑
37、大纸屑
38、之字形
39、波浪线
40、对角砖形
41、横向砖形
42、纺织物
43、方格呢
44、草皮
45、虚格线
46、点式菱形
47、瓦形
48、棚架
49、球体
50、小网格
51、大网格
52、小棋盘
53、大棋盘
54、空心菱形
55、实心菱形

示例：

参见： 示例的书写格式、基本数据类型


刷子颜色 (打印机)

刷子颜色 属性 所属对象：打印机

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


文本颜色 (打印机)

文本颜色 属性 所属对象：打印机

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


文本背景颜色 (打印机)

文本背景颜色 属性 所属对象：打印机

数据类型：整数型；

示例：

参见： 示例的书写格式、基本数据类型


字体 (打印机)

字体 属性 所属对象：打印机

数据类型：字体；

示例：

参见： 示例的书写格式、基本数据类型


打印作业名 (打印机)

打印作业名 属性 所属对象：打印机

数据类型：文本型；在打印过程中，本属性的内容将显示在由系统自动提供的打印状态对话框及 Windows 打印管理器中。如果为空，默认为“未命名打印作业”。

示例：

参见： 示例的书写格式、基本数据类型


打印份数 (打印机)

打印份数 属性 所属对象：打印机

数据类型：整数型；本属性用作为打印设置对话框中的打印份数编辑框提供初始值，当用户从打印设置对话框中确认返回后，属性值提供用户所实际设置的需要打印份数。需了解的是：如果被选定打印机硬件支持多份拷贝功能，无论用户设置打印份数为多少，打印设置对话框永远返回 1 ，多份打印被转交给打印机硬件去自动完成。如果在进入打印设置对话框前置属性值为 -1 ，表明现行易程序不支持多份打印，此时系统会自动检查当前所选择打印机硬件，如果该打印机硬件支持多份拷贝，将允许用户指定打印份数并启用硬件多份拷贝功能，否则不允许，打印设置对话框返回后属性值保持不变。如果使用“开始打印”方法进入打印时没有调用打印设置对话框，本属性值保持不变。

示例：

参见： 示例的书写格式、基本数据类型


多份打印方式 (打印机)

多份打印方式 属性 所属对象：打印机

数据类型：逻辑型；本属性用作为打印设置对话框中“份数”组中的“分页”选择框提供初始值，当用户从打印设置对话框中确认返回后，属性值提供用户所实际设置的值。如果使用“开始打印”方法进入打印时没有调用打印设置对话框，本属性值保持不变。

示例：

参见： 示例的书写格式、基本数据类型


最小页号 (打印机)

最小页号 属性 所属对象：打印机

数据类型：整数型；本属性用作为打印设置对话框提供最小页号值，如果在进入打印设置对话框前置属性值为 -1 ，打印设置对话框中将不允许用户设置页打印范围。如果使用“开始打印”方法进入打印时没有调用打印设置对话框，本属性值保持不变。

示例：

参见： 示例的书写格式、基本数据类型


最大页号 (打印机)

最大页号 属性 所属对象：打印机

数据类型：整数型；本属性用作为打印设置对话框提供最大页号值。如果置为 -1 ，表示最大页号不受限制。如果“最小页号”属性值被置为 -1 ，本属性无意义。如果使用“开始打印”方法进入打印时没有调用打印设置对话框，本属性值保持不变。

示例：

参见： 示例的书写格式、基本数据类型


首页页号 (打印机)

首页页号 属性 所属对象：打印机

数据类型：整数型；本属性用作为打印设置对话框中的首打印页页号编辑框提供初始值，当用户从打印设置对话框中确认返回后，属性值提供用户所实际设置的首打印页号，此值将在“最小页号”属性值及“最大页号”属性值之间。但如果用户选择了全部打印或者打印选择区，本属性值将为 -1 。如果“最小页号”属性值被置为 -1 ，本属性无意义。如果使用“开始打印”方法进入打印时没有调用打印设置对话框，本属性值保持不变。

示例：

参见： 示例的书写格式、基本数据类型


末页页号 (打印机)

末页页号 属性 所属对象：打印机

数据类型：整数型；本属性用作为打印设置对话框中的末打印页页号编辑框提供初始值，如果置为 -1 ，表示不提供。当用户从打印设置对话框中确认返回后，属性值提供用户所实际设置的末打印页号，此值将在“首页页号”属性值及“最大页号”属性值之间。但如果用户选择了全部打印或者打印选择区，本属性值将为 -1 。如果“最小页号”属性值被置为 -1 ，本属性无意义。如果使用“开始打印”方法进入打印时没有调用打印设置对话框，本属性值保持不变。

示例：

参见： 示例的书写格式、基本数据类型


打印选择区 (打印机)

打印选择区 属性 所属对象：打印机

数据类型：整数型；本属性用作为打印设置对话框中“选择的范围”选择框提供初始值，为 1 表示真，为 0 表示假。当用户从打印设置对话框中确认返回后，属性值提供用户所实际设置的值。如果在进入打印设置对话框前置属性值为 -1 ，打印设置对话框中将不允许用户选取该选择框。如果使用“开始打印”方法进入打印时没有调用打印设置对话框，本属性值保持不变。

示例：

参见： 示例的书写格式、基本数据类型


左边空 (打印机)

左边空 属性 所属对象：打印机

数据类型：整数型；本属性指定打印时打印纸左边所留空白的尺寸，使用现行绘画单位，由系统自动提供支持。

示例：

参见： 示例的书写格式、基本数据类型


顶边空 (打印机)

顶边空 属性 所属对象：打印机

数据类型：整数型；本属性指定打印时打印纸顶边所留空白的尺寸，使用现行绘画单位，由系统自动提供支持。

示例：

参见： 示例的书写格式、基本数据类型


右边空 (打印机)

右边空 属性 所属对象：打印机

数据类型：整数型；本属性指定打印时打印纸右边所留空白的尺寸，使用现行绘画单位，由系统自动提供支持。

示例：

参见： 示例的书写格式、基本数据类型


底边空 (打印机)

底边空 属性 所属对象：打印机

数据类型：整数型；本属性指定打印时打印纸底边所留空白的尺寸，使用现行绘画单位，由系统自动提供支持。

示例：

参见： 示例的书写格式、基本数据类型


当前页号 (打印机)

当前页号 属性 所属对象：打印机

数据类型：整数型；只读；本属性提供现行打印页的页号，由系统自行维护。页号值从“首页页号”属性值开始，如果“最小页号”属性值被置为 -1 ，页号值从 1 开始。在以下情况下属性值被自动增一： 1、使用“写文本行”方法打印一行文本并且要打印文本行的高度当前页容纳不下（此时将会首先自动换页）； 2、使用“换页”方法。本属性仅在打印作业过程中有效。

示例：

参见： 示例的书写格式、基本数据类型


已打印份数 (打印机)

已打印份数 属性 所属对象：打印机

数据类型：整数型；只读；本属性提供现行所已经打印的份数（含当前份），由系统自行维护。在调用“开始下一份”方法后，本属性值被自动加一。

示例：

参见： 示例的书写格式、基本数据类型


打印区宽度 (打印机)

打印区宽度 属性 所属对象：打印机

数据类型：整数型；只读；本属性提供了打印纸实际可打印区域宽度减去左右边空后的值，使用现行绘画单位，仅在打印作业过程中有效。

示例：

参见： 示例的书写格式、基本数据类型


打印区高度 (打印机)

打印区高度 属性 所属对象：打印机

数据类型：整数型；只读；本属性提供了打印纸实际可打印区域高度减去上下边空后的值，使用现行绘画单位，仅在打印作业过程中有效。

示例：

参见： 示例的书写格式、基本数据类型


打印被中止 (打印机)

打印被中止 属性 所属对象：打印机

数据类型：逻辑型；只读；如果在打印时使用了系统所提供的打印状态对话框，并且在打印过程中用户已经选择中止打印取消了打印作业（系统自动支持），本属性值为真，否则为假。易程序在进行打印的过程中一旦发现本属性值为真，应该退出此过程。

示例：

参见： 示例的书写格式、基本数据类型


取设备句柄 (打印机)

取设备句柄 方法 所属对象：打印机

为高级用户提供，初级用户无需掌握；
如当前用户程序正在进行打印作业，则返回对应的打印机设备句柄（即HDC），否则返回 0。

语法： 整数型 打印机．取设备句柄 （）

示例：


开始打印 (打印机)

开始打印 方法 所属对象：打印机

返回真表示已经成功地进入了打印作业，进入打印作业后文本写出位置将被重置为 0 。如果执行本命令时已经在打印作业中或者用户在打印设置对话框中选择了取消，返回假。进入打印后必须调用“结束打印”或者“取消打印”方法来退出打印。进入打印前易程序进行的所有打印绘画操作都将被忽略。

语法： 逻辑型 打印机．开始打印 （［是否调用打印设置对话框］，［是否显示打印状态对话框］）

参数名 | 描 述
是否调用打印设置对话框 | 可选的；逻辑型。指定在进入打印之前是否先调用打印设置对话框对打印机及相关打印参数进行设置。如省略本参数，默认为真。如果参数值为假，将自动使用 Windows 系统默认打印机，但如果取 Windows 系统默认打印机失败，仍然会调用打印设置对话框。
是否显示打印状态对话框 | 可选的；逻辑型。指定在打印过程中是否显示由系统自动提供的打印状态对话框。用户如果在该打印状态对话框中选择了取消打印，系统将自动中止并取消该打印作业，并置“打印被中止”属性值为真。如省略本参数，默认为真。

示例：


结束打印 (打印机)

结束打印 方法 所属对象：打印机

如果当前已经进入了打印作业，调用本命令可完成此作业。结束打印后易程序进行的后续打印绘画操作都将被忽略。

语法： 无返回值 打印机．结束打印 （）

示例：


取消打印 (打印机)

取消打印 方法 所属对象：打印机

如果当前已经进入了打印作业，调用本命令可立即中止且取消该作业。如果操作系统的打印管理器正在处理该打印作业（打印管理器正在运行并且允许后台打印），那么该作业将被删除且使打印机不接收任何信息。如果打印管理器不是正在处理该作业（没有选用后台打印），部分或全部数据可能在此之前已发送到打印机。此时，打印机驱动程序将尽可能使打印机立即复位并终止该作业。取消打印后易程序进行的后续打印绘画操作都将被忽略。

语法： 无返回值 打印机．取消打印 （）

示例：


换页 (打印机)

换页 方法 所属对象：打印机

调用本命令使打印机完成当前页的打印，文本写出位置被重置为 0 ，并走纸到下一页左上角。如果换页成功返回真，否则将自动取消打印并返回假。

语法： 逻辑型 打印机．换页 （）

示例：


开始下一份 (打印机)

开始下一份 方法 所属对象：打印机

调用本命令后将结束在当前页上的打印作业，并将当前打印份数加一，当前页号置回到首页页号，以进入下一份拷贝的打印。如果成功返回真，失败将自动取消打印并返回假。

语法： 逻辑型 打印机．开始下一份 （）

示例：


画点 (打印机)

画点 方法 所属对象：打印机

语法： 无返回值 打印机．画点 （点横坐标，点纵坐标，欲画入点的颜色值）

参数名 | 描 述
点横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
点纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
欲画入点的颜色值 | 必需的；整数型。

示例：


画直线 (打印机)

画直线 方法 所属对象：打印机

使用画笔在画板上画出一条直线。

语法： 无返回值 打印机．画直线 （起始点横坐标，起始点纵坐标，结束点横坐标，结束点纵坐标）

参数名 | 描 述
起始点横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
起始点纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
结束点横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
结束点纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画椭圆 (打印机)

画椭圆 方法 所属对象：打印机

语法： 无返回值 打印机．画椭圆 （椭圆左上角横坐标，椭圆左上角纵坐标，椭圆右下角横坐标，椭圆右下角纵坐标）

参数名 | 描 述
椭圆左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画弧线 (打印机)

画弧线 方法 所属对象：打印机

使用画笔在画板上画出一条弧线。

语法： 无返回值 打印机．画弧线 （椭圆左上角横坐标，椭圆左上角纵坐标，椭圆右下角横坐标，椭圆右下角纵坐标，弧线起始点横坐标，弧线起始点纵坐标，弧线终止点横坐标，弧线终止点纵坐标）

参数名 | 描 述
椭圆左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点横坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点纵坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点横坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点纵坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画弦 (打印机)

画弦 方法 所属对象：打印机

语法： 无返回值 打印机．画弦 （椭圆左上角横坐标，椭圆左上角纵坐标，椭圆右下角横坐标，椭圆右下角纵坐标，弧线起始点横坐标，弧线起始点纵坐标，弧线终止点横坐标，弧线终止点纵坐标）

参数名 | 描 述
椭圆左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点横坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点纵坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点横坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点纵坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画饼 (打印机)

画饼 方法 所属对象：打印机

语法： 无返回值 打印机．画饼 （椭圆左上角横坐标，椭圆左上角纵坐标，椭圆右下角横坐标，椭圆右下角纵坐标，弧线起始点横坐标，弧线起始点纵坐标，弧线终止点横坐标，弧线终止点纵坐标）

参数名 | 描 述
椭圆左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
椭圆右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点横坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线起始点纵坐标 | 必需的；整数型。弧线从椭圆中心点至此起始点的直线与椭圆圆弧相交处开始绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点横坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。
弧线终止点纵坐标 | 必需的；整数型。弧线在椭圆中心点至此终止点的直线与椭圆圆弧相交处结束绘制。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画矩形 (打印机)

画矩形 方法 所属对象：打印机

使用画笔在画板上画出一个矩形，矩形的内部使用刷子填充。

语法： 无返回值 打印机．画矩形 （矩形左上角横坐标，矩形左上角纵坐标，矩形右下角横坐标，矩形右下角纵坐标）

参数名 | 描 述
矩形左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画渐变矩形 (打印机)

画渐变矩形 方法 所属对象：打印机

语法： 无返回值 打印机．画渐变矩形 （矩形区域左边，矩形区域顶边，矩形区域宽度，矩形区域高度，［渐变方向］，首渐变颜色，其它渐变颜色，… ）

参数名 | 描 述
矩形区域左边 | 必需的；整数型。
矩形区域顶边 | 必需的；整数型。
矩形区域宽度 | 必需的；整数型。
矩形区域高度 | 必需的；整数型。
渐变方向 | 可选的；整数型。参数值可以为以下常量值之一： 1、#从上到下； 2、#从左到右； 3、从左上到右下； 4、从右上到左下； 5、从下到上； 6、从右到左； 7、从右下到左上； 8、从左下到右上。 如果本参数被省略，默认为“#从左到右”。
首渐变颜色 | 必需的；整数型。
其它渐变颜色 | 必需的；可扩充的；整数型。

示例：


填充矩形 (打印机)

填充矩形 方法 所属对象：打印机

将画板上指定的矩形区域用当前刷子填充。

语法： 无返回值 打印机．填充矩形 （矩形左上角横坐标，矩形左上角纵坐标，矩形右下角横坐标，矩形右下角纵坐标）

参数名 | 描 述
矩形左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


画圆角矩形 (打印机)

画圆角矩形 方法 所属对象：打印机

使用画笔在画板上画出一个圆角矩形，圆角矩形的内部使用刷子填充。

语法： 无返回值 打印机．画圆角矩形 （矩形左上角横坐标，矩形左上角纵坐标，矩形右下角横坐标，矩形右下角纵坐标，圆角宽度）

参数名 | 描 述
矩形左上角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形左上角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角横坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
矩形右下角纵坐标 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
圆角宽度 | 必需的；整数型。使用当前绘画单位。

示例：


画多边形 (打印机)

画多边形 方法 所属对象：打印机

语法： 无返回值 打印机．画多边形 （多边形顶点，［顶点数目］）

参数名 | 描 述
多边形顶点 | 必需的；整数型，参数数据只能提供数组数据。本参数数组顺序记录多边形各顶点的横向及纵向坐标值。使用当前绘画单位，相对于画板或打印纸左上角。
顶点数目 | 可选的；整数型。本参数指定多边形顶点的总数目。如果被省略，默认为数组中所记录的顶点数目。

示例：


置写出位置 (打印机)

置写出位置 方法 所属对象：打印机

设置下次使用“写文本行”或“写出”命令输出数据时的位置。

语法： 无返回值 打印机．置写出位置 （［横向写出位置］，［纵向写出位置］）

参数名 | 描 述
横向写出位置 | 可选的；整数型。如果本参数被省略，则使用现行横向写出位置。使用当前绘画单位，相对于画板或打印纸左上角。
纵向写出位置 | 可选的；整数型。如果本参数被省略，则使用现行纵向写出位置。使用当前绘画单位，相对于画板或打印纸左上角。

示例：


写文本行 (打印机)

写文本行 方法 所属对象：打印机

在当前写出位置写出指定的文本、数值、逻辑值或日期时间，并将现行写出位置调整到下行行首。支持自动换页。

语法： 无返回值 打印机．写文本行 （［欲写出数据］，… ）

参数名 | 描 述
欲写出数据 | 可选的；可扩充的；通用型。参数值只能为文本、数值、逻辑值或日期时间。如果本参数被省略，则写出一个空行。

示例：


写出 (打印机)

写出 方法 所属对象：打印机

在当前写出位置处写出指定的文本、数值、逻辑值或日期时间。自动调整现行写出位置到所写出数据的末位置。

语法： 无返回值 打印机．写出 （［欲写出数据］，… ）

参数名 | 描 述
欲写出数据 | 可选的；可扩充的；通用型。参数值只能为文本、数值、逻辑值或日期时间。如果本参数被省略，则写出一个空行。

示例：


定位写出 (打印机)

定位写出 方法 所属对象：打印机

在指定写出位置处写出指定的文本、数值、逻辑值或日期时间，不改变现行写出位置。

语法： 无返回值 打印机．定位写出 （［横向写出位置］，［纵向写出位置］，欲写出数据，… ）

参数名 | 描 述
横向写出位置 | 可选的；整数型。如果本参数被省略，则使用现行横向写出位置。使用当前绘画单位，相对于画板或打印纸左上角。
纵向写出位置 | 可选的；整数型。如果本参数被省略，则使用现行纵向写出位置。使用当前绘画单位，相对于画板或打印纸左上角。
欲写出数据 | 必需的；可扩充的；通用型。参数值只能为文本、数值、逻辑值或日期时间。

示例：


取宽度 (打印机)

取宽度 方法 所属对象：打印机

返回指定数据的写出宽度，使用当前绘画单位。如果调用本命令时尚未进入打印，将返回 0 。

语法： 整数型 打印机．取宽度 （欲取其宽度或高度的数据）

参数名 | 描 述
欲取其宽度或高度的数据 | 必需的；通用型。参数值只能为文本、数值、逻辑值或日期时间。

示例：


取高度 (打印机)

取高度 方法 所属对象：打印机

返回指定数据的写出高度，使用当前绘画单位。如果调用本命令时尚未进入打印，将返回 0 。

语法： 整数型 打印机．取高度 （欲取其宽度或高度的数据）

参数名 | 描 述
欲取其宽度或高度的数据 | 必需的；通用型。参数值只能为文本、数值、逻辑值或日期时间。

示例：


画图片 (打印机)

画图片 方法 所属对象：打印机

语法： 无返回值 打印机．画图片 （图片号，图片左边画出位置，图片顶边画出位置，［图片画出宽度］，［图片画出高度］，［图片画出方法］）

参数名 | 描 述
图片号 | 必需的；整数型。参数值必须为调用“载入图片”命令所返回的图片号。
图片左边画出位置 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
图片顶边画出位置 | 必需的；整数型。使用当前绘画单位，相对于画板或打印纸左上角。
图片画出宽度 | 可选的；整数型。如果本参数被省略，则使用图片本身的宽度。使用当前绘画单位。
图片画出高度 | 可选的；整数型。如果本参数被省略，则使用图片本身的高度。使用当前绘画单位。
图片画出方法 | 可选的；整数型。本参数定义在将图像绘制到对象（画板 / 打印机）上时对图像执行的位操作。对“图标”类型图片无效。可以为以下常量值之一或者其它自定义操作码： 1、#拷贝； 2、#翻转拷贝； 3、#位异或； 4、#位或； 5、#位与 如果省略本参数，默认为“#拷贝”。

示例：


取图片宽度 (打印机)

取图片宽度 方法 所属对象：打印机

返回指定图片的宽度。如果调用本命令时尚未进入打印，使用像素点为单位，否则使用当前绘画单位。

语法： 整数型 打印机．取图片宽度 （图片号）

参数名 | 描 述
图片号 | 必需的；整数型。参数值必须为调用“载入图片”命令所返回的图片号。

示例：


取图片高度 (打印机)

取图片高度 方法 所属对象：打印机

返回指定图片的高度。如果调用本命令时尚未进入打印，使用像素点为单位，否则使用当前绘画单位。

语法： 整数型 打印机．取图片高度 （图片号）

参数名 | 描 述
图片号 | 必需的；整数型。参数值必须为调用“载入图片”命令所返回的图片号。

示例：


报表

报表 包容型报表单元 跳至：系统核心支持库


菜单

菜单 数据类型 跳至：系统核心支持库

用作指定某一个菜单项目。

属性：

标题 选中 禁止 可视

自有事件：

被选择


标题 (菜单)

标题 属性 所属对象：菜单

数据类型：文本型；

示例：

参见： 示例的书写格式、基本数据类型


选中 (菜单)

选中 属性 所属对象：菜单

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


禁止 (菜单)

禁止 属性 所属对象：菜单

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


可视 (菜单)

可视 属性 所属对象：菜单

数据类型：逻辑型；

示例：

参见： 示例的书写格式、基本数据类型


被选择 (菜单)

被选择 事件 所属对象：菜单

当菜单项被用户选择后即产生此事件。

语法： 无返回值 _菜单_被选择 （）

示例：


字体

字体 数据类型 跳至：系统核心支持库

成员 | 描 述
角度 | 整数型；以 1 / 10 度为单位。
加粗 | 逻辑型；
倾斜 | 逻辑型；
删除线 | 逻辑型；
下划线 | 逻辑型；
字体大小 | 整数型；初始值为 9 。单位为点（1 / 72 英寸）。
字体名称 | 文本型；初始值为“宋体”。

示例：

参见： 示例的书写格式、基本数据类型


字段信息

字段信息 数据类型 跳至：系统核心支持库

成员 | 描 述
名称 | 文本型；名称文本的长度必须在 16 个字符以内。
类型 | 整数型；可以为以下常量值之一： 1、#字节型； 2、#短整数型； 3、#整数型； 4、#长整数型； 5、#小数型； 6、#双精度小数型； 7、#逻辑型； 8、#日期时间型； 10、#文本型； 11、#字节集型； 12、#备注型。
最大文本长度 | 整数型；初始值为 20 。本成员仅当字段类型为“文本型”时才有效，用作指定文本的最大可能长度，其值范围必须在 1 到 512 之间。如果字段类型不为“文本型”，本成员将被忽略。

示例：

参见： 示例的书写格式、基本数据类型


鼠标左键被按下

鼠标左键被按下 系统基本事件

处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去；如果不返回值或返回真，则将此事件继续传递到所属对象上去。

语法： 逻辑型 _窗口单元_鼠标左键被按下 （横向位置，纵向位置，功能键状态）

参数名 | 描 述
横向位置 | 整数型；指示鼠标在当前所处窗口单元中的横向位置。
纵向位置 | 整数型；指示鼠标在当前所处窗口单元中的纵向位置。
功能键状态 | 整数型；用于查看各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。

示例：


鼠标左键被放开

鼠标左键被放开 系统基本事件

处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去；如果不返回值或返回真，则将此事件继续传递到所属对象上去。

语法： 逻辑型 _窗口单元_鼠标左键被放开 （横向位置，纵向位置，功能键状态）

参数名 | 描 述
横向位置 | 整数型；指示鼠标在当前所处窗口单元中的横向位置。
纵向位置 | 整数型；指示鼠标在当前所处窗口单元中的纵向位置。
功能键状态 | 整数型；用于查看各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。

示例：


被双击

被双击 系统基本事件

处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去；如果不返回值或返回真，则将此事件继续传递到所属对象上去。

语法： 逻辑型 _窗口单元_被双击 （横向位置，纵向位置，功能键状态）

参数名 | 描 述
横向位置 | 整数型；指示鼠标在当前所处窗口单元中的横向位置。
纵向位置 | 整数型；指示鼠标在当前所处窗口单元中的纵向位置。
功能键状态 | 整数型；用于查看各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。

示例：


鼠标右键被按下

鼠标右键被按下 系统基本事件

处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去；如果不返回值或返回真，则将此事件继续传递到所属对象上去。

语法： 逻辑型 _窗口单元_鼠标右键被按下 （横向位置，纵向位置，功能键状态）

参数名 | 描 述
横向位置 | 整数型；指示鼠标在当前所处窗口单元中的横向位置。
纵向位置 | 整数型；指示鼠标在当前所处窗口单元中的纵向位置。
功能键状态 | 整数型；用于查看各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。

示例：


鼠标右键被放开

鼠标右键被放开 系统基本事件

处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去；如果不返回值或返回真，则将此事件继续传递到所属对象上去。

语法： 逻辑型 _窗口单元_鼠标右键被放开 （横向位置，纵向位置，功能键状态）

参数名 | 描 述
横向位置 | 整数型；指示鼠标在当前所处窗口单元中的横向位置。
纵向位置 | 整数型；指示鼠标在当前所处窗口单元中的纵向位置。
功能键状态 | 整数型；用于查看各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。

示例：


鼠标位置被移动

鼠标位置被移动 系统基本事件

处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去；如果不返回值或返回真，则将此事件继续传递到所属对象上去。

语法： 逻辑型 _窗口单元_鼠标位置被移动 （横向位置，纵向位置，功能键状态）

参数名 | 描 述
横向位置 | 整数型；指示鼠标在当前所处窗口单元中的横向位置。
纵向位置 | 整数型；指示鼠标在当前所处窗口单元中的纵向位置。
功能键状态 | 整数型；用于查看各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。

示例：


获得焦点

获得焦点 系统基本事件

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

语法： 无返回值 _窗口单元_获得焦点 （）

示例：


失去焦点

失去焦点 系统基本事件

当对象失去输入焦点时产生本事件。

语法： 无返回值 _窗口单元_失去焦点 （）

示例：


按下某键

按下某键 系统基本事件

此事件当用户按下一个键时发生。处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去；如果不返回值或返回真，则将此事件继续传递到所属对象上去。

语法： 逻辑型 _窗口单元_按下某键 （键代码，功能键状态）

参数名 | 描 述
键代码 | 整数型；为键常量值，如：“#F1键”、“#回车键” 等等。具体所有的键常量见库常量表。
功能键状态 | 整数型；用于查看在按下本键的同时各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。

示例：


放开某键

放开某键 系统基本事件

此事件当用户放开以前按下的一个键时发生。处理本事件的子程序如果返回假，则取消本事件，不再将此事件传递到所属对象上去；如果不返回值或返回真，则将此事件继续传递到所属对象上去。

语法： 逻辑型 _窗口单元_放开某键 （键代码，功能键状态）

参数名 | 描 述
键代码 | 整数型；为键常量值，如：“#F1键”、“#回车键” 等等。具体所有的键常量见库常量表。
功能键状态 | 整数型；用于查看在按下本键的同时各功能键是否被同时按下。可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态。要判断是否同时按下了某个功能键，在此参数的值与想要得知的功能键的状态常量值之间使用“位与”命令进行比较。如果所得的结果不为零，则表示同时按下了此功能键。

示例：


字符输入

字符输入 系统基本事件

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

语法： 整数型 _窗口单元_字符输入 （字符代码）

参数名 | 描 述
字符代码 | 整数型；表明所按下的字符键所对应的字符代码，可以使用“字符”命令取出所对应的具体字符。

示例：


G:\APP\E\DOC\krnlcnst.htm

常用文本常量
常量 | 常量值 | 描 述
#引号 | “"” | 半角双引号。 例： #引号 + "飞扬" + #引号
#左引号 | ““” | 全角左双引号。 例： #左引号 + "飞扬" + #右引号
#右引号 | “”” | 全角右双引号。
#换行符 | “字符（13）+字符（10）” | 一个回车符（13）和一个换行符（10）的组合。 例： "文本行1" + #换行符 + "文本行2"
常用数值常量
常量 | 常量值 | 描 述
#pi | 3.1415926535 |
#e | 2.718282 |
常用颜色值常量 (可以在程序中所有需要颜色值的地方使用)
常量 | 常量值 | 描 述
#黑色 | 0 | 例： 标签1.背景颜色 = #黑色
#藏青 | 8388608 |
#墨绿 | 32768 |
#深青 | 8421376 |
#红褐 | 128 |
#紫红 | 8388736 |
#褐绿 | 32896 |
#浅灰 | 12632256 |
#灰色 | 8421504 |
#蓝色 | 16711680 |
#绿色 | 65280 |
#艳青 | 16776960 |
#红色 | 255 |
#品红 | 16711935 |
#黄色 | 65535 |
#白色 | 16777215 |
#蓝灰 | 16744576 |
#藏蓝 | 14692440 |
#嫩绿 | 57472 |
#青绿 | 8445952 |
#黄褐 | 24768 |
#粉红 | 16754943 |
#嫩黄 | 55512 |
#银白 | 15527148 |
#紫色 | 16711824 |
#天蓝 | 16746496 |
#灰绿 | 8429696 |
#青蓝 | 12607488 |
#橙黄 | 33023 |
#桃红 | 8409343 |
#芙红 | 12615935 |
#深灰 | 6316128 |
#透明 | 4278190080 |
按键代码值常量 (窗口单元按键事件中的键代码即为此处的常量值)
常量 | 常量值 | 描 述
#键0 | 48 | 例： 如果真 （键代码 = #键0）
#键1 | 49 |
#键2 | 50 |
#键3 | 51 |
#键4 | 52 |
#键5 | 53 |
#键6 | 54 |
#键7 | 55 |
#键8 | 56 |
#键9 | 57 |
#A键 | 65 |
#B键 | 66 |
#C键 | 67 |
#D键 | 68 |
#E键 | 69 |
#F键 | 70 |
#G键 | 71 |
#H键 | 72 |
#I键 | 73 |
#J键 | 74 |
#K键 | 75 |
#L键 | 76 |
#M键 | 77 |
#N键 | 78 |
#O键 | 79 |
#P键 | 80 |
#Q键 | 81 |
#R键 | 82 |
#S键 | 83 |
#T键 | 84 |
#U键 | 85 |
#V键 | 86 |
#W键 | 87 |
#X键 | 88 |
#Y键 | 89 |
#Z键 | 90 |
#F1键 | 112 |
#F2键 | 113 |
#F3键 | 114 |
#F4键 | 115 |
#F5键 | 116 |
#F6键 | 117 |
#F7键 | 118 |
#F8键 | 119 |
#F9键 | 120 |
#F10键 | 121 |
#F11键 | 122 |
#F12键 | 123 |
#F13键 | 124 |
#F14键 | 125 |
#F15键 | 126 |
#F16键 | 127 |
#Break键 | 3 |
#退格键 | 8 |
#Tab键 | 9 |
#回车键 | 13 |
#Shift键 | 16 |
#Ctrl键 | 17 |
#Alt键 | 18 |
#Pause键 | 19 |
#CapsLock键 | 20 |
#NumLock键 | 144 |
#ScrollLock键 | 145 |
#Esc键 | 27 |
#空格键 | 32 |
#PageUp键 | 33 |
#PageDown键 | 34 |
#Home键 | 36 |
#End键 | 35 |
#左光标键 | 37 |
#上光标键 | 38 |
#右光标键 | 39 |
#下光标键 | 40 |
#Ins键 | 45 |
#Del键 | 46 |
#分号键 | 186 |
#等号键 | 187 |
#逗号键 | 188 |
#减号键 | 189 |
#圆点键 | 190 |
#除号键 | 191 |
#反撇号键 | 192 |
#左中括号键 | 219 |
#右中括号键 | 221 |
#斜杠键 | 220 |
#单引号键 | 222 |
其它杂类常量 (由相关命令使用，此处不作了解)
常量 | 常量值 | 描 述
#隐藏窗口 | 1 |
#普通激活 | 2 |
#最小化激活 | 3 |
#最大化激活 | 4 |
#普通不激活 | 5 |
#最小化不激活 | 6 |
#读入 | 1 |
#写出 | 2 |
#读写 | 3 |
#重写 | 4 |
#改写 | 5 |
#改读 | 6 |
#无限制 | 1 |
#禁止读 | 2 |
#禁止写 | 3 |
#禁止读写 | 4 |
#文件首 | 1 |
#文件尾 | 2 |
#现行位置 | 3 |
#只读文件 | 1 |
#隐藏文件 | 2 |
#系统文件 | 4 |
#子目录 | 16 |
#存档文件 | 32 |
#无属性文件 | 128 |
#字节型 | 1 |
#短整数型 | 2 |
#整数型 | 3 |
#长整数型 | 4 |
#小数型 | 5 |
#双精度小数型 | 6 |
#逻辑型 | 7 |
#日期时间型 | 8 |
#子程序指针型 | 9 |
#文本型 | 10 |
#年份 | 1 |
#季度 | 2 |
#月份 | 3 |
#周 | 4 |
#自年首周数 | 4 |
#日 | 5 |
#小时 | 6 |
#分钟 | 7 |
#秒 | 8 |
#星期几 | 9 |
#自年首天数 | 10 |
#确认钮 | 0 | “信息框”命令使用。
#确认取消钮 | 1 |
#放弃重试忽略钮 | 2 |
#取消是否钮 | 3 |
#是否钮 | 4 |
#重试取消钮 | 5 |
#错误图标 | 16 |
#询问图标 | 32 |
#警告图标 | 48 |
#信息图标 | 64 |
#默认按钮一 | 0 |
#默认按钮二 | 256 |
#默认按钮三 | 512 |
#默认按钮四 | 768 |
#程序等待 | 0 |
#系统等待 | 4096 |
#位于前台 | 65536 |
#文本右对齐 | 524288 |
#取消钮 | 1 |
#放弃钮 | 2 |
#重试钮 | 3 |
#忽略钮 | 4 |
#是钮 | 5 |
#否钮 | 6 |
#首拼及全拼 | 1 |
#双拼 | 2 |
#自动判别 | 3 |
#Ctrl键状态 | 1 |
#Shift键状态 | 2 |
#Alt键状态 | 4 |
#顶层 | 1 | 在窗口 Z 顺序的最前面。
#底层 | 2 | 在窗口 Z 顺序的最后面。
#最高层 | 3 | 在所有现行窗口的最前面并一直保持此位置。
#次高层 | 4 | 在最高层窗口的下面但在其他窗口的前面。
#全部转换 | 1 |
#日期部分 | 2 |
#时间部分 | 3 |
#输入文本 | 1 |
#输入整数 | 2 |
#输入小数 | 3 |
#拷贝 | 1 |
#翻转拷贝 | 2 |
#位异或 | 3 |
#位或 | 4 |
#位与 | 5 |
#从上到下 | 1 |
#从左到右 | 2 |
#从左上到右下 | 3 |
#从右上到左下 | 4 |
#从下到上 | 5 |
#从右到左 | 6 |
#从右下到左上 | 7 |
#从左下到右上 | 8 |
#字节集型 | 11 | 可以存储大量的不定长字节数据。
#备注型 | 12 | 文本型的扩充，可以存储大量的不定长文本数据。
#通常索引 | 1 |
#读音索引 | 2 |
#南方读音索引 | 3 |
#不区分大小写 | 1 |
#忽略所有空格 | 2 |
#取平均值 | 1 |
#求和 | 2 |
#取最大值 | 3 | 取最大数值及日期。
#取最小值 | 4 | 取最小数值及日期。
#禁止修改 | 1 | 如果禁止修改，则自动禁止添加和删除。
#禁止添加 | 2 |
#禁止删除 | 4 |
#禁止自动判断 | 8 |
#根类 | 1 |
#现行设置 | 2 |
#现行用户 | 3 |
#本地机器 | 4 |
#所有用户 | 5 |


系统的安装及运行

返回首页

一、安装方法

    安装时将所有系统文件拷贝到同一个目录中即可，如：C:\E。以后本工作室将提供专门的安装程序。

二、运行方法及配置要求

    安装后直接执行 E.EXE 文件即可运行。

    本软件运行的最低计算机配置要求为：

  • Windows 9X / 2000 / NT 操作系统；

  • 486DX/66 MHz 或更高的处理器（推荐 Pentium 或更高的处理器)；

  • VGA 或分辨率更高的显示器；

  • 16M 内存；

  • 鼠标或其它定点设备。


操作手册

返回首页

[ 系统主窗口布局 ]
[ 工作夹 ]
    [ 支持库夹 ]　[ 程序夹 ]　[ 属性夹 ]
[ 状态夹 ]
     [ 提示夹 ]　[ 输出夹 ]　[ 调用表夹 ]
[ 状态行 ]
[ 设计窗口界面 ]
    [ 绘制新的窗口单元 ]　[ 选择窗口单元 ]　[ 使用鼠标改变窗口单元的位置 ]
    [ 使用鼠标改变窗口单元的尺寸 ]　[ 编辑窗口菜单 ]　[ 预览 ]
[ 程序编辑窗口 ]
    [ 程序集的组成 ]　 [ 输入备注 ]　[ 草稿 ]　[ 光标键操作 ]　 [ 编辑 ]　 [ 选择块 ]
[ 失去关联的名称 ]
[ 其它 ]

一、系统主窗口布局

    在系统安装后第一次进入时，主窗口的顶端为菜单条，菜单条的下面为标准工具条，左边为工作夹，下边为 状态夹 ，中间为“_启动窗口”的 窗口设计界面 ，右边为窗口单元工具箱。另外，系统状态条默认是不显示的，使用组合夹可以将工作夹与输出夹组合到一起，编写程序时将使用程序编辑窗口。
    在主窗口或其各类工具条上单击鼠标右键可以弹出用作设置各种工具条、工具夹显示状态的菜单。

二、工作夹

    在工作夹中包括三个子夹，名为：“支持库”、“程序”、“属性”。

    1、支持库夹：

    在支持库夹中可以查看到当前所有被引入的支持库及其中的所有内容和信息。每选中一条项目，在提示夹或状态行上均可以看到有关此项目的详细帮助文本。在某项目上单击鼠标右键可以弹出一个菜单，在此菜单中可以进行譬如输出此项目及其所有子项目的帮助文本、将现行项目所对应的命令输入到程序中等等操作。双击某项目可以将此项目所对应的命令输入到程序中；

    2、程序夹：

    在程序夹中可以查看到当前程序的所有组成部分。譬如：程序中的所有程序集、所有全局容器、窗口等等。双击某项目可以跳转到该项目所对应的程序部分。在某项目上单击鼠标右键可以弹出一个跳转、插入或删除对应程序项目的菜单；

    3、属性夹：

    属性夹用作显示当前被选中窗口单元的属性表。各组属性之间用粗线条隔开。某属性的子属性将比其父属性缩进一格。灰色文本标题的属性表示此属性需要在其父属性被设置为某值后才有效，但仍然可以进行设置。选中某属性后按下 Delete 键可以删除此属性中的内容（譬如图片、声音等等），按下空格可以进行编辑或修改。
    在属性夹的顶部有一个组合框，用作选择当前设计窗口中的某窗口单元。在属性夹的底部也有一个组合框，用作自动加入或跳转到当前被选择窗口单元的某事件处理子程序。

三、 状态夹

    在状态夹中包括三个子夹，名为：“提示”、“输出”、“调用表”。

    1、提示夹：

    提示夹中始终具有针对于当前用户操作的提示，此为用户获取帮助信息的最有效、最直接的地方；

    2、输出夹：

    输出夹中提供当前系统输出给用户的信息。譬如：编译易程序的全过程；易程序在调试运行方式下使用“输出调试文本”命令所输出的文本；易程序的编译及运行错误等等；

    3、调用表夹：

    调用表夹中提供调试时当前被中断运行的易程序的子程序调用过程记录。用户可以双击某项目或者选中某项目后按回车以直接跳转到该调用位置。

四、状态行

    状态行中的内容等同于提示夹中的内容，如信息有多行或超出行外，在任何时候（包括正在显示对话框时）均可使用 Ctrl + / 键浏览其全部。

五、设计窗口界面

    1、绘制新的窗口单元：

    在窗口单元工具箱中选取所欲绘制入的窗口单元（窗口单元工具箱的第一个按钮为返回选择方式，不是窗口单元），然后使用鼠标拖动绘制在窗口上。在绘制过程中如果想中途放弃，可以按 Esc 键或者单击鼠标右键。

    2、选择窗口单元：

  • 使用鼠标直接单击欲选择的窗口单元；

  • 使用鼠标拖动选择在一个指定矩形区域内的所有窗口单元；

  • 使用 Shift + 鼠标左键 选择或者取消选择指定的窗口单元而不影响其它窗口单元的选择状态；

  • 使用 Shift + 鼠标拖动 选择或者取消选择指定矩形区域内的窗口单元而不影响其它窗口单元的选择状态；

  • 在属性夹顶部的组合框中直接选择某窗口单元。

    3、使用鼠标改变窗口单元的位置：

  • 拖动已经被选择的窗口单元即可。

    4、使用鼠标改变窗口单元的尺寸：

  • 拖动已经被选择的单个窗口单元四周的对应调节器即可。

    5、编辑窗口菜单：

  • 使用 Ctrl + E 即可调入窗口菜单编辑器。

    6、预览：

  • 使用 Ctrl + Enter 即可预览窗口在运行时的实际情况，在预览时不会去调用事件的处理子程序。

    7、其它可以进行的操作请参见主菜单及设计窗口上的右键菜单。

六、程序编辑窗口

    1、程序集的组成

    在程序集的首部为程序集定义表，其中可以定义程序集名称、备注和程序集容器。如果程序集容器定义表尚不存在，在程序集定义表上使用 回车 或者 Insert 键即可创建并插入一个空的程序集容器。

    在程序集定义表后面顺序记录有此程序集中的所有子程序。

    子程序由子程序定义表、局部容器定义表和程序语句系列组成。在子程序定义表中可以定义子程序名称、返回值类型、备注和子程序参数。如果子程序参数定义表尚不存在，在子程序定义表上使用 回车 或者 Insert 键即可创建并插入一个空的参数。在局部容器定义表中可以定义仅在此子程序中使用的容器。如果局部容器定义表尚不存在，在子程序中使用 Ctrl + L 键即可创建并插入一个空的局部容器。

    2、输入备注

    在用户编写易程序的过程中，所有地方均允许用户直接输入相关的备注信息。在子程序中，用户可以使用菜单功能“编辑 -> 修改备注”或者 Alt + Enter 来输入与当前语句相关的备注。

    3、草稿

    由于易系统对用户所输入的语句是先编译后存放，因此不符合语法规则的语句就不能被输入到程序。但是，在实用过程中，用户可能经常需要在输入语句时跳转到其它地方去查阅相关信息，或者需要暂时存放一些临时性的语句文本、需要暂时屏蔽某些语句等等。此时可以使用草稿来满足此需求。在语句上按下 Ctrl + Enter 或者在输入时按下 Ctrl + Enter 键均可以将当前语句以草稿的形式保存。另外，如果在输入的过程中跳转到程序中的其它地方，当前语句将自动以草稿的形式保存，在查看完毕返回此程序编辑窗口后，按下 Tab 键可以继续先前的输入。

    4、光标键操作（同样适用于自定义数据类型表、全局容器表、Dll命令定义表、常量数据表、资源表等等编辑窗口）

← | 在语句行上关闭参数，在表格上左移一列。
→ | 在语句行上打开参数，在表格上右移一列。
↑ | 上移一行
↓ | 下移一行
Ctrl + ↑ | 上滚一行
Ctrl + ↓ | 下滚一行
Shift + ↑ | 向上选择一行
Shift + ↓ | 向下选择一行
Ctrl + Alt + ↑ | 跳转到上一子程序／自定义数据类型／Dll命令
Ctrl + Alt + ↓ | 跳转到下一子程序／自定义数据类型／Dll命令
Ctrl + Shift + ↑ | 移动光标到与当前行有箭头关连的前面的行
Ctrl + Shift + ↓ | 移动光标到与当前行有箭头关连的后面的行
Ctrl + = | 打开所有参数
Ctrl + [ | 水平向左滚动一页
Ctrl + ] | 水平向右滚动一页
PageUp | 垂直向上滚动一页
PageDown | 垂直向下滚动一页
Shift + PageUp | 向上选择一页
Shift + PageDown | 向下选择一页
Ctrl + PageUp | 跳到头部
Ctrl + PageDown | 跳到尾部
Ctrl + Shift + PageUp | 选择到头部
Ctrl + Shift + PageDown | 选择到尾部
Home | 在表格中到首列
Ctrl + Home | 跳到当前页头部
Ctrl + Shift + Home | 选择到当前页头部
End | 在表格中到尾列
Ctrl + End | 跳到当前页尾部
Ctrl + Shift + End | 选择到当前页尾部
Insert | 在当前行前插入新行
Enter | 在当前行后插入新行
Delete | 删除当前行
Ctrl + / | 如果当前所提示信息不能被看到或完全看到，则跳转到提示夹或另弹出窗口显示之；如果执行此操作时提示夹已经被显示但无输入焦点，则赋予其输入焦点，以便于用户使用键盘浏览提示信息；如果已有输入焦点，则将焦点转移回程序编辑窗口继续进行编辑。
Ctrl + Tab | 在编辑窗口之间跳转。按下 Ctrl 键后不放，然后反复按 Tab 键可以在目前所有的编辑窗口之间跳转；按下 Ctrl 键后同时按下 Tab 键，然后都放开，可以在最近两个编辑窗口之间跳转。

    5、编辑

    <1>、进入编辑状态：

  • 按下空格键即可进入编辑，此时原有内容将被调入；

  • 按下 Ctrl + V 可以使用当前剪辑板中的文本内容进入编辑，此时原有内容将被此文本替换；

  • 直接输入字符或汉字也可以进入编辑，此时原有内容将被该字符或汉字替换；

    <2>、欲删除整个子程序，只需要在子程序表的子程序名称行上进行删除操作即可。

    <3>、编辑过程中可进行的操作（此信息在编辑时可在提示夹或状态行上查阅到）：

  • F1 键可以浏览并选择输入文件名；

  • Ctrl + F 可以进行搜寻，F3 或 Shift + F3 键可以继续向后或向前搜寻文本；

  • Ctrl + → 或 Ctrl + ← 以单词为单位移动光标，同时按下 Shift 键可以进行选择；

  • Tab、Alt + → 或 Shift + Tab、Alt + ← 以 8 个字符为单位快速移动光标，使用光标键时同时按下 Shift 键可以进行选择；

  • Ctrl + A 可以全选；

  • 在输入程序语句时以 Ctrl + Enter 键结束可以强行将当前输入内容以草稿形式保存；

  • 在常量表中输入常量值时以 Alt + Enter 结束可以强行将当前输入内容作为文本类型常量保存，此方法可用作输入带有双引号的文本常量内容。

    6、选择块

    易编辑窗口中的块与其它软件不同之处为：可以同时选择多块。块选择的方法为：

    <1>、键盘方式：使用 Shift + 光标键 进行块选择或者添加，使用 Alt + 光标键 进行不影响当前块定义的光标移动。

    <2>、鼠标方式：使用鼠标直接拖动可以选择一个区域，单击标志列可以选择对应的行。使用 Shift + 鼠标单击或者拖动 可以增加一个选择区域。使用 Ctrl + 鼠标单击或者拖动 可以取消一个选择区域。

七、失去关联的名称

    易程序中的所有名称，都被系统内置的名称管理器所管理，以便进行改名跟踪等处理。但有时候某些名称可能会被失去关联管理，譬如：假设程序中存在名为“子程序1”的子程序，在程序中的“子程序2”子程序内调用了“子程序1”。那么，用户如果进行了类似以下的系列操作，“子程序1”名称将会与“子程序2”中的相应调用名称失去关联：
    1、剪切“子程序1”到剪辑板。此时由于“子程序1”已被删除，“子程序2”中的相应调用名称将失去其关联对象；
    2、再将剪辑板中的“子程序1”代码粘贴到程序中。此时系统因为无法确认用户是否确切想将其与“子程序2”中的“子程序1”调用名称关联起来，所以不会去自动关联。
    至此，“子程序2”中的“子程序1”调用名称失去了其关联对象，现在用户如果修改“子程序1”的名称，“子程序2”中的相应调用名称不会被自动更改。如果“标记程序中失去关联的名称”系统选项被置位（系统安装后默认不置位。修改设置的方法：使用“程序 -> 系统配置 -> 程序显示夹 - 标记程序中失去关联的名称”菜单功能），“子程序2”中的调用名称前将会被显示一个五角星号。
    将两者重新关联起来的方法是在具有失去关联名称的语句行上按下 Shift + Enter 键重新处理。
    在编译或者运行程序时，系统将会自动寻找与失去关联的名称相匹配的对象名称。

八、其它

    有关所有菜单功能的介绍，请参见易系统中对应菜单项目的提示信息。


支持库手册

即时查询帮助信息

返回首页

    如欲对系统中各运行支持库内的命令、库定义数据类型、库定义常量等等信息进行查找，请在易系统启动后使用以下方法之一：

  • 直接在工作夹内的支持库夹中单击对应的所欲查找其信息的项目，此时所有的相关信息将会显示在系统的提示夹或者状态行中；
  • 如果欲将这些信息提取出来打印或者以后阅读，请在相应项目上单击鼠标右键，在所弹出的菜单中选择“拷贝帮助文本到剪贴板”或者“写帮助文本到文件”功能输出与该项目及该项目所有子项目相关的帮助信息。譬如：在支持库名项目上进行此操作将输出此支持库内的所有信息。


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

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

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

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

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

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

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

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

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

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

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

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

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

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


语法的描述规则：

由下面的语法描述行（请参见画板的滚动写行方法）：

无返回值 画板．滚动写行 （［欲写出数据］，… ）
 1 2 3 4

可得知，语法描述行顺序分为四部分（见上面的标识数）：

1、是否有返回值及返回值的数据类型；

2、是否为方法及其调用对象的名称。如果不为方法，本部分不存在；

3、命令或者方法的名称；

4、参数表。参数表被小括号括住，为该命令或方法的所有参数顺序排列。如果某参数被中括号括住，表示该参数不是必需的，调用时可以被省略。参数表的最后如果有一串省略号，表明最后一个参数可以被扩展。


示例的书写格式

易语言采用流程图编辑并显示程序，而知识库中的示例使用文本方式提供，故在此处对此文本格式进行说明。

如下面的子程序：

srule.gif (5243 字节)

所对应的文本格式为（使用“编辑->复制程序文本”系统菜单功能可以将此子程序拷贝为此文本格式）：

子程序：取最大值
返回值类型：整数型
备注：本子程序用作返回两个数值中的较大值

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

局部容器：容器1 数据类型：整数型 备注：本容器仅用作说明格式，在程序中未使用。

如果 (数值1 ＞ 数值2)
返回 (数值1)
否则
返回 (数值2)
如果结束

其中，为了说明“如果”命令的程序流程，加上了“否则”和“如果结束”语句行，它们以斜体的形式书写，表示在实际程序中此语句行并不存在。其它的一些流程控制类命令，如“如果真”、“判断”等等，中间都会插入这样的斜体语句行以说明程序流程。

示例中如有绿色的文字，表示它为注释。如：

如果 (数值1 ＞ 数值2) 检查数值1是否大于数值2。

其中，“检查数值1是否大于数值2。”即用作注释语句“如果 (数值1 ＞ 数值2)”。


一步一步跟我学易语言

第一章：入门

注意：本章及以后所有叙述都假设您在安装易语言后没有使用 程序->系统配置 菜单项修改过系统的初始配置信息。如果不能确定，请在启动易 语言的同时一直按住 Shift 键，出现系统界面后再放开，此时将自动清除以前的设置信息。

我们以软件中自带的一个例程开始讲述，例程名称为：“第一个程序”，启动 易 语言后请在“打开例程”子夹中选中该程序，然后再按下确定按钮。另外，此程序您也可以根据首页上的《三分钟就能学会编程序》文章自己建立。

进入后我们可以看到易 系统的主界面，界面中间用作设计 E 程序的程序窗口，现在里面已经有了一个，该程序窗口中有两个窗口单元：一个“标签”（上面中部）及一个“按钮”（下面中部）。

请单击系统界面左边工作夹内的“程序”子夹，然后双击列表树中的“窗口程序集1”项目，您现在可以看到 易程序代码的编辑界面，里面现已有一个“窗口程序集1”程序集和一个“_按钮1_被单击”子程序。

至此为止您已经看到了此易 程序的全部组成部分，可以使用“窗口”菜单或者 Ctrl + Tab 键在程序窗口设计界面和程序代码编辑界面之间跳转查看。

易 程序由程序窗口、程序集、子程序、自定义数据类型、全局容器、DLL命令定义、常量、资源等组成。您现在不需要了解那么多，目前只要知道以下基本知识就可以了：
1、程序窗口是易 程序用作接收来自用户的输入信息或者显示某项输出信息的界面；
2、程序窗口由窗口单元组成。窗口单元具有很多种类，譬如在此例程中被使用的标签及按钮，还有编辑框、选择框等等，以后还将不断增加。在 易 系统主界面右边的单元栏工具箱中您可以看到当前可以使用的各种窗口单元；
3、子程序为一系列语句的排列集合，用作完成某一功能，执行子程序即是执行其中的所有语句；
4、程序集用作将子程序进行分类集合。

我们按下 F5 键运行该例程，然后单击窗口中的按钮，窗口中会显示出“祖国，您好！”文本。

下面关闭被运行的例程，我们来分析为什么此程序能够完成这样的功能：

1、请跳转到程序窗口设计界面，然后单击左边工作夹内的“属性”子夹，在属性表中您可以看到“名称”一栏的内容为：“_启动窗口”，该名称就是此已被选中的程序窗口的名称。凡是以短下划线“_”开头的名称都是具有特定意义的名称。名称为“_启动窗口”的程序窗口，易 程序在运行起来后会自动载入并显示，这就是例程执行后能够马上显示出窗口的原因。

2、下面请双击程序窗口中的按钮跳转到对应的代码设计界面，您可以看到下面这条语句：

标签1.标题 ＝ “祖国，您好！”

这条语句具体是什么意思呢？为什么它会被放在名称为“_按钮1_被单击”的子程序中？

请跳转到程序窗口设计界面，单击选中窗口中的按钮，在属性表中可以看到其名称为“按钮1”，单击属性表底部显示为“在此处选择加入事件处理子程序”的组合框，在其中我们可以找到名为“被单击”的列表项。然后选中窗口中的标签，在属性表中可以看到其名称为“标签1”，并且属性表中同时还有名为“标题”的属性表栏。这些与上面的程序语句及子程序之间又有什么联系呢？

前面曾经提到过：凡是以短下划线“_”开头的名称都是具有特定意义的名称，此处也不例外。名称为“_按钮1_被单击”或类似名称的子程序被专门用作接收运行时来自程序窗口的事件，被称为事件处理子程序。它们名称的组成格式为“_” + 产生事件的窗口单元名称 + “_” + 事件名称。按照此格式分析即可得知，名称为“_按钮1_被单击”的子程序就是被用来接收名称为“按钮1”的按钮窗口单元上所产生的“被单击”事件。也就是说，易 程序运行时用户一旦单击了此按钮，系统将会自动执行具有此名称的子程序。

引用一个窗口单元必须使用它的名称，引用窗口单元的某个属性必须使用： 窗口单元名称 + “.” + 属性名称 的格式，由此我们知道，“标签1.标题”实际上就是引用名称为“标签1”的窗口单元的“标题”属性，而语句： 标签1.标题 ＝ “祖国，您好！” 执行后就是将“标签1”窗口单元的标题改变为“祖国，您好！”。所有在程序中使用的文本数据两边都必须用双引号括起来，譬如“祖国，您好！”。输入时不必用全角符号“”，直接输入半角 " 即可。

下面总结一下：当该易 例程开始执行时，将自动载入并显示名称为“_启动窗口”的程序窗口。当用户按下窗口中的按钮后，“_按钮1_被单击”子程序被自动执行，子程序中的 标签1.标题 ＝ “祖国，您好！” 语句被执行，导致窗口中的“标签1”窗口单元的标题被改变，从而显示出对应文本。

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

试一试：

1、 在 标签1.标题 ＝ “祖国，您好！” 语句处回车向后插入一条新语句，然后输入：

bq1.xg = 2

注：“bq1.xg”为“标签1.效果”文本中各汉字第一个拼音字母的组合，如果不能理解，请先阅读《程序的输入方法》。

运行后查看结果。

2、在程序界面设计窗口中选中“按钮1”窗口单元，在其属性表底部的组合框中选择“鼠标右键被按下”，然后输入：

bq1.zb = 0

运行后，先单击按钮，然后在按钮上按下鼠标右键，查看结果。


一步一步跟我学易语言

第二章：进一步了解窗口单元属性的使用方法

命名规则：从现在开始，对于名称为 “xxx” 的窗口单元，我们一律直接以加粗的 xxx 形式引用。譬如名称为“_启动窗口”的程序窗口，将被直接称为 _启动窗口 。

今天我们要对前一章中提到的“第一个程序”一步一步做下述改进：

1、为_启动窗口加上标题“易语言演示窗口”；

2、运行过程中单击按钮时为标签1加上渐变边框；

3、增加一个编辑框，单击按钮的同时将用户在编辑框内输入的内容显示到标签1中。

为_启动窗口加上标题的工作我们将在设计程序窗口时完成。下面请选中_启动窗口，方法为直接单击该程序窗口内的空白处，注意程序窗口本身同样也是一个窗口单元。选中属性表中的“标题”属性，在其右表列中输入“易语言演示窗口”后回车。

双击窗口中的按钮，直接输入以下文本后回车：

bq1.bk=6

跳回_启动窗口设计界面，按下系统主界面右边单元栏工具箱中的编辑框按钮（在位置 2 ），然后将鼠标指针移回到被设计程序窗口上，可以看到现在鼠标指针的形状已经变为了十字形。在按钮1的下面按下鼠标左键并拖动出一个矩形，放开鼠标后您可以看到一个编辑框已经被加入到了_启动窗口中。此编辑框窗口单元的名称现在被系统自动设置为编辑框1，您如果觉得不合适，可以在其属性表中随意修改其“名称”属性，我们现在将其更改为测试输入框。

再次双击窗口中的按钮，以跳转到对应的代码部分，回车插入空行后输入：

bq1.bt=cssrk.nr

至此，我们的所有改进工作已经完成，您可以运行一下看看效果。_按钮1_被单击子程序中的最后内容如下：

标签1.边框 ＝ 6
标签1.标题 ＝ 测试输入框.内容

此时的程序您可以在此处下载，下一章将在此程序的基础上继续讲述。

对于上面的程序，目前我们第一次接触的可能就是第二行，其实仔细一看就能明白，此语句不过就是将测试输入框的内容属性值读出来后写入到标签1的标题属性中去。另外，您可能要问，被写入到标签1的边框属性中去的数值 6 究竟代表了什么，还有一些其它的数值可以用吗？您可以在标签1的属性表中查看其边框属性，选中该属性后其最右边会出现一个下拉箭头按钮，单击此按钮后您可以看到以下列表项：

0. 无边框； 1. 凹入式 ...... 6. 渐变镜框式

这些数值就是可以写入到边框属性中的值，您如果读取边框属性，也将得到这些值。在列表项中数值的后面您可以看到它们所代表的具体含义。了解了这些后您可以将 标签1.边框 ＝ 6 改变为 标签1.边框 ＝ 1 试一试。

下面总结一下：

1、窗口单元的属性值可以在设计窗口时给予初始值，我们为_启动窗口加上标题的工作就是使用此方法来完成；

2、窗口单元的属性值可以通过在程序中赋值来改变。在窗口单元属性表中列出的所有属性，除了被明确标明的外（为极少数，您可以在譬如文件框、打印机之类窗口单元的属性表中看到），都可以在程序中读写，其效果与在设计时给予其初始值完全一样；

3、窗口单元的属性值可以在程序中被读出，它们代表了窗口单元的最近相关状态值，譬如上面第二条语句中读取测试输入框的内容属性值将取得测试输入框中的最近输入内容。

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

试一试：

运行本章最后完成的程序，在测试输入框中输入一段文本，然后按下按钮，再输入一段不同的文本，再按下按钮。了解一下两次标签1中所反映的测试输入框的内容属性值的变化过程。

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


一步一步跟我学易语言

第三章：其它的一些窗口单元知识

1、依赖型窗口单元属性：

请打开上一章中所完成的例程，选中标签1后在其属性表中找到边框属性，在此属性的下方我们可以看到四个被缩进一格并显示为灰色的属性：渐变边框宽度、渐变边框颜色1、2、3 。请将渐变边框颜色2属性值改变为黄色，此时标签1并没有任何变化。现在请再将边框属性值改变为渐变镜框式，您马上可以看到标签1的周围被加上了一道黄色的渐变边框。

为什么会产生这种现象呢？这是因为渐变边框颜色2属性依赖于边框属性，它只有当边框属性为渐变镜框式时才会产生作用。渐变边框宽度、渐变边框颜色1、3属性也具有同样的依赖性，此类属性只有当其依赖到的属性为某特定值时才会产生作用，在程序中应用时也一样。

注：现在请按 Ctrl + Z 键直到所作的修改被全部复原，以后类似的实验性操作都不要保存到我们所使用的例程中去。

2、窗口单元层次：

请做以下实验：在_启动窗口的设计界面中拖动测试输入框到按钮1的上面，您可以看到测试输入框将按钮1遮盖了一部分。现在请在测试输入框上单击鼠标右键，在所弹出的菜单中选择“到最底层”菜单项，您可以看到测试输入框被调整到了按钮1的下面。

通过此实验您可以了解到：窗口单元与窗口单元之间存在层次关系，当两个或者多个窗口单元之间存在重叠时，位于高层的窗口单元将遮盖其下面位于低层的窗口单元。

3、父窗口单元及子窗口单元：

我们仍然通过实验来了解此概念。首先请使用“程序->新建”菜单功能新建一个 易程序，然后在单元栏工具箱中按下选择夹窗口单元按钮（位置 18），在被设计窗口上使用鼠标左键拖曳出一个矩形以加入一个选择夹窗口单元（以后我们把此过程称为“加入一个新的xxx窗口单元”），然后再按下工具箱中的按钮窗口单元按钮（位置 8），在刚刚被加入的选择夹1窗口单元上面拖曳加入一个按钮（注意拖曳的起点必须在选择夹1内）。

下面我们来进行下面测试：
1、选中按钮1，用鼠标四处拖动它，您可以看到它始终被限制在选择夹1内；
2、在按钮1上单击鼠标右键，在所弹出的菜单中选择“到最底层”菜单项，您可以看到按钮1始终在选择夹1的上面，无法被调整到其底层；
3、拖动选择夹1到另外一个位置，您可以看到按钮1也一起被移动；
4、设置选择夹1的禁止属性为真以禁止操作者在程序运行时对其操作，然后在被设计窗口上单击鼠标右键，在所弹出的菜单中选择“预览”菜单项，在预览窗口中单击选择夹1和按钮1试一试，您可以发现一旦选择夹1被禁止，按钮1也被自动禁止；
5、设置选择夹1的可视属性为假，然后预览窗口，您可以看到一旦选择夹1不可视，按钮1也自动不可视；
6、选中选择夹1，按下 Del 键删除它，您可以看到按钮1也一起被删除；

为什么会产生上面的现象呢？这是因为创建按钮1窗口单元时，您的操作过程指定了按钮1是选择夹1的子单元，反过来说，选择夹1为按钮1的父单元。并不是所有的窗口单元都可以成为其它窗口单元的父单元，具有此特性的只有图片框、外形框、画板、分组框、选择夹五种，它们被统称为容器类单元。所有种类的窗口单元都可以成为其它窗口单元的子单元。

父单元与其子单元的主要关系为：
1、如果父单元被销毁、禁止或者隐藏，其内部的所有子单元将会自动被销毁、禁止或者隐藏；
2、子单元始终被限制在父单元的内部，其坐标位置相对于父单元的左上角；
3、父单元内的所有子单元之间存在层次关系，但是父单元与子单元之间不存在层次关系；

如果窗口单元已经存在，欲将其设置为另外一个窗口单元的子单元，操作方法为：剪切该窗口单元到剪贴板中，然后选中父窗口单元，粘贴后即可。

关于选择夹，它与其它容器类单元不同之处为：选择夹的每一个子夹都可以单独容纳一批子单元，子夹与子夹之间不会相互干扰，以便于您设计多夹式程序界面。您可以进行以下实验：

选中选择夹1，单击属性表中“子夹管理”行右边的省略号按钮，在所弹出来的子夹管理对话框中单击“向后插入空项目”按钮，然后回车关闭对话框。您现在可以看到选择夹1被增加了一个新的子夹，单击该新子夹的头部以跳转过去，再插入一个新的任意类型子窗口单元到该子夹中。现在，您可以在新子夹和原子夹之间跳转查看，以了解选择夹窗口单元的此特性。此实验最后形成的程序您可以在此处下载查看。

总结：今天讲述了相对较容易理解的一些窗口单元知识，由于举例时很多是操作过程举例，您如果有什么不明白的地方请与我们联系。

下一章将开始讲述易语言编程的重要入门知识： 易 语言的基本数据类型 。


一步一步跟我学易语言

第四章：初步了解数据类型

在窗口单元属性表中设置某属性的值时，我们常常会遇到某些属性需要输入一段文本，某些属性需要输入一个数值，还有某些属性需要在真和假之间选择等等，这是由此属性的数据类型所决定的。数据类型用作标明某数据的具体种类，譬如：100 的类型为整数，3.14 的类型为小数，“祖国您好！”的类型为文本，真和假的类型为逻辑值等等。

打开例程后请跳转到窗口程序集1，将光标移动到返回值类型表栏下，按下空格后您可以看到一个数据类型选择框，里面列出了易语言所支持的所有基本数据类型。

字节型、短整数型、整数型、长整数型、小数型、双精度小数型统称为数值型，它们之间的区别在于所容纳数值范围的不同和数据尺寸的不同。

名称 | 数值范围 | 所占字节数
字节型 | 0 到 255 | 1
短整数型 | -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

字节是系统中数据的基本存储单位。从上表中您可以看出，数据类型所占字节数越多，所能够容纳数值的范围就越大。打个比方：字节型数值 1 和长整数型数值 1 ，都代表了数值 1 ，但是系统在存储时，所用去的存储空间却大不一样，字节型数值 1 仅仅只用去了 1 个字节，而长整数型数值 1 却要用 8 个字节。在实际应用时，要注意到这一点，您需要根据所可能存储的最大数值决定采用何种数据类型，既不能溢出（关于溢出下一章将会举例讲解）最好也不要浪费空间。譬如：如果您需要存储的数值最大不超过 32767 ，可以使用短整数型。如果您采用长整数型，就会造成存储空间的浪费。一般情况下，如果仅存储整数，推荐您使用整数型数据类型，如果需要存储小数，在精度要求不高的情况下，推荐使用小数型。

另外，还有逻辑型、日期时间型、文本型、字节集、子程序指针等五类数据类型。逻辑型数据只能记录真或者假，日期时间型数据用作记录某日期时间，文本型数据用作记录一段文本，字节集型数据用作记录一段字节，子程序指针将留作以后讲述。

总结，今天的内容可能有一些枯燥，但这是我们进入易语言编程的必经之路，下一章中将继续讨论数据类型，并且开始讲述易程序的重要构成部件：容器 。

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

试一试：

在教学例程中的 标签1.边框 ＝ 6 语句处直接输入 bq1.bk="6" 将其覆盖，然后运行程序，按下按钮后程序会出错并中断，这是为什么呢？请大家想一想，不久就会讲到这个问题。


一步一步跟我学易语言

第五章：初步了解容器

容器，顾名思义就是容纳东西的器件，只不过在易 程序中，容器所容纳的是各种不同类型的数据，程序可以将数据写入到容器中也可以从容器中读回数据。容器具有名称及数据类型，名称用作在程序中访问该容器，可以根据需要随意定义，只要不与其它容器重名即可。数据类型用作标识该容器中所能够容纳数据的类型。

请新建一个易程序，加入一个画板到_启动窗口左边，再加入一个按钮到右边，双击此按钮以创建并跳转到_按钮1_被单击子程序，按下 Ctrl + L 加入一个空容器，在容器名栏内输入“容器1”（快速输入方法：rq + 空格 + 1）后回车，在类型栏中输入“dzsx”（短整数型）后回车。这样，我们就在该子程序内定义了一个名称为“容器1”的容器。

下面请顺序输入以下语句：
rq1=100
hb1.gdxh(rq1)
rq1=rq1+1000
hb1.gdxh(rq1)
rq1=rq1+50000
hb1.gdxh(rq1)

输入完毕后该子程序中的内容如下：
容器1 ＝ 100
画板1.滚动写行 (容器1)
容器1 ＝ 容器1 ＋ 1000
画板1.滚动写行 (容器1)
容器1 ＝ 容器1 ＋ 50000
画板1.滚动写行 (容器1)

对于“画板1.滚动写行 (容器1)”语句，我们将在以后给予讲解，现在您只需要知道此语句的作用就是在画板1上显示出容器1的内容就可以了。

运行此程序，单击窗口中的按钮，您可以看到画板中显示了如下内容：
100
1100
-14436

现在，我们知道了容器确实可以被写入和读出，如“容器1 ＝ 100”语句将数值 100 写入到了容器1中，而“容器1 ＝ 容器1 ＋ 1000”语句先将容器1中上次被写入的值 100 读出来，然后与数值 1000 相加，最后将其和写回到容器1中（先前的数值 100 被覆盖）。

但是为什么执行了“容器1 ＝ 容器1 ＋ 50000”语句后容器1中的内容变成了 -14436 呢？根据我们的计算，100 + 1000 + 50000，其结果应该是 51100 。这就是我们上一章中所提到的溢出。因为，容器1的数据类型被我们定义为短整数型，所以系统仅为此容器分配了一个短整数的存储空间，据上一章中所述，短整数型数值的最大值为 32767，而结果值 51100 大于了此数值，导致系统为容器1所分配的存储空间不能容纳该数值，部分数据被丢弃，从而得到了错误的结果。

本章总结：
1、容器具有名称和数据类型；
2、程序可以从容器内读出数据或者写入数据到容器内；
3、写入数值到数值型容器内时注意防止溢出。

下一章将继续讲述容器。

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

试一试：

1、将程序中容器1的数据类型改变为整数型，再运行程序，看看其结果有什么不同。

2、试一试将容器1的名称随意更改为另外一个名称，譬如“测试容器”，以表达更加清楚的意思，便于以后阅读程序。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第六章：容器的写入规则

容器的写入规则规定了容器内能够被写入什么类型的数据。

一般来说，容器内仅能被写入类型与容器本身数据类型一致的数据。譬如：将一个整数写入到整数型容器中，将一段文本写入到文本型容器中等。比较特殊的是：任意数值类型的数据可以被写入到任意数值类型的容器中，系统将自动进行转换。譬如将一个短整数写入到整数型容器中，将一个整数写入到小数型容器中等等，但是此时必须注意防止上一章中所提到的溢出问题。

窗口单元属性的写入规则与容器相同。

请打开上一章中所完成的程序，跳转到_按钮1_被单击子程序，删除其中的所有语句，并将容器1的名称改为短整数容器（改名时的快速输入方法：dzs + 空格 + rq + 空格）。然后按下 Ctrl + L 键加入一个空容器，在容器名栏输入“整数容器”（快速输入方法：zs + 空格 + rq + 空格），在类型栏中输入“zsx”（即整数型）。以后我们把类似的操作称为“加入名为xxx的xxx型容器”。然后我们再加入一个名为文本容器的文本型容器。

顺序输入以下语句：

wbrq="100"
zsrq=51100
dzsrq=zsrq
hb1.gdxh(wbrq,zsrq,dzsrq)

输入完毕后该子程序中的内容如下：
文本容器 ＝ “100”
整数容器 ＝ 51100
短整数容器 ＝ 整数容器
画板1.滚动写行 (文本容器, 整数容器, 短整数容器)

运行该程序，单击按钮后其显示结果如下：
100
51100
-14436

程序中的第一行语句将文本数据“100”写入到了文本容器中，第二行将 51100 数值写入到了整数容器中，所以我们看到输出结果的头两行为 100 和 51100 。第三行将整数容器中的整数数值写入到短整数容器中证明了不同类型数值之间可以互相转换，但是此处输出了与上一章中相同的值 -14436 ，说明同样产生了数值溢出。

下面我们来做一些实验：

将第一行程序改为 文本容器 ＝ 100 ，即将 100 两边的双引号删除，然后运行程序，单击按钮后查看程序中断错误信息。

按下 Ctrl + F5 终止被运行的程序后按一下 Ctrl + Z 取消此修改，然后将第二行改为 整数容器 ＝ "51100" ，即在 51100 两边加上双引号，运行程序并单击按钮后查看程序中断错误信息。

可以看到，两次的程序中断错误信息都一致，就是：

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

我们知道，用双引号括住的文本为一段文本型数据，那么，第一次修改后的语句就是将一个数值 100 写入到文本容器中，第二次修改后的语句就是将一段文本 “51100” 写入到整数容器中。这两种情况都违背了文首所提到的容器写入规则，导致程序无法继续运行，从而中断报错。

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

试一试：

在第一行语句上直接输入 wbrq=dwb(100) 后回车，该语句将改变为：

文本容器 ＝ 到文本 (100)

这条语句中的 100 也是数值，但是为什么被成功地写入到了文本型容器中呢？到文本 (100) 是什么意思？

这就是下一章我们要开始讲述的命令，真的是很重要。同时恭喜您，您的 易语言编程知识将登堂入室了。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第七章：命令

命令是由系统提供的能够完成某一特定功能的指令。它在易 程序中的书写格式为：

命令名称 （参数，...... ）

命令名称是程序中调用时所使用的名称，譬如上一章尾所提到的到文本。命令可以接收一些数据以供其处理，这些数据被称为参数。譬如上一章尾的到文本命令就接收了一个数值参数 100 。命令所能接收参数的数目和各参数的数据类型由命令本身所决定。所有参数必须用括号一起括住，多个参数之间用逗号隔开。命令执行完毕后还可能返回数据，是否返回数据及所返回数据的数据类型同样由命令本身所决定。譬如上一章尾的到文本命令就将返回文本型数据。

下面我们通过具体编程来理解上述概念。

请新建一个程序，然后进行以下操作：

1、在_启动窗口的左边加入一个画板，右下加一个按钮；

2、双击按钮1，在_按钮1_被单击子程序中顺序输入以下语句：

mj
hb1.gdxh(qxxsj())
hb1.gdxh(szdrmb(100))

输入完毕后子程序内容如下：

鸣叫 ()
画板1.滚动写行 (取现行时间 ())
画板1.滚动写行 (数值到人民币 (100, 假))

大家可能对第二、三行语句的首部不大理解，我们以后会讲到，现在您只需要知道此语句就是将取现行时间、数值到人民币这两个命令的返回数据显示出来就可以了。

我们在上面的程序中使用了三个不同的命令：鸣叫、取现行时间、数值到人民币。

对于鸣叫命令，通过查看其解释，我们了解到它既不接收参数也不返回数据，仅用作完成发声功能，所以它的参数部分是空的。取现行时间命令将返回一个日期时间型数据，它也没有参数。数值到人民币返回文本型数据并且接收两个参数：参数1类型为双精度小数型，名称为“欲转换形式的数值”；参数2类型为逻辑型，名称为“是否转换为简体”，其默认值为“假”。由于我们在程序中没有为参数2提供数据，所以系统自动取用其默认值。

运行一下程序，单击按钮后查看其结果，了解这三个命令的执行情况。

关闭程序，继续进行以下输入操作：

1、加入一个名称为“容器1”的小数型容器；
2、在子程序尾部继续添加以下语句：
rq1=100.38
hb1.gdxh(szdrmb(rq1,zhen))
hb1.gdxh(szdrmb(sswr(rq1,1)))

输入完毕后所添加的语句如下：

容器1 ＝ 100.38
画板1.滚动写行 (数值到人民币 (容器1, 真))
画板1.滚动写行 (数值到人民币 (四舍五入 (容器1, 1), 假))

从 数值到人民币 (容器1, 真) 语句可以看出，命令的参数数据可以通过容器来提供。而 数值到人民币 (四舍五入 (容器1, 1), 假) 说明，命令的参数数据还可以通过另外一个命令的返回值来提供。关于四舍五入命令，您可以使用前面的方法来查看其详细解释，以后不再提示。

为命令参数提供数据时，必须同样遵循容器的写入规则。您可以将 数值到人民币 (容器1, 真) 改为 数值到人民币 ("文本", 真) 试一试，查看程序运行时的中断错误信息。

下一章我们将继续讲述命令。

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

本章完毕后，请将支持库夹中的所有类别命令浏览一遍，了解一下易 语言究竟提供了哪些命令。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第八章：进一步了解命令

请打开上一章中所完成的程序，将_按钮1_被单击子程序中的内容全部删空，然后顺序输入以下语句：

hb1.gdxh(dxxz(3,"文本",100,3.14,[2000/10],jia))
hb1.gdxh(dxxz(2,3.14,"文本"))

输入完毕后子程序中的内容为：

画板1.滚动写行 (多项选择 (3, “文本”, 100, 3.14, [2000年10月1日], 假))
画板1.滚动写行 (多项选择 (2, 3.14, “文本”))

请先到“其他”类别中看一看多项选择命令的详细解释，从中可以了解到：
1、命令执行后所返回数据的类型为通用型；
2、命令参数表中最后一个被定义的参数可以重复添加；
3、命令一共定义了两个参数，第一个参数为“索引值”，类型为整数型。第二个参数为“待选择项数据”，类型为通用型。

关于通用型数据类型，我们是第一次接触到，它能够代表所有的各种数据类型，就象数值型数据类型能够代表所有的数值数据类型一样，它与数值型数据类型都只能在命令中使用，不能用来定义容器。所谓命令执行后返回通用型数据，即表示命令执行后可能返回任何一种类型的数据，具体在什么情况下返回什么类型的数据，由命令自己决定。譬如多项选择命令所返回数据的数据类型将等同于“索引值”参数所选中的“待选择项数据”参数数据。

“命令参数表中最后一个参数可以被重复添加”意味着可以为命令提供无限个参数，所增加出来的参数是该命令的最后一个定义参数的延续。譬如在上面所输入的两条语句中，第一行语句为多项选择命令提供了六个参数，第二行语句提供了三个参数，都比该命令所定义的两个参数数目多。所多出来的参数为该命令的最后一个定义参数“待选择项数据”的延续，它们的数据类型等所有特性完全一致。

下面我们结合程序来理解：

多项选择 (3, “文本”, 100, 3.14, [2000年10月1日], 假) 语句用作返回第 3 个“待选择项数据”参数，即 3.14 ，因此命令此时所返回数据的类型为小数型。此语句共提供了 5 个“待选择项数据”参数，除开命令本身所定义的一个，共延续了 4 个。语句中为这 5 个通用型参数分别提供了文本型、整数值、小数值、日期时间型（用中括号括住的数据为日期时间型数据）、逻辑型等不同类型的数据。

多项选择 (2, 3.14, “文本”) 语句用作返回第 2 个“待选择项数据”参数，即：“文本”，因此命令此时所返回数据的类型为文本型。此语句共提供了 2 个“待选择项数据”参数，除开命令本身所定义的一个，共延续了 1 个。

如果某语句中命令的参数可以被延续，显示时该语句首部将出现一个右双箭头。

下面讲述可以被省略的参数，请继续输入以下语句：

hb1.gdxh(sswr(100.58))

输入完毕后此语句的内容为：

画板1.滚动写行 (四舍五入 (100.58, ))

我们所注意的是 四舍五入 (100.58, ) 语句，您可以看到该命令的第二个参数“被舍入的位置”没有提供参数数据，那么此时系统是怎么处理的呢？仔细看一看四舍五入命令的解释，可以发现有如下说明：

参数<2>的名称为“被舍入的位置”，类型为“整数型（int）”，本参数可以省略不填。 ... 如果省略本参数，则默认为0。

原来此时系统将自动使用命令所定义的默认值 0 。

总结：这一章我们讲述了关于命令的一些其它知识，下一章将开始具体讲述流程控制类命令。

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

试一试：

将第一行语句改为： 画板1.滚动写行 (多项选择 (4, “文本”, 100, 3.14, [2000年10月1日], 假))，即将原来的 3 改为 4 ，运行程序查看其结果有什么不同。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第九章：流程控制命令

易语言中的流程控制类命令目前有下面几种，请先在系统中查看有关各命令的详细解释。

1、分枝类： 如果、如果真、判断
2、循环类： 判断循环首、循环判断首、计次循环首、容器循环首
3、跳转类： 到循环尾、跳出循环、返回、结束

如果命令应当很好理解，当其条件参数的逻辑值为真时，程序就向下执行，否则就跳转到左侧箭头所指向语句处执行。如果真命令与如果命令相比，就是少了条件参数为假时的程序部分。判断语句实际上就是多重分枝语句，当任何一个判断分枝语句的条件参数为真时，相应的程序部分就被执行，如果所有分枝语句的条件参数都为假，那么位于最后的默认分枝的程序被执行。

在循环类命令中，判断循环在循环体的首部判断是否进入或者继续循环，循环判断在循环体的尾部判断是否继续循环。使用循环判断，循环体内的程序至少会被执行一次。

返回命令因与子程序相关，留到以后讲述。结束命令结束当前 易程序的执行。

下面结合例程来具体讲述计次循环首、容器循环首、到循环尾、跳出循环命令。

打开上一章中的例程后，将_按钮1_被单击子程序中的所有内容删空，然后在该子程序中进行以下输入操作：

1、将画板1的“自动重画”属性值设置为真，以便于后面调试时随时查看画板的显示内容；

2、加入一个名为容器1的整数型容器；

3、顺序输入以下语句：
jcxhs(3,rq1)
hb1.gdxh(rq1)

4、移动光标到程序尾部，继续输入：
rqxhs(100,180,50,rq1)
hb1.gdxh(rq1)

5、移动光标到程序尾部，继续输入：
jcxhs(5,rq1)
rgz(rq1=2)
dxhw
rgz(rq1=4)
tcxh
hb1.gdxh(rq1)

6、移动光标到程序尾部，加入一个空行，以便在后面调试时查看跳出循环命令的执行结果。

输入完毕后，子程序中的内容如下：

计次循环首 (3, 容器1)
画板1.滚动写行 (容器1)
计次循环尾 ()
容器循环首 (100, 180, 50, 容器1)
画板1.滚动写行 (容器1)
容器循环尾 ()
计次循环首 (5, 容器1)
如果真 (容器1 ＝ 2)
到循环尾 ()
如果真 (容器1 ＝ 4)
跳出循环 ()
画板1.滚动写行 (容器1)
计次循环尾 ()
< 空行 >

仅依靠文本很难看出程序的真实面目，建议您下载此例程以供查看。

执行程序并单击按钮后，显示结果如下：

1
2
3
100
150
1
3

下面我们来分析为什么会有此结果。

子程序的首部是计次循环首命令，由于其“循环次数”参数值为 3 ，所以循环体将被重复执行 3 次。通过查看上面显示结果的前三行，我们了解到容器1的内容一直被系统自动设置为当前循环体已进入的次数。

容器循环首类似于 Basic 语言中的 for 命令，它规定了循环容器的起始值、目标值、递增值。递增值可以被提供为正数或者负数。每执行循环体内的程序一次，系统将自动把递增值加入到循环容器中，当循环容器中的值大于目标值时循环将被终止。请查看系统中有关此命令的详细解释以具体了解此命令。

在程序的尾部还有一个计次循环，里面有到循环尾和跳出循环命令。到循环尾命令用作跳到当前循环的尾部，即循环尾类命令。跳出循环命令用作跳出当前循环。

下面请使用易 语言的调试功能来“身临其境”地了解这些命令的执行情况。

请将光标移动到子程序的第一行语句 计次循环首 (3, 容器1) 上，然后按下 Ctrl + F8 键或者单击“调试->执行到光标处”菜单项。单击被运行程序窗口中的按钮后，程序将被中断，此时请使用 F8 键或者单击“调试->单步跟踪进入”菜单项来一条语句一条语句地执行程序，注意了解此时程序的实际执行过程。在此过程中您可以随时使用 Alt + Tab 键跳转到被调试的易 程序中查看其窗口中所显示出来的执行结果。

总结：这一章我们介绍了在易 语言命令集中较为重要的程序流程控制类命令，以后我们还会讲到一些其它的重要或者不太容易理解的命令，但是大部分的命令还是要依靠大家自己到系统中去阅读解释，并通过实际试用来了解其特性，如果有不懂的地方请随时咨询我们。

最后，顺便告诉大家几个操作技巧：

1、大家可能经常要在一段已经存在的程序两边加上流程控制类命令，请先将此段程序选作块，然后单击鼠标右键，选择“加到当前块首尾”菜单项，最后单击对应的子菜单项即可；

2、有时候，可能要将一种流程控制类命令改为另外一种，譬如将如果命令改为如果真命令，将判断循环首命令改为循环判断首命令等。请在该语句行上单击鼠标右键，选择“转换为 ->”菜单项，最后单击对应的子菜单项即可。

下一章将暂时回到窗口单元上去，讲述有关窗口单元方法的编程知识。

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

试一试：

在上面的例程中加入如果、如果真、判断、判断循环首、循环判断首等命令，使用上面所介绍的调试方法来查看其执行过程。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第十章：窗口单元的方法

“画板1.滚动写行 （...... ）”语句我们以前使用了很多次，但一直没有讲述过它，现在终于到了揭开其秘密的时候了。

请新建一个程序，在_启动窗口的左边和中间各加入一个画板，右边加入一个按钮。为了将两个画板在外形上区分开，请将画板1的边框属性设置为“凹入式”，画板2的边框属性设置为“凸出式”。

双击按钮1，在_按钮1_被单击子程序中输入以下行：

hb1.gdxh("画板1")
hb2.gdxh("画板2")

输入完毕后子程序中的内容如下：

画板1.滚动写行 (“画板1”)
画板2.滚动写行 (“画板2”)

运行程序并单击按钮，查看显示结果。

我们发现，“画板1”文本被显示在画板1中，“画板2”文本被显示在画板2中。这说明了画板1.滚动写行仅对画板1进行操作，画板2.滚动写行仅对画板2进行操作。实际上，这就是窗口单元方法的调用。

窗口单元的方法除了具有以下两个特点外与我们前面所讲的命令完全相同：

1、窗口单元的方法必须使用窗口单元来调用，调用格式为 窗口单元名称 + “.” + 方法名称 ；
2、窗口单元的方法仅影响调用该方法时所使用的窗口单元。

欲查看某类窗口单元具有哪些方法及这些方法的详细解释，请到支持库夹中的“数据类型”分枝中寻找。譬如：想了解画板的所有方法，可以到“数据类型 -> 画板”下查看。

为了加深印象，请继续进行以下输入操作：

1、在_启动窗口中按钮的上方加入一个列表框；

2、在_按钮1_被单击子程序的尾部加入以下行：
lbk1.jrxm("新项目")

输入完毕后子程序中被加入的语句如下：

列表框1.加入项目 (“新项目”, )

请查看加入项目方法的详细解释，然后运行程序，查看其执行结果。

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

下面我们继续讲述窗口单元方法的其它知识，请进行以下输入操作：

1、将列表框1向左边移动一段距离，使之遮盖住画板2的一部分；

2、在_按钮1_被单击子程序的尾部加入以下行：
lbk1.tzcc(#diceng)

输入完毕后子程序中被加入的语句如下：

列表框1.调整层次 (#底层)

上面语句中的“#底层”是一个常量，常量主要用作增强程序的易读性，可以被视为在程序运行期间永久存在并且只能读出而不能被写入的容器。常量的内容可以为一个数值、一段文本或者其它类型数据，具体是什么由其本身的数据类型决定。在程序中使用常量时其名称前必须加上“#”符号。“底层”常量的数据类型为数值型，值为 2 ，欲查看其详细解释请到常量表内寻找。

运行程序并单击按钮，查看所添加语句的运行效果。

不过，我们马上就会发现一个问题，那就是在支持库夹中“数据类型 -> 列表框”下找不到调整层次方法，也就是说，列表框类窗口单元并没有调整层次方法！

最后，我们终于在“数据类型 -> 窗口”下找到了调整层次方法，它怎么会在这里呢？和列表框又有什么关系？事实上，它和所有类别的窗口单元都有关系，也就是说，所有类别的窗口单元都可以调用此方法。“数据类型 -> 窗口”下的所有方法不仅仅可以被窗口本身调用，还可以被其它所有类别的窗口单元调用，这是一个特例。

下一章将回到容器的讲述上去。

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

试一试：

请在 列表框1.调整层次 (#底层) 语句行上直接输入 hb2.tzcc(#dingceng) 从而将其修改为 画板2.调整层次 (#顶层) ，运行程序后查看其结果。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第十一章：静态容器

请打开第九章中所完成的程序，将_按钮1_被单击子程序中的内容全部删除，然后请进行以下输入操作：

1、加入一个名为非静态容器的整数型容器；

2、加入一个名为静态容器的整数型容器，并同时选中该容器的静态属性；

3、顺序输入以下语句行：

hb1.gdxh(fjtrq)
hb1.gdxh(jtrq)
fjtrq=fjtrq+1
jtrq=jtrq+1

输入完毕后，子程序的内容如下：

画板1.滚动写行 (非静态容器)
画板1.滚动写行 (静态容器)
非静态容器 ＝ 非静态容器 ＋ 1
静态容器 ＝ 静态容器 ＋ 1

运行该程序，连续单击三次按钮，其显示结果如下：

0
0
0
1
 0
2

通过阅读程序我们知道：每次单击按钮时，程序将顺序显示非静态容器和静态容器的内容。我们发现，非静态容器的内容在显示时始终为 0 ，而静态容器的内容却在一直递增，这是为什么呢？

这就是非静态与静态的区别。所谓静态，就是静止存在，当所处子程序退出时，此类容器能够保留住现行内容以供下次继续使用，而非静态的容器就不能，下次进入子程序时它将被重新初始化，例程中的语句 非静态容器 ＝ 非静态容器 ＋ 1 根本没有任何作用，这就是为什么非静态容器的内容在显示时始终为 0 的原因，

下一章我们将讲述数组容器。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第十二章：数组容器

请打开上一章所完成的程序，将_按钮1_被单击子程序中的内容全部删除，然后进行以下输入操作：

1、加入一个名为数组容器1的整数型容器，在其数组属性中输入“3”，表明此容器为一个单维数组，共有 3 个成员；

2、加入一个名为数组容器2的整数型容器，在其数组属性中输入“2，2”，表明此容器为一个二维数组，共有 4 （2 × 2 的结果）个成员；

3、顺序输入下列语句行：

szrq1[1]=100
szrq2[2][1]=200
hb1.gdxh(szrq1[1],szrq2[2][1])
hb1.gdxh(szrq2[3])
szrq2[4]=300
hb1.gdxh(szrq2[2][2])

输入完毕后子程序中的语句如下：

数组容器1 [1] ＝ 100
数组容器2 [2] [1] ＝ 200
画板1.滚动写行 (数组容器1 [1], 数组容器2 [2] [1])
 画板1.滚动写行 (数组容器2 [3])
数组容器2 [4] ＝ 300
画板1.滚动写行 (数组容器2 [2] [2])

运行结果为：

100
200
200
300

通过上面的程序，我们可以知道：

一、数组容器可以有多个成员容器，每个成员容器等同于一个单独容器。各成员容器的引用方法为：

数组容器名 + “[” + 从 1 开始的成员位置 + “]” + ......

譬如上面的数组容器1，它有“数组容器1 [1]”、“数组容器1 [2]”、“数组容器1 [3]”三个成员。数组容器2有“数组容器2 [1] [1]”、“数组容器2 [1] [2]”、“数组容器2 [2] [1]”、“数组容器2 [2] [2]”四个成员。

二、多维数组的成员也可以使用单维的方式来引用。譬如上面的“数组容器2 [3]”等同于“数组容器2 [2] [1]”，“数组容器2 [4]”等同于“数组容器2 [2] [2]”。此方法可用来遍历数组的所有成员，请继续进行以下输入：

1、加入一个名为容器1的整数型容器；

2、添加以下语句行：

jcxhs(qszcys(szrq2),rq1)
hb1.gdxh(szrq2[rq1])

输入完毕后所添加的语句如下：

计次循环首 (取数组成员数 (数组容器2), 容器1)
画板1.滚动写行 (数组容器2 [容器1])
计次循环尾 ()

此段程序可以顺序显示出数组容器2中所有成员的内容，其中“数组容器2 [1] [1]”、“数组容器2 [1] [2]”由于没有被写入新值，为初始值 0 。

下一章将讲述容器的初始值及动态管理数组容器。

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

试一试：

将上面添加的程序段中的数组容器2改为数组容器1：

计次循环首 (取数组成员数 (数组容器1), 容器1)
画板1.滚动写行 (数组容器1 [容器1])
计次循环尾 ()

运行后查看结果。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第十三章：容器的初始值及动态管理数组容器

如果容器内从来没有被写入过数据，那么此时容器中的内容是什么呢？我们来做一个实验：

请打开上一章所完成的程序，将_按钮1_被单击子程序中的内容全部删除，然后进行以下输入操作：

一、顺序加入以下容器：

1、 名为字节容器的字节型容器；
2、 名为短整数容器的短整数型容器；
3、 名为整数容器的整数型容器；
4、 名为长整数容器的长整数型容器；
5、 名为小数容器的小数型容器；
6、 名为双精度小数容器的双精度小数型容器；
7、 名为逻辑容器的逻辑型容器；
8、 名为日期时间容器的日期时间型容器；
9、 名为文本容器的文本型容器；
10、名为字节集容器的字节集型容器；

二、输入以下程序语句：

hb1.gdxh(zjrq,dzsrq,zsrq,czsrq,xsrq,sjdxsrq,ljrq,rqsjrq,qwbcd(wbrq),qzjjcd(zjjrq))

输入完毕后子程序中的语句为：

画板1.滚动写行 (字节容器, 短整数容器, 整数容器, 长整数容器, 小数容器, 双精度小数容器, 逻辑容器, 日期时间容器, 取文本长度 (文本容器), 取字节集长度 (字节集容器))

运行程序并单击按钮，显示出来的各行为：

显示结果行 |  | 所显示的数据
0 | -> | 字节容器的内容
0 | -> | 短整数容器的内容
0 | -> | 整数容器的内容
0 | -> | 长整数容器的内容
0 | -> | 小数容器的内容
0 | -> | 双精度小数容器的内容
假 | -> | 逻辑容器的内容
1899年12月30日 | -> | 日期时间容器的内容
0 | -> | 文本容器中文本的长度
0 | -> | 字节集容器中字节的数目

由上面的显示结果我们可以知道：所有数值型容器的初始值都为 0 ，逻辑型容器的初始值为假，日期时间型容器的初始值为1899年12月30日，文本型容器的初始值为长度为 0 的空文本，字节集容器的初始值为空字节集。

如果容器为数组，其每个数组成员的初始值都与单个容器相同。

请在此处下载上面所编写的程序。

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

下面我们继续讲述如何动态管理数组容器，它是易 语言的高级特性之一。

请查看以下命令的详细解释：

名称 | 简要解释
复制数组 | 将数组数据复制到数组容器，数组容器内的原有内容将被全部覆盖。
加入成员 | 将数据加入到数组容器的尾部
插入成员 | 将数据插入到数组容器的指定位置
删除成员 | 删除数组容器中的指定成员
清除数组 | 删除数组容器中的所有成员

为了理解这些命令，请将上面所编写程序中的_按钮1_被单击子程序的内容全部删除，然后进行以下输入操作：

一、分别加入名为容器数组1、容器数组2的整数型容器，将其数组属性都设置为 0 ，表示为具有 0 个成员的容器数组；

二、输入以下语句行：

hb1.gdxh(qszcys(rqsz1),qszcys(rqsz2))
jrcy(rqsz1,200)
crcy(rqsz1,1,100)
jrcy(rqsz2,50)
jrcy(rqsz2,rqsz1)
hb1.gdxh(qszcys(rqsz1),qszcys(rqsz2),rqsz1[1],rqsz1[2],rqsz2[1],rqsz2[2],rqsz2[3])
sccy(rqsz1,1)
qcsz(rqsz2)
hb1.gdxh(qszcys(rqsz1),qszcys(rqsz2),rqsz1[1])
fzsz(rqsz2,rqsz1)
hb1.gdxh(qszcys(rqsz2),rqsz2[1])

输入完毕后，子程序中的语句为：

画板1.滚动写行 (取数组成员数 (容器数组1), 取数组成员数 (容器数组2))
加入成员 (容器数组1, 200)
插入成员 (容器数组1, 1, 100)
加入成员 (容器数组2, 50)
加入成员 (容器数组2, 容器数组1)
画板1.滚动写行 (取数组成员数 (容器数组1), 取数组成员数 (容器数组2), 容器数组1 [1], 容器数组1 [2], 容器数组2 [1], 容器数组2 [2], 容器数组2 [3])
删除成员 (容器数组1, 1, )
清除数组 (容器数组2)
画板1.滚动写行 (取数组成员数 (容器数组1), 取数组成员数 (容器数组2), 容器数组1 [1])
复制数组 (容器数组2, 容器数组1)
画板1.滚动写行 (取数组成员数 (容器数组2), 容器数组2 [1])

运行程序并单击按钮，显示出来的各行及其对应的意义为：

显示行 | 所显示的数据
0 | 容器数组1内的初始成员数目
0 | 容器数组2内的初始成员数目
2 | 由于加入和插入了一个成员，容器数组1内的成员数增为 2。
3 | 由于加入了一个成员，然后又加入了容器数组1内的现行所有成员，容器数组2内的成员数增为 3。
100 | “插入成员 (容器数组1, 1, 100)”语句插入到容器数组1首部的成员数据。
200 | “加入成员 (容器数组1, 200)”语句加入到容器数组1内的成员数据。
50 | “加入成员 (容器数组2, 50)”语句加入到容器数组2内的成员数据。
100 | “加入成员 (容器数组2, 容器数组1)”加入到容器数组2内的成员数据。
200
1 | “删除成员 (容器数组1, 1, )”语句执行后容器数组1内的成员数目
0 | “ 清除数组 (容器数组2)”语句执行后容器数组2内的成员数目
200 | 由于容器数组1的第一个成员被“删除成员 (容器数组1, 1, )”语句删除，后面的成员被顺序前移，200 为此时的容器数组1 [1]成员内容。
1 | 由于“复制数组 (容器数组2, 容器数组1)”语句将容器数组1内的所有数据复制到了容器数组2，所以此时容器数组2内的成员数目与容器数组1相同。
200 | 由于“复制数组 (容器数组2, 容器数组1)”语句将容器数组1内的所有数据复制到了容器数组2，所以此时容器数组2 [1]成员的内容与容器数组1 [1]相同。

由此可见，使用这些命令可以相当灵活地对容器数组进行操作。

请在此处下载上面所编写的程序。

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

下一章我们将开始讲述非常重要的易 语言编程知识：子程序。


一步一步跟我学易语言

第十四章：初步了解子程序

终于到了学习子程序的时候，现在我们可以开始写一些有趣点的程序了。

请新建一个程序，进行以下输入操作：

1、加入两个编辑框到_启动窗口的上部，并将它们的“输入方式”属性设置为“整数输入”，以限制只能输入数值；

2、加入一个按钮到_启动窗口的下部并双击它跳转到对应的事件处理子程序；

3、按下 Ctrl + N 插入一个名为子程序1的新子程序；

4、在子程序1中输入以下文本（ 注意：在本章以后将不再提供语句的输入文本）：

rg(wbdsz(bjk1.nr)>wbdsz(bjk2.nr))
bjk1.bjys=#huangse
bjk2.bjys=#bs

5、下移一行，继续输入：

bjk1.bjys=#bs
bjk2.bjys=#huangse

6、在_按钮1_被单击子程序中输入：

zcx1

完成以上输入后，程序中现在有了两个子程序:

1、_按钮1_被单击，其中的内容为：

子程序1 ()

2、子程序1，其中的内容为：

如果 (文本到数值 (编辑框1.内容) ＞ 文本到数值 (编辑框2.内容))
编辑框1.背景颜色 ＝ #黄色
编辑框2.背景颜色 ＝ #白色
<否则> （斜体行用作表明程序流程，实际程序中并无此类语句行）
编辑框1.背景颜色 ＝ #白色
编辑框2.背景颜色 ＝ #黄色
<如果结束>

运行程序，在两个编辑框中各输入一个数值，单击按钮后，包含较大值的编辑框的底色将被置为黄色。

总结：在以上的程序中，我们第一次创建并调用了一个名为子程序1的子程序，子程序的调用方法与命令的调用方法完全一致，其书写格式为：

子程序名称 （参数，...... ）

下一章我们将继续讲述子程序。

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

试一试：

在_按钮1_被单击子程序中的 子程序1 () 语句行上按下 Ctrl + F8 键运行程序，单击窗口中的按钮后程序将被中断，请再连续按 F8 键一步一步跟踪程序的整个执行过程，以了解子程序是如何被调用的。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第十五章：进一步了解子程序

请打开上一章中的程序，将_按钮1_被单击及子程序1中的内容删空，然后输入以下内容：

1、在_启动窗口的左下加入一个标签，将标题属性清空，将边框属性设置为“浅凹入式”；

2、将按钮1的类型属性设置为“默认”，以支持操作者直接按回车进行比较；

3、将光标移动到子程序1的头部，即子程序名所在行，然后按回车加入一个空参数。在参数名栏中输入“数值文本1”，在类型栏中输入“wbx”（文本型）。以后我们把类似的过程称为加入名为xxx的xxx类型参数。然后继续回车后加入名为数值文本2的文本型参数；

4、将子程序1的名称改为取最大值文本；

5、在返回值类型栏中输入“wbx”（文本型）；

6、在子程序中输入以下语句：

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

7、在_按钮1_被单击子程序中输入以下语句：

标签1.标题 ＝ 取最大值文本 (编辑框1.内容, 编辑框2.内容)

现在请运行程序，在两个编辑框中输入不同的数值，然后按回车进行比较，较大的值将会被显示在标签1中。

在上面的程序中，我们定义了一个名为取最大值文本的子程序，它接收数值文本1、数值文本2两个文本型参数，返回文本型数据。在_按钮1_被单击子程序中，调用了此子程序。

理解了此程序后，我们可以总结如下：

1、子程序可以接收参数，所定义的各参数的数据类型及参数数目决定了该子程序所能够接收的参数数据的类型和数目，具有参数的子程序在被调用时必须提供与参数数目相同的数据。如上面的第 7 步在调用子程序的同时就把编辑框1.内容和编辑框2.内容作为参数数据对应地传递到了取最大值文本子程序内的数值文本1、数值文本2参数内；

2、子程序的参数可以在子程序内部被使用（如：“文本到数值 (数值文本1)”），使用方法等同于容器；

3、子程序可以返回数据，但必须首先定义返回数据的类型（上面第 5 步），并且在程序中使用“返回”命令进行返回。

下一章我们将讲述窗口程序集与子程序的关系。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第十六章：窗口程序集与子程序的关系

今天的例程中我们要建立两个窗口。

请新建一个程序后进行如下输入操作：

1、使用“插入->新窗口”菜单功能插入一个新的窗口，该窗口被系统自动命名为窗口1；

2、在_启动窗口及窗口1中均加入一个标签和一个按钮；

3、双击_启动窗口中的按钮1，在对应子程序中输入：

窗口1.标签1.标题 ＝ “来自启动窗口”
注：输入文本为 ck1.bq1.bt ＝ “来自启动窗口”。

4、选中_启动窗口，将其标题属性改为“启动窗口”，位置属性改为“通常”，然后在属性表底部的事件组合框中选择“创建完毕”，以加入一个名为“__启动窗口_创建完毕”的事件处理子程序（以后我们把类似的操作称为“为 xxx 加入 xxx 事件处理子程序”），然后在该子程序中输入语句：

载入窗口 (窗口1, , 假)

5、将窗口1的标题属性改为“窗口1”，位置属性改为“通常”，顶边属性改为 300 ，然后双击其中的按钮1，在对应子程序中输入：

_启动窗口.标签1.标题 ＝ “来自窗口1”

6、将窗口程序集1的名称改为“启动窗口的程序集”，窗口程序集2的名称改为“窗口1的程序集”（仅用作说明窗口与窗口程序集之间的对应关系，实际程序中可以省略此步）。

运行程序，你可以看到屏幕上同时出现两个窗口，单击“启动窗口”中的按钮，“窗口1”中的标签将显示“来自启动窗口”；单击“窗口1”中的按钮，“启动窗口”中的标签将显示“来自窗口1”。

上面的程序中，我们所不明白的可能是“窗口1.标签1.标题”、“_启动窗口.标签1.标题”。之所以必须这样书写的原因为：任何窗口都有一个也仅有一个程序集与它对应，譬如上面程序中的_启动窗口对应启动窗口的程序集，窗口1对应窗口1的程序集。所有该窗口内所产生事件的事件处理子程序都必须放在该窗口所对应的程序集中，任何不在此程序集中的子程序如果需要访问该窗口或其内部单元的属性或方法，都必须加上前缀文本： 所在窗口名称 + “.” ，以明确指定所在窗口。

下一章将继续讲述子程序参数。

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

试一试：

将 窗口1.标签1.标题 ＝ “来自启动窗口” 语句改为 窗口1.销毁 () ，执行后查看效果，以了解在程序中如何调用位于其它窗口中的窗口单元方法。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第十七章：子程序参数

请下载本章的示范程序，其中讲述了子程序参数的“参考”、“可空”、“数组”属性的使用方法。

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


一步一步跟我学易语言

第十八章：容器的使用范围

请新建一个程序，进行如下输入操作：

1、在_启动窗口中加入一个画板和一个按钮；

2、双击按钮1，在_按钮1_被单击子程序中加入一个名为子程序容器的整数型容器；

3、将光标移动到此程序集的首行，按下回车加入一个空程序集容器，将其名称改为“程序集容器”，其类型设置为整数型；

4、使用“插入->新全局命令”菜单功能插入一个空全局容器，将其名称改为“全局容器”，其类型设置为整数型；

5、在窗口程序集1中加入一个名为子程序1的子程序，在其中输入语句：

程序集容器 ＝ 2
全局容器 ＝ 2

6、使用“插入->新程序集”菜单功能插入一个名为程序集1的程序集，然后在其中加入一个名为子程序2的子程序，在其中输入语句：

全局容器 ＝ 3

6、在窗口程序集1中的_按钮1_被单击子程序中输入以下语句：

子程序容器 ＝ 1
程序集容器 ＝ 1
全局容器 ＝ 1
画板1.滚动写行 (子程序容器, 程序集容器, 全局容器)
子程序1 ()
画板1.滚动写行 (程序集容器, 全局容器)
子程序2 ()
画板1.滚动写行 (全局容器)

运行程序后的显示结果为：

显示行 | 说明
1 | 窗口程序集1中的_按钮1_被单击子程序对子程序容器、程序集容器、全局容器所写入的内容。
1
1
2 | 窗口程序集1中的子程序1对程序集容器、全局容器所写入的内容。
2
3 | 程序集1中的子程序2对全局容器所写入的内容。

总结：

1、可以在子程序内、程序集首、全局容器表这三个不同的位置定义容器；

2、在子程序内定义的容器只能在该子程序内部使用（例如：子程序容器只能被窗口程序集1中的_按钮1_被单击子程序使用）；

3、在程序集首部定义的容器只能被该程序集内的所有子程序使用（例如：程序集容器可以被窗口程序集1中的所有子程序使用）；

4、在全局容器表中定义的容器可以被任何子程序使用（例如：全局容器可以在任何子程序中被使用）。

下一章将讲述子程序指针数据类型，这是 易语言的高级特性之一。

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

试一试：

尝试进行以下输入操作，想一想为什么不能输入成功：

1、在窗口程序集1中的子程序1内加入以下语句：

子程序容器 = 2

2、在程序集1中的子程序2内加入以下语句：

程序集容器 = 3

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第十九章：子程序指针

请新建一个程序，进行如下输入操作：

1、在_启动窗口中加入一个编辑框和一个按钮；

2、将按钮1的类型属性改为“默认”，双击按钮1，创建并跳转到窗口程序集1；

3、连续加入名为子程序1、子程序2、子程序3的三个子程序；

4、在子程序1中输入以下语句：

信息框 (“子程序1被调用”, 0, )

5、在子程序2中输入以下语句：

信息框 (“子程序2被调用”, 0, )

6、在子程序3中输入以下语句：

信息框 (“子程序3被调用”, 0, )

7、在_按钮1_被单击子程序中加入一个名为数组容器的子程序指针型容器，在其数组属性内输入 3 ，再加入一个名为调用容器的子程序指针型容器及一个名为容器1的整数型容器；

8、顺序输入以下语句：

数组容器 ＝ { &子程序1, &子程序2, &子程序3 }
输入文本为：szrq={&zcx1,&zcx2,&zcx3}
容器1 ＝ 文本到数值 (编辑框1.内容)
如果 (容器1 ＜ 1 或 容器1 ＞ 取数组成员数 (数组容器))
输入文本为：rg(rq1<1||rq1>qszcys(szrq))
信息框 (“没有此选择值所对应的子程序！”, #错误图标, )
<否则> （斜体行用作表明程序流程，实际程序中并无此类语句行，以后不再提示）
调用容器 ＝ 数组容器 [容器1]
将对应的欲调用子程序的指针值写入到调用容器中。
调用容器 ()
实际调用对应的子程序，输入文本为：dyrq 。
<如果结束>
编辑框1.被选择字符数 ＝ -1
用作选中编辑框中的现行所有内容，以备下次能够连续输入。

运行程序，在编辑框中分别输入 1、2、3、4 后回车，查看其结果。

第一行语句中的 { &子程序1, &子程序2, &子程序3 } 将会在明天讲述，现在您只需要知道此语句是将代表 子程序1、子程序2、子程序3 的指针值取出后写入到数组容器的各成员内即可。

总结，使用子程序指针可以相当灵活地调用所需子程序，使用时要理解以下几点：

1、子程序指针可以代表程序中的任何子程序；

2、可以使用子程序指针容器来间接调用任何子程序（譬如上面的“调用容器 ()”），其格式为：

子程序指针型容器名 （参数，...... ）

从上面可以看到，使用子程序指针容器间接调用子程序的格式与子程序被直接调用时的格式完全相同。

3、子程序指针容器所具体调用的子程序由该容器内的指针值决定。譬如：当上面执行“调用容器 ()”语句时，如调用容器内的指针值为子程序1，就会调用子程序1，此时“调用容器 （）”语句与“子程序1 （）”语句完全等效。如为子程序2，就会调用子程序2，此时“调用容器 （）”与“子程序2 （）”语句完全等效，等等。

4、使用子程序指针容器间接调用子程序时所提供的参数数据必须与将实际调用的子程序匹配。譬如：假设上面的子程序1有一个参数，当使用调用容器间接调用子程序1时就必须为此参数提供数据。

下一章将讲述常数。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第二十章：常数、常量与资源

常数、常量、资源用作在程序中提供恒定不变的数据，程序中任何可以使用容器提供数据的地方都可以使用它们，反之亦然。

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

第一节、常数

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

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

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

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

<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]

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

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

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

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

第二节、常量：

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

2、可以使用以下两种方法之一加入新的空常量：

<1>、使用“插入->新常量”菜单功能；

<2>、跳转到常量数据表，如果尚未被打开，请在程序夹中双击“常量表...”项，然后使用回车或者 Ins 键即可加入；

3、空常量加入后，可以直接修改其常量名称、常量值、备注等各属性栏。在修改常量值时以 Alt + Enter 结束输入可以强行将当前输入的所有文本作为文本类型常量内容保存，此方法可用作输入带有双引号的文本常量内容。

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

第三节、资源：

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

2、可以使用以下两种方法之一加入新的空图片资源：

<1>、使用“插入->新资源->图片”菜单功能；

<2>、跳转到图片资源表，如果尚未被打开，请在程序夹中双击“资源表->图片...”项，然后使用回车或者 Ins 键即可加入；

3、可以使用以下两种方法之一加入新的空声音资源：

<1>、使用“插入->新资源->声音”菜单功能；

<2>、跳转到声音资源表，如果尚未被打开，请在程序夹中双击“资源表->声音...”项，然后使用回车或者 Ins 键即可加入；

4、空图片或者空声音资源被加入后，可以直接修改其名称和内容。

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

下面用一个例程来详细说明，请新建一个程序，进行以下输入操作：

1、在_启动窗口中加入一个画板和一个按钮；

2、使用第二节中所介绍的方法加入四个空常量，将它们分别改为以下内容：

常量序号 | 名称栏 | 常量值栏
1 | 数值常量 | 3.14
2 | 文本常量 | "飞扬"
3 | 逻辑常量 | 真 （输入文本：zhen）
4 | 日期常量 | 2000年11月1日 （输入文本：[2000/11]）

3、使用第三节中所介绍的方法加入一个空图片资源，将其名称改为“测试图片”，然后单击“内容”栏或者在其上按下空格，随意导入一个图片文件后，单击“加入/修改到程序并关闭对话框”按钮返回，此时图片数据将被保存入 易程序文件中，图片文件不再被需要；

4、使用第三节中所介绍的方法加入一个空声音资源，将其名称改为“测试声音”，然后单击“内容”栏或者在其上按下空格，随意导入一个声音文件后，单击“加入/修改到程序并关闭对话框”按钮返回，此时声音数据将被保存入 易程序文件中，声音文件不再被需要；

5、双击_启动窗口中的按钮1，在_按钮1被单击子程序中进行以下输入：

<1>、加入一个名为数组容器，数组属性为 3 的整数型数组容器和一个名为图片号的整数型容器；

<2>、输入以下语句：

画板1.滚动写行 (“数值型常数：” ＋ 到文本 (3.14), “逻辑型常数：” ＋ 到文本 (真), “日期时间型常数：” ＋ 到文本 ([2000年11月1日]), “文本常数：” ＋ “祖国您好！”)
输入文本为：hb1.gdxh("数值型常数："+dwb(3.14),"逻辑型常数："+dwb(zhen),"日期时间型常数："+dwb([2000/11]),"文本常数："+"祖国您好！")
 图片号 ＝ 载入图片 (#测试图片)
输入文本为：tph=zrtp(#cstp)
 如果真 (图片号 ≠ 0)
输入文本为：rgz(tph<>0)
 画板1.画图片 (图片号, 100, 0, , , )
卸载图片 (图片号)
<如果真结束>
播放音乐 (#测试声音, )
数组容器 [3] ＝ 3
数组容器 ＝ { 1, 2 }
画板1.滚动写行 (数组容器 [1], 数组容器 [2], 数组容器 [3])

您可能会觉得：画一个图片还要先载入后卸载，太麻烦了。不过，采用这种方法可以保证以最高的效率画出图片，而且图片号还可以被反复使用。

上面程序中的第一行演示了绝大部分常数的使用方法，子程序指针常数由于我们上一章刚刚讲述，所以在此处被略去。在后面顺序演示了图片资源、声音资源、常数集的使用方法。对于语句 数组容器 ＝ { 1, 2 } 我们需要解释一下：数组容器的成员数目我们定义为 3 ，但此处的常数集中只提供了两个数值，没有被提供数值的 数组容器 [3] 系统将自动对其重新初始化，所以最后显示出来的结果是 0 ，而不是 3 。

下一章我们将讲述自定义数据类型，这是易 语言的高级特性之一。

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

试一试：

1、加入语句：

_启动窗口.底图 ＝ #测试图片

2、将 播放音乐 (#测试声音, ) 语句改为：

_启动窗口.背景音乐 ＝ #测试声音

运行后查看效果，以了解如何使用资源去改变窗口单元的属性。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第二十一章：自定义数据类型

自定义数据类型分为支持库自定义数据类型（如：窗口、字体、编辑框等）和用户自定义数据类型。在程序中的任何位置，只要可以使用系统基本数据类型（如：整数型、文本型等），就可以使用自定义数据类型。

所有的支持库自定义数据类型在支持库夹的“数据类型”分枝下可以找到，用户自定义数据类型由用户自行在自定义数据类型表中加入。

下面我们一起来写一个有一点意思的程序，该程序执行后将允许你在画板上涂抹各种随机颜色的方块。请新建一个程序后进行以下输入：

1、在_启动窗口上加入一个尽可能大的画板，将画板背景色属性改为白色，以便能够突出我们的显示；

2、使用菜单功能“插入->新数据类型”加入一个用户自定义数据类型，将数据类型名修改为“坐标”，回车加入一个新成员，将成员名修改为“水平坐标”，类型改为整数型，再加入一个名为“垂直坐标”的整数型成员；

3、再按下 Ctrl + N 加入一个新数据类型，将数据类型名修改为“矩形”，回车加入一个新成员，将成员名修改为“起始坐标”，类型改为坐标（输入文本：zb），再加入一个名为“结束坐标”的坐标数据类型成员；

4、使用菜单功能“插入->新Dll命令”加入一个Dll命令（Dll命令将在下一章中讲述，本章中仅作了解），将其名称改为“俘获鼠标”（此名称可以随意取），在“本Dll命令在Dll库中的对应命令名”栏中输入“SetCapture”（此名称对应Windows系统的一个API函数名，不能修改），回车后加入一个参数，将参数名改为“窗口句柄”，类型改为整数型；

5、再按下 Ctrl + N 加入一个新Dll命令，将其名称改为“释放鼠标”，在“本Dll命令在Dll库中的对应命令名”栏中输入“ReleaseCapture”；

6、跳转到_启动窗口，选中画板1，在其属性表底部的组合框中分别选择“鼠标左键被按下”、“鼠标左键被放开”、“鼠标位置被移动”加入三个事件处理子程序；

7、在窗口程序集1中加入一个名为绘画矩形，数据类型为矩形（输入文本：jx）的程序集容器和一个名为绘画已开始的逻辑型程序集容器；

8、在_画板1_鼠标左键被按下子程序中输入：

连续赋值 (横向位置, 绘画矩形.起始坐标.水平坐标, 绘画矩形.结束坐标.水平坐标)
输入文本：lxfz(hxwz,hhjx.qszb.spzb,hhjx.jszb.spzb)
另注：事件处理子程序的参数（如本子程序中的横向位置、纵向位置）的内容由系统自动提供。
连续赋值 (纵向位置, 绘画矩形.起始坐标.垂直坐标, 绘画矩形.结束坐标.垂直坐标)
俘获鼠标 (画板1.取窗口句柄 ())
输入文本：fhsb(hb1.qckjb())

9、在_画板1_鼠标位置被移动子程序中输入：

如果真 (绘画已开始)
画板1.翻转矩形区 (绘画矩形.起始坐标.水平坐标, 绘画矩形.起始坐标.垂直坐标, 绘画矩形.结束坐标.水平坐标, 绘画矩形.结束坐标.垂直坐标)
绘画矩形.结束坐标.水平坐标 ＝ 横向位置
绘画矩形.结束坐标.垂直坐标 ＝ 纵向位置
画板1.翻转矩形区 (绘画矩形.起始坐标.水平坐标, 绘画矩形.起始坐标.垂直坐标, 绘画矩形.结束坐标.水平坐标, 绘画矩形.结束坐标.垂直坐标)
<如果真结束>

10、在_画板1_鼠标左键被放开子程序中输入：

如果真 (绘画已开始)
置随机数种子 ()
画板1.刷子颜色 ＝ 取颜色值 (取随机数 (0, 255), 取随机数 (0, 255), 取随机数 (0, 255))
画板1.刷子类型 ＝ 取随机数 (0, 55)
画板1.填充矩形 (绘画矩形.起始坐标.水平坐标, 绘画矩形.起始坐标.垂直坐标, 绘画矩形.结束坐标.水平坐标, 绘画矩形.结束坐标.垂直坐标)
释放鼠标 ()
输入文本：sfsb
绘画已开始 ＝ 假
<如果真结束>

运行程序后，在画板上使用鼠标拖动，可以绘制出随机颜色和填充类型的矩形。

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

最后，我们总结如下：

1、用户可以在自定义数据类型表中定义自己所需要的数据类型；

2、自定义数据类型由一系列成员组成，每个成员在程序中可以被单独访问，成员的数据类型可以是系统基本数据类型或者其它的自定义数据类型；

3、引用自定义数据类型容器成员的格式为：

容器名称 + “.” + 成员名称

如果欲引用成员内的成员，请使用连续的句点分隔。如上面的“绘画矩形.起始坐标.水平坐标”。

注：“绘画矩形.起始坐标.水平坐标”这样的语句写起来是否觉得有一点长？不要紧，我们第二十三章所要讲述的参考容器能够解决此问题。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第二十二章：Dll命令

首先声明：本章内容只适合对 Windows 系统的 API 函数有所了解的中级用户，初级用户可以跳过本章。

在上一章的程序中，我们定义了两个 Dll 命令：俘获鼠标、释放鼠标，它们所对应的 Windows API 函数分别为 SetCapture 和 ReleaseCapture 。在程序中使用这两个 API 函数可以保证当鼠标移到画板1外面时，画板1仍然能够接收到鼠标事件。

请新建一个程序，我们来继续了解有关 Dll 命令的其它情况。

1、插入一个自定义数据类型，将其名称改为“矩形”，为其增加左边、上边、右边、下边四个整数型成员；

2、插入一个 Dll 命令，将其名称改为“取窗口当前位置”，返回值设置为逻辑型，在“本Dll命令在Dll库中的对应命令名”栏中输入“GetWindowRect”，然后加入一个名为“窗口句柄”的整数型参数和一个名为“返回位置”的矩形型参数；

3、插入一个 Dll 命令，将其名称改为“取系统目录”，返回值设置为整数型，在对应命令名栏中输入“GetWindowsDirectoryA”，然后加入一个名为“返回文本储存区”的文本型参数和一个名为“文本储存区尺寸”的整数型参数；

4、继续插入一个 Dll 命令，将其名称改为“取键盘速度”，返回值设置为逻辑型，在对应命令名栏中输入“SystemParametersInfoA”，然后顺序加入四个名称分别为“查询动作”、“查询参数”、“返回数据”、“更新标志”的整数型参数，并将“返回数据”参数的传址属性设置为真；

5、在_启动窗口中加入一个按钮，双击它，在_按钮1_被单击子程序中加入一个名为“文本容器”的文本型容器、一个名为“容器1”的整数型容器、一个名为“容器2”的整数型容器、一个名为“窗口位置”的矩形型容器；

6、输入以下语句：

文本容器 ＝ 取空白文本 (260)
容器1 ＝ 取系统目录 (文本容器, 取文本长度 (文本容器))
取键盘速度 (10, 0, 容器2, 0)
取窗口当前位置 (取窗口句柄 (), 窗口位置)
信息框 (“Windows系统目录为： ” ＋ 文本容器 ＋ “ ，目录文本长度为： ” ＋ 到文本 (容器1) ＋ #换行符 ＋ “键盘速度为： ” ＋ 到文本 (容器2) ＋ #换行符 ＋ “窗口左边：” ＋ 到文本 (窗口位置.左边) ＋ #换行符 ＋ “窗口顶边：” ＋ 到文本 (窗口位置.上边), 0, )

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

在上面的程序中，我们通过 Dll 命令使用了三个外部函数：GetWindowRect、GetWindowsDirectoryA、SystemParametersInfoA ，因为它们都是 Windows API 函数，所以“Dll库文件名”栏可以省略不填，系统将自动搜寻所有基本 Windows API 库文件（Kernel32.dll、Gdi32.dll、User32.dll、Mpr.dll、Advapi32.dll），否则必须提供该 Dll 命令所在的 Dll 文件名称。在“本Dll命令在Dll库中的对应命令名”栏中必须输入该 Dll 命令在库文件中的输出名称，系统将使用它在 Dll 文件中寻找对应的调用入口。

在设置 Dll 命令的参数时，必须保证参数的顺序、数据类型都与实际的 Dll 外部函数一致，如果某个参数需要地址指针，将“传址”属性置为真即可。对于文本型、字节集型、自定义数据类型参数和数组参数，系统将自动传递地址指针，这就是 GetWindowRect 中的“返回位置”和 GetWindowsDirectoryA 中的“返回文本储存区”参数没有设置“传址”属性的原因（也可以设置，不过是多余的）。

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

附：将 Win32Api.txt 中的定义转换到易语言中的方法。

由于时间有限，易语言目前还没有提供现成的 Dll 命令定义表以供用户使用 Windows 的 API 函数，您可以按照以下大致规则来转换：

1、由于易语言是纯粹的 32 位编程系统，而 VB 是从 16 位版本发展过来的，所以 VB 中的 Long 对应易语言中的整数型；

2、如果某参数具有 ByRef 属性，请在易 语言中将“传址”属性选中；

3、如果某参数的类型为复合类型，如 RECT ，需要先在自定义数据类型表中定义出该数据类型。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第二十三章：参考容器

请新建一个程序，然后进行以下输入：

一、插入一个自定义数据类型，将其名称改为“矩形”，为其增加左边、上边、右边、下边四个整数型成员；

二、在_启动窗口中加入一个画板和一个按钮（按钮请放在底部）；

三、双击按钮，在_按钮1_被单击子程序中进行以下输入：

1、定义以下容器：

容器名 | 类型 | 静态 | 数组 | 备注
整数容器 | 整数型 |  |  |
矩形容器 | 矩形 |  |  |
容器数组 | 整数型 |  | 3 |
容器1 | 整数型 |  |  |

2、顺序输入以下语句：

画板1.清除 ()
整数容器 ＝ 4
矩形容器.左边 ＝ 5
容器数组 ＝ { 1, 2, 3 }
参考 (容器1, 整数容器)
将容器1参考到整数容器。
 画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (整数容器))
读容器1时实际上将从整数容器中读。
 容器1 ＝ 100
写容器1时实际上将写入到整数容器。
 画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (整数容器))
参考 (容器1, 矩形容器.左边)
将容器1参考到矩形容器.左边。
 画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (矩形容器.左边))
读容器1时实际上将从矩形容器.左边中读。
 容器1 ＝ 200
写容器1时实际上将写入到矩形容器.左边。
 画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (矩形容器.左边))
参考 (容器1, 容器数组 [2])
将容器1参考到容器数组 [2]。
 画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (容器数组 [2]))
容器1 ＝ 300
画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (容器数组 [2]))
参考 (容器1, 容器数组)
将容器1参考到容器数组。
 画板1.滚动写行 (到文本 (容器1 [3]) ＋ “, ” ＋ 到文本 (容器数组 [3]))
容器1 [3] ＝ 400
画板1.滚动写行 (到文本 (容器1 [3]) ＋ “, ” ＋ 到文本 (容器数组 [3]))
参考 (容器1, 左边)
将容器1参考到_启动窗口的“左边”属性。
 画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (左边))
容器1 ＝ 容器1 － 10
画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (左边))
参考 (容器1, 按钮1.顶边)
将容器1参考到按钮1的“顶边”属性。注意“按钮1”的首拼输入字为“ann1”，其中“按”的首拼为“an”。
 画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (按钮1.顶边))
容器1 ＝ 容器1 － 10
画板1.滚动写行 (到文本 (容器1) ＋ “, ” ＋ 到文本 (按钮1.顶边))
参考 (容器1, )
此语句将解除容器1对其它容器或者窗口单元属性的参考，此时容器1将恢复为一个普通容器。
 画板1.滚动写行 (容器1)
由此处的显示可以得知，在上面一系列的写操作中，并没有对容器1本身的内容产生影响。
 容器1 ＝ 500
画板1.滚动写行 (容器1)

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

参考容器具有与我们前面所讲述的子程序指针相同的作用，只不过它是指向另外一个容器或窗口单元属性。使用参考容器可以非常灵活地对容器或属性进行操作，同时它也有减少容器或属性引用文本长度的作用。譬如我们第二十一章中提到的“绘画矩形.起始坐标.水平坐标”，就可以使用参考容器来代替。

我们来看一看系统中有关“参考”命令的解释：

将指定容器的内容置为参考到其它容器的指针，以后对此容器进行的读写操作将被自动转移到其所参考到的容器。

由此可以得知，当一个容器被参考到其它容器或者属性后，就失去了其本来的作用，而改变成为一个传递站，任何以后对此容器的读写操作，都将被自动传递到其所参考的实际容器或者属性上去进行。

一个容器要成功参考到另外一个容器或属性，它们的数据类型必须一致，但数组类型可以不一致，这就是上面程序中容器1被成功参考到容器数组的原因。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第二十四章：窗口单元的事件：

今天我们来一起做一个儿童英文测试程序。

1、新建程序后在_启动窗口中加入列表框、标签、编辑框、按钮各一个，将标签的标题属性设置为“请输入当前中文含义所对应的英文单词：”，边框属性置为“浅凹入式”。布局方式为列表框在上，标签、编辑框、按钮在下，其中标签在编辑框的上面，按钮在标签和编辑框的右边；

2、双击_启动窗口中的空白处，跳转到窗口程序集1，定义中文含义、英文单词、所输入单词三个文本型程序集容器，将它们的数组属性都置为 5 。

3、双击列表框1，在_列表框1_列表项被选择子程序中输入以下语句：

如果真 (列表框1.现行选中项 ≥ 0)
编辑框1.内容 ＝ 已输入单词 [列表框1.现行选中项 ＋ 1]
<如果真结束>
 编辑框1.被选择字符数 ＝ -1
选中编辑框1中的所有字符，以便于修改。
 编辑框1.获取焦点 ()
将输入焦点转移到编辑框1，以便可以直接输入单词。

4、在__启动窗口_创建完毕子程序中加入一个名为容器1的整数型容器后输入以下语句：

中文含义 ＝ { “书本”, “课桌”, “朋友”, “学校”, “家” }
英文单词 ＝ { “book”, “desk”, “friend”, “school”, “home” }
初始化数组数据。
 计次循环首 (取数组成员数 (中文含义), 容器1)
列表框1.加入项目 (中文含义 [容器1], )
将所有欲测试单词的中文含义加入到列表框中。
计次循环尾 ()
列表框1.现行选中项 ＝ 0
默认选中列表框的第一项。
_列表框1_列表项被选择 ()

5、选中编辑框1，在其属性表下方的组合框中选择“字符输入”，在被建立的_编辑框1_字符输入子程序中进行以下输入：

<1>、加入一个名为文本容器的文本型容器和一个名为现行选中项的整数型容器；

<2>、输入以下语句：

现行选中项 ＝ 列表框1.现行选中项
如果真 (现行选中项 ≥ 0 且 字符代码 ＝ #回车键)
文本容器 ＝ 到小写 (删全部空 (编辑框1.内容))
已输入单词 [现行选中项 ＋ 1] ＝ 文本容器
列表框1.置项目文本 (现行选中项, 中文含义 [现行选中项 ＋ 1] ＋ “ ” ＋ 文本容器)
如果真 (现行选中项 ＜ 取数组成员数 (中文含义))
列表框1.现行选中项 ＝ 现行选中项 ＋ 1
自动下移一项。
_列表框1_列表项被选择 ()
<如果真结束>
<如果真结束>

6、最后，双击按钮1，在_按钮1_被单击子程序中进行以下输入：

<1>、加入以下容器：

容器名 | 类型 | 静态 | 数组 | 备注
总共题数 | 整数型 |  |  |
错误题数 | 整数型 |  |  |
信息 | 文本型 |  |  |
容器1 | 整数型 |  |  |

<2>、顺序输入以下语句：

总共题数 ＝ 取数组成员数 (中文含义)
计次循环首 (总共题数, 容器1)
如果真 (英文单词 [容器1] ≠ 已输入单词 [容器1])
错误题数 ＝ 错误题数 ＋ 1
信息 ＝ 信息 ＋ #左引号 ＋ 中文含义 [容器1] ＋ #右引号 ＋ “的正确英文单词为：” ＋ #左引号 ＋ 英文单词 [容器1] ＋ #右引号 ＋ #换行符
如果真结束
计次循环尾 ()
信息框 (“共答错 ” ＋ 到文本 (错误题数) ＋ “ 题，得分为： ” ＋ 到文本 ((总共题数 － 错误题数) × 100 ÷ 总共题数) ＋ #换行符 ＋ #换行符 ＋ 信息, 0, )
销毁 ()

至此为止，我们的这个程序就编写完毕了，您可以对其进行改进，以更适合您的要求。

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

总结：

1、欲为窗口单元的某一个事件加入事件处理子程序，选中它后在其属性表底部的组合框中选择对应的事件名称即可；

2、每个窗口单元都有一个默认事件，譬如窗口的“创建完毕”，按钮的“被单击”等等，直接双击窗口单元将自动加入默认事件的处理子程序。

3、不要对事件处理子程序的名称、返回值、参数定义作任何修改，修改后将导致系统不能将事件传递到该子程序；

4、事件处理子程序参数的数据由系统在调用时自动提供；

5、事件处理子程序可以象普通子程序一样被其它程序行调用。

另外，告诉大家一个操作技巧：将光标移动到事件处理子程序的子程序名行上时提示夹中将提供有关该事件的相关帮助信息，将光标移动到参数行上时提示夹中将提供有关该参数的相关帮助信息。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第二十五章：字节集：

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

下面我们一起来写一个程序，它能够读出并显示指定文件首部的 100 个字节。

我们准备使用一个多行只读编辑框来显示字节数据，为了让操作者能够指定文件，还需要一个通用对话框和一个按钮。

1、请新建一个程序，在_启动窗口中分别加入编辑框、按钮、通用对话框窗口单元各一个，将编辑框的“是否允许多行”属性设置为真，“输入方式”属性设置为“只读方式”，将按钮的“标题”属性改为“选择文件(&F)”，“类型”属性改为“默认”，以便操作者按下回车键时能够选择文件。

2、双击“选择文件”按钮，在_按钮1_被单击子程序中作以下输入：

<1>、加入以下容器：

容器名 | 类型 | 静态 | 数组 | 备注
字节数据 | 字节集 |  |  |
文件句柄 | 整数型 |  |  |
数据长度 | 整数型 |  |  |
容器1 | 整数型 |  |  |
文本容器 | 文本型 |  |  |

<2>、输入以下语句：

编辑框1.内容 ＝ “” 首先将编辑框的原有内容清空。
如果真 (通用对话框1.打开 ()) 检查操作者是否选择了有效的文件名。
文件句柄 ＝ 打开文件 (通用对话框1.文件名, , ) 打开该文件。
如果真 (文件句柄 ≠ 0) 检查是否打开成功。
字节数据 ＝ 读入字节集 (文件句柄, 100) 读入首部的 100 字节。
数据长度 ＝ 取字节集长度 (字节数据) 由于有些文件可能没有 100 字节，在此处获取实际所读入的字节数。
计次循环首 (数据长度, 容器1)
文本容器 ＝ 文本容器 ＋ 到文本 (字节数据 [容器1]) ＋ “, ” 将每个字节转换为文本后加入到文本容器中去。
计次循环尾 ()
编辑框1.内容 ＝ 文本容器
关闭文件 (文件句柄) 注意成功打开文件之后必须将其关闭。
<如果真结束>
<如果真结束>

最后，告诉大家两个操作技巧：

1、如果您不大习惯易 程序编辑时所画的方框图，请使用“程序->系统配置->程序显示->自动配置为紧凑布局”菜单功能就可以了；

2、如果您认为在使用容器之前要先定义该容器比较麻烦，请选中“程序->系统配置->输入->输入错误语句后询问”，此后系统将自动为您添加容器。

明天我们将讲述《一步一步跟我学易 语言》的最后一章：动态创建窗口单元，以后我们将进入《一步一步跟我编 易程序》教程。

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

请在此处下载本章所编写的程序。


一步一步跟我学易语言

第二十六章：动态创建窗口单元：

到目前为止，我们在程序中所使用的窗口单元都是在设计时加进去的，有没有办法可以在运行时动态加入窗口单元呢？

请大家先在系统中阅读一下“其他”类中的“取事件单元”、“事件转移”、“复制窗口单元”三个命令的详细解释。

我们这个程序能够根据操作者所提供的输入项的数目来自动创建相应数目的编辑框：

1、新建程序后在_启动窗口中加入标签、编辑框各一个。将标签的“标题”属性设置为“输入项的数目（1 - 5）：”，编辑框的“输入方式”属性设置为“整数输入”。布局方式为：标签与编辑框位于同一行，放在窗口顶部，标签在左；

2、由于我们希望当操作者在编辑框1内输入一个数值并按下回车后能够马上创建出对应数目的新标签和新编辑框，所以我们必须处理编辑框1的“字符输入”事件以截获操作者键入的回车。现在请选中编辑框1后加入该事件的处理子程序；

3、在窗口程序集1中加入以下程序集容器：

容器名 | 类型 | 数组 | 备注
提示标签 | 标签 | 0 | 数组属性为 0 表示将动态建立成员
输入编辑框 | 编辑框 | 0 |

4、在我们在第 2 步所加入的_编辑框1_字符输入子程序中作以下输入：

<1>、加入以下容器：

容器名 | 类型 | 静态 | 数组 | 备注
当前编辑框 | 编辑框 |  |  |
编辑框数目 | 整数型 |  |  |
容器1 | 整数型 |  |  |
容器2 | 整数型 |  |  |

<2>、输入以下语句：

如果真 (字符代码 ≠ #回车键) 检查是否键入了回车键
返回 (字符代码) 如果没有就直接返回
<如果真结束>
 当前编辑框 ＝ 取事件单元 () 由于所有被创建出来的编辑框的事件都会传递到此事件处理子程序，因此首先取出按下回车键时的实际编辑框。
如果 (当前编辑框 ＝ 编辑框1) 如果在编辑框1内按下回车键，则去进行创建编辑框处理。
编辑框数目 ＝ 取数组成员数 (输入编辑框) 取出先前已经创建出来的编辑框数目
编辑框1.被选择字符数 ＝ -1 将编辑框1内的所有内容选中，以方便下次直接输入。
计次循环首 (编辑框数目, 容器1) 销毁先前创建出来的所有标签和编辑框
提示标签 [容器1].销毁 ()
输入编辑框 [容器1].销毁 ()
计次循环尾 ()
编辑框数目 ＝ 文本到数值 (编辑框1.内容) 取回操作者所输入的项目数目
如果真 (编辑框数目 ＜ 1 或 编辑框数目 ＞ 5) 判断项目数目是否有效
清除数组 (提示标签) 如果无效则清除以前的所有记录数据并提示操作者
清除数组 (输入编辑框)
信息框 (“项目数目必须在 1 - 5 之间”, 0, )
返回 (字符代码)
<如果真结束>
 重定义数组 (提示标签, 假, 编辑框数目) 准备对应数目的空间以存储创建出来的标签和编辑框
重定义数组 (输入编辑框, 假, 编辑框数目)
计次循环首 (编辑框数目, 容器2)
容器1 ＝ 编辑框数目 ＋ 1 － 容器2 倒序创建，以支持 TAB 键操作顺序。
复制窗口单元 (标签1, 提示标签 [容器1]) 创建新标签
复制窗口单元 (编辑框1, 输入编辑框 [容器1]) 创建新编辑框
提示标签 [容器1].标题 ＝ “请输入第 ” ＋ 到文本 (容器1) ＋ “ 项：” 设置标签的标题
提示标签 [容器1].顶边 ＝ 标签1.顶边 ＋ (标签1.高度 ＋ 10) × 容器1 设置标签的位置
提示标签 [容器1].可视 ＝ 真 将新的标签显示出来
输入编辑框 [容器1].输入方式 ＝ 0 将编辑框的输入方式还原为“通常方式”
输入编辑框 [容器1].顶边 ＝ 编辑框1.顶边 ＋ (编辑框1.高度 ＋ 10) × 容器1 设置编辑框的位置
输入编辑框 [容器1].标记 ＝ 到文本 (容器1) 为新建的编辑框加上标记
输入编辑框 [容器1].可视 ＝ 真 将新的编辑框显示出来
计次循环尾 ()
<否则> 如果是在创建出来的编辑框内输入，则进行提示
 信息框 (“在第 ” ＋ 当前编辑框.标记 ＋ “ 项上输入了内容” ＋ #左引号 ＋ 当前编辑框.内容 ＋ #右引号, 0, )
<如果结束>

运行该程序，在编辑框内分别输入 1 - 5 后回车，查看效果。在创建出来的编辑框内输入文本后回车，查看效果。

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

总结：

1、使用“复制窗口单元”命令可以动态创建出某窗口单元的副本，该副本除了“可视”属性被自动设置为假外（以便于进行调整），其它属性与原窗口单元完全一致；

2、所创建出来的窗口单元的所有事件都将发送到原窗口单元上，原窗口单元的事件处理子程序必须能够处理此情况；

3、在事件处理子程序中使用“取事件单元”命令可以取回事件产生时的实际窗口单元。

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

请在此处下载本章所编写的程序。