Rexx - 快速指南
Rexx - Overview
Rexx (Restructured Extended Executor)旨在成为脚本语言。 它的目标是使脚本尽可能简单，快速，可靠和无错误。 许多编程语言旨在与旧语言兼容，并针对特定受众或平台编写。 Rexx忽略了无关的目标。 它从第一天开始设计，功能强大，易于使用。
Rexx是用汇编语言设计并首次在1979年3月20 日至1982年中期由IBM的Mike Cowlishaw实施的“自己的”项目，最初是作为脚本编程语言来取代EXEC and EXEC 2语言。 它被设计为任何系统的macro or scripting language 。 因此，Rexx被认为是Tcl和Python的前身。 Rexx的创建者也希望它是PL/I编程语言的简化版本。
Rexx的特点
Rexx作为一种编程语言具有以下主要功能 -
语法简单
将命令路由到多个环境的能力
支持与特定调用环境关联的函数，过程和命令的能力。
内置堆栈，具有与主机堆栈互操作的能力（如果有）。
包含仅仅二十几条指令的小指令集
自由格式语法
不区分大小写的标记，包括变量名称
字符串基础
动态数据类型，无声明
除了本地上下文外，没有保留关键字
没有包含文件设施
任意数值精度
十进制算术，浮点数
丰富的内置函数选择，尤其是字符串和文字处理
自动存储管理
防撞保护
内容可寻址数据结构
关联数组
直接访问系统命令和设施
简单的错误处理，以及内置的跟踪和调试器
几乎没有人为限制
简化的I/O设施
Rexx的官方网站是www.oorexx.org
Rexx - Environment
在开始使用Rexx之前，您需要确保在系统上运行Rexx的全功能版本。 本章将介绍在Windows机器上安装Rexx及其后续配置以开始使用Rexx。
在继续安装之前，请确保满足以下系统要求。
系统需求 (System Requirements)
| Memory | 2 GB RAM（推荐） |
| 磁盘空间 | 没有最低要求。 优选地，具有足够的存储空间来存储将使用Rexx创建的程序。 |
| 操作系统版本 | Rexx可以安装在Windows，Ubuntu/Debian，Mac OS X上。 |
正在下载Rexx
要下载Rexx，您应使用以下URL - https://www.oorexx.org/download.html
此页面有各种Rexx版本的下载，如以下屏幕截图所示。
单击表4.2.0版标题中的“ooRexx安装文件”。
在此之后，您将被重定向到以下页面。
单击ooRexx-4.2.0.windows.x86_64.exe以下载该软件的64-bit版本。 我们将在下一章讨论有关软件的安装。
Rexx - Installation
以下步骤将详细说明如何在Windows系统上安装Rexx。
Step 1 - 启动前面部分中下载的安装程序。 安装程序启动后，单击“运行”按钮。
Step 2 - 单击以下屏幕上的下一个按钮继续安装。
Step 3 - 单击“ I Agree按钮继续。
Step 4 - 接受default components ，然后单击下一步按钮。
Step 5 - 选择安装位置，然后单击“下一步”按钮。
Step 6 - 接受将要安装的默认进程，然后单击Next按钮。
Step 7 - 选择默认文件关联，然后单击“下一步”按钮。
Step 8 - 单击将Rexx项目发送到可执行文件的复选框，然后单击Next按钮，如以下屏幕截图所示。
Step 9 - 在下一个屏幕中，选择用于处理Rexx文件的编辑器。 将记事本保留为默认选项。 同时接受每个Rexx文件的默认扩展名。
Step 10 - 接受出现的以下屏幕上的默认设置，然后单击“下一步”按钮继续安装。
Step 11 - 最后单击“安装”按钮继续安装。
Step 12 - 安装完成后，您需要单击“下一步”按钮继续。
Step 13 - 单击“完成”按钮完成安装。
Rexx - Installation of Plugin-Ins
在本章中，我们将讨论如何在popular IDE's (Integrated Development Environment)上安装插件。 Rexx作为一种编程语言也可以在流行的IDE中使用，例如Eclipse 。 让我们看看我们如何在这些IDE中获得所需的插件，以便您在使用Rexx时有更多选择。
在Eclipse中安装
要在Eclipse中无故障地安装Rexx，您需要遵循以下步骤。
Step 1 - 打开Eclipse并单击菜单项， Help → Eclipse Marketplace ，如以下屏幕截图所示。
Step 2 - 在下一个对话框中，在搜索条件中输入Rexx，然后单击搜索按钮。
完成后，单击“安装”按钮。
Step 3 - 单击“确认”按钮以继续安装功能。
Step 4 - Eclipse将下载必要的文件以开始安装。 完成后，Eclipse将要求接受许可协议。 单击接受许可协议，然后单击Finish按钮，如以下屏幕截图所示。
然后，Eclipse将开始在后台安装该软件。
Step 5 - 您可能会收到安全警告（如以下屏幕截图所示）。 单击“确定”按钮继续。
Step 6 - 安装更新后，系统将提示您重新启动Eclipse。 单击是以重新启动Eclipse。
Rexx - Basic Syntax
为了理解Rexx的基本语法，我们先来看一个简单的Hello World程序。
例子 (Example)
/* Main program */
say "Hello World"
人们可以看到hello world程序有多简单。 它是一个简单的脚本行，用于执行Hello World程序。
关于上述计划需要注意以下事项 -
say command用于向控制台输出值。
/* */用于Rexx中的注释。
上述计划的输出将是 -
Hello World
声明的一般形式
在Rexx中，让我们看一个程序的一般形式。 看一下下面的例子。
/* Main program */
say add(5,6)
exit
add:
parse arg a,b
return a + b
上述计划的输出将是 -
11
让我们来看看我们从上述程序中理解的内容 -
添加是一个定义为添加2个数字的函数。
在主程序中，值5和6用作add函数的参数。
exit关键字用于退出主程序。 这用于区分主程序和添加功能。
add函数用':'符号区分。
parse语句用于解析传入的参数。
最后，return语句用于返回数值的总和。
子程序和函数 (Subroutines and Functions)
在Rexx中，代码通常分为子例程和函数。 子例程和函数用于将代码区分为不同的逻辑单元。 子例程和函数之间的关键区别在于函数返回值而子例程没有。
下面是子例程和添加实现的函数之间的关键差异示例 -
功能实现
/* Main program */
say add(5,6)
exit
add:
parse arg a,b
return a + b
子程序实现
/* Main program */
add(5,6)
exit
add:
parse arg a,b
say a + b
两个程序的输出值均为11。
Executing Commands
Rexx可用作各种基于命令的系统的控制语言。 Rexx在这些系统中执行命令的方式如下。 当Rexx遇到既不是指令也不是赋值的程序行时，它会将该行视为要计算的字符串表达式，然后传递给环境。
一个例子如下 -
例子 (Example)
/* Main program */
parse arg command
command "file1"
command "file2"
command "file3"
exit
此程序中三条相似的行中的每一行都是一个字符串表达式，它将文件名（包含在字符串常量中）添加到命令名称（作为参数给出）。 生成的字符串将传递给环境以作为命令执行。 命令完成后，变量“rc”将设置为命令的退出代码。
上述计划的输出如下 -
sh: file1: command not found
3 *-* command "file1"
>>> " file1"
+++ "RC(127)"
sh: file2: command not found
4 *-* command "file2"
>>> " file2"
+++ "RC(127)"
sh: file3: command not found
5 *-* command "file3"
>>> " file3"
+++ "RC(127)"
Rexx中的关键字
REXX的自由语法意味着某些符号被保留用于语言处理器在某些上下文中的使用。
在特定指令内，可以保留一些符号以分离指令的各部分。 这些符号称为关键字。 REXX关键字的示例WHILE in a DO instruction中的WHILE in a DO instruction ，以及在IF or WHEN clause之后的THEN （在这种情况下充当子句终止符）。
除了这些情况之外，只检查作为子句中第一个标记并且后面没有“=”或“:”的简单符号，以查看它们是否是指令关键字。 您可以在子句中的其他位置自由使用符号，而不将其视为关键字。
Rexx中的评论
注释用于记录您的代码。 通过在行中的任何位置使用/ * * /来标识单行注释。
一个例子如下 -
/* Main program */
/* Call the add function */
add(5,6)
/* Exit the main program */
exit add:
/* Parse the arguments passed to the add function */ parse arg a,b
/* Display the added numeric values */
say a + b
注释也可以写在代码行之间，如下面的程序所示 -
/* Main program */
/* Call the add function */
add(5,6)
/* Exit the main program */
exit
add:
parse /* Parse the arguments passed to the add function */
arg a,b
/* Display the added numeric values */
say a + b
上述计划的输出将是 -
11
您还可以在注释中包含多行，如以下程序所示 -
/* Main program
The below program is used to add numbers
Call the add function */
add(5,6)
exit
add:
parse arg a,b
say a + b
上述计划的输出将是 -
11
Rexx - DataTypes
在任何编程语言中，您都需要使用各种变量来存储各种类型的信息。 变量只是用于存储值的保留内存位置。 这意味着当您创建变量时，您在内存中保留一些空间以存储与该变量关联的值。
您可能希望存储各种数据类型的信息，如字符串，字符，宽字符，整数，浮点，布尔值等。根据变量的数据类型，操作系统分配内存并决定可以在保留中存储的内容记忆。
(类型)
Rexx提供各种内置数据类型。 以下是Rexx中定义的数据类型列表。
Integer - 一串不包含小数点或指数标识符的数字。 第一个字符可以是a plus (+) or minus (-) sign 。 表示的数字必须介于-2147483648和2147483647之间。
Big Integer - 一串不包含小数点或指数标识符的数字。 第一个字符可以是加号（+）或减号（ - ）。 表示的数字必须介于-9223372036854775808和2147483648之间，或者介于2147483648和9223372036854775807之间。
Decimal - 它将来自以下格式之一 -
包含小数点但没有指数标识符的数字字符串。 p表示精度， s表示字符串表示的十进制数的比例。 第一个字符可以是加号（+）或减号（ - ）。
一串数字， does not contain a decimal point或指数标识符。 第一个字符可以是加号（+）或减号（ - ）。 表示的数字小于-9223372036854775808或大于9223372036854775807。
Float - 表示科学记数的数字的字符串。 该字符串由一系列数字后跟一个指数标识符（E或e后跟可选的加号（+）或减号（ - ）和一系列数字）组成。 字符串可以以加号（+）或减号（ - ）开头。
String - 正常的字符串。
以下是如何使用每种数据类型的一些示例。 同样，每个数据类型将在后续章节中详细讨论。 这只是为了让您快速了解上述数据类型的简要说明。
Integer
以下程序显示了如何使用数字数据类型的示例。 该程序显示添加2个整数。
Example
/* Main program
The below program is used to add numbers
Call the add function */
add(5,6)
exit
add:
parse arg a,b
say a + b
上述计划的输出将是 -
11
大整数
以下程序显示了Rexx处理大整数的功能。 该程序显示了如何添加2个大整数。
Example
/* Main program
The below program is used to add numbers
Call the add function */
add(500000000000,6000000000000000000000)
exit
add:
parse arg a,b
say a + b
上述计划的输出将是 -
6.00000000E+21
Decimal
以下程序显示了Rexx处理十进制数的功能。 该程序显示如何添加2个十进制数字。
Example
/* Main program
The below program is used to add numbers
Call the add function */
add(5.5,6.6)
exit
add:
parse arg a,b
say a + b
上述计划的输出将是 -
12.1
浮动
以下示例显示了数字如何作为浮点数工作的情况。
Example
/* Main program
The below program is used to add numbers
Call the add function */
add(12E2,14E4)
exit
add:
parse arg a,b
say a + b
上述计划的输出将是 -
141200
String
以下程序中显示了如何使用元组数据类型的示例。
这里我们定义一个有3个术语的Tuple P tuple_size是Rexx中定义的内置函数，可用于确定元组的大小。
Example
/* Main program */
display("hello")
exit
display:
parse arg a
say a
上述计划的输出将是 -
hello
Rexx - Variables
在Rexx中，所有变量都与'='语句绑定。 变量名有时被称为符号。 它们可能由字母，数字和字符组成，例如' . ! ? _ . ! ? _ . ! ? _ '。 您创建的变量名称不得以数字或句点开头。 简单的变量名称不包含句点。 包含句点的变量名称称为复合变量，表示数组或表。
以下是Rexx中的基本变量类型，这些变量也在前一章中进行了解释 -
Integers - 用于表示整数或浮点数。 一个例子是10。
Big integers - 这表示一个大的整数值。
Decimal - 十进制值是一个数字字符串，包含小数点但没有指数标识符。
Float - 浮点值是一个字符串，表示科学记数法中的数字。
String - 一系列字符在Rexx中定义一个字符串。
不同类型的变量函数
在本节中，我们将讨论变量可以执行的各种功能。
变量声明
定义变量的一般语法如下所示 -
var-name = var-value
哪里
var-name - 这是变量的名称。
var-value - 这是绑定到变量的值。
以下程序是变量声明的示例 -
Example
/* Main program */
X = 40
Y = 50
Result = X + Y
say Result
在上面的例子中，我们有2个变量，一个是X ，它绑定到值40 ，下一个是Y ，它绑定到值50 。 另一个名为Result的变量绑定到X and Y的加法。
上述计划的输出如下 -
90
命名变量
变量名有时被称为符号。 它们可能由字母，数字和字符组成，例如'。 ！ ？ _'。 您创建的变量名称不得以数字或句点开头。
如果尚未为变量赋值，则将其称为未初始化。 未初始化变量的值是以大写字母表示的变量本身的名称。
未分配变量的示例如下 -
Example
/* Main program */
unassignedvalue
say unassignedvalue
如果您运行上述程序，您将获得以下输出 -
UNASSIGNEDVALUE
sh: UNASSIGNEDVALUE: command not found
2 *-* unassignedvalue
>>> "UNASSIGNEDVALUE"
+++ "RC(127)"
可以多次为变量分配值。 以下程序显示如何多次为X值赋值。
Example
/* Main program */
X = 40
X = 50
say X
上述计划的输出如下 -
50
打印变量
使用say命令打印变量值。 以下是打印各种变量的示例。
Example
/* Main program */
X = 40
/* Display an Integer */
say X
Y = 50.5
/* Display a Float */
say Y
Z = "hello"
/* Display a string */
say Z
上述计划的输出如下 -
40
50.5
hello
Rexx - Operators
运算符是一个符号，告诉编译器执行特定的数学或逻辑操作。
Rexx有各种类型的运算符，详细解释如下 -
- 算术运算符
- 关系运算符
- 逻辑运算符
- 按位运算符
算术运算符 (Arithmetic Operators)
Rexx语言支持任何语言的普通算术运算符。 以下是Rexx中可用的算术运算符。
| 操作者 | 描述 | 例 |
|---|---|---|
| + | 增加了两个操作数 | 1 + 2将给出3 |
| − | 从第一个减去第二个操作数 | 1 - 2将给-1 |
| ∗ | 两个操作数的乘法 | 2 * 2将给4 |
| / | 由分母划分的分子 | 2/2会给1 |
| // | 将第一个数除以第二个数的余数 | 3 // 2将给出1 |
| % | div组件将执行除法并返回整数组件。 | 3％2将给1 |
关系运算符 (Relational Operators)
关系运算符允许对象的比较。 以下是Rexx中提供的关系运算符。 在Rexx中，真值表示为1，假值表示为0。
| 操作者 | 描述 | 例 |
|---|---|---|
| == | 测试两个对象之间的相等性 | 2 = 2将给出1 |
| < | 检查左对象是否小于右操作数。 | 2 <3将给出1 |
| =< | 检查左对象是否小于或等于右操作数。 | 2 = <3将给出1 |
| > | 检查左对象是否大于右操作数。 | 3> 2将给1 |
| >= | 检查左对象是否大于或等于右操作数。 | 3> 2将给1 |
逻辑运算符 (Logical Operators)
逻辑运算符用于计算布尔表达式。 以下是Rexx中可用的逻辑运算符。
| 操作者 | 描述 | 例 |
|---|---|---|
| & | 这是逻辑“和”运算符 | 1或1将给1 |
| | | 这是逻辑“或”运算符 | 1或0将给出1 |
| \ | 这是逻辑“非”运算符 | \0会给1 |
| && | 这是逻辑上的“或”运算符 | 1 && 0将给出1 |
按位运算符 (Bitwise Operators)
Groovy提供了四个按位运算符。 下面是Groovy中可用的按位运算符。
| Sr.No. | 操作符和说明 |
|---|---|
| 1 | bitand 这是按位“和”运算符 |
| 2 | bitor 这是按位“或”运算符 |
| 3 | bitxor 这是按位“xor”或Exclusive或运算符 |
运算符优先级 (Operator Precedence)
下表按优先级递减优先级顺序显示了Rexx运算符的运算符优先级。
| 运算符 | 优先权 |
|---|---|
| 前缀运算符 | + - \ |
| Addition and subtraction | + - |
| 比较运算符 | = ==> <> = <= |
| Logical AND | & |
| Logical OR | | |
| EXCLUSIVE OR | && |
Rexx - Arrays
使用任何编程语言的数组都可以对相同类型的值列表进行分组。 数组的使用是它允许您构建一个类似类型的值的列表，这些值是sortable, searchable并且可以easily manipulated 。 Rexx还允许定义数组。 这些阵列可以是一维的或多维的。
Rexx数组可能很稀疏。 也就是说，并非每个数组位置都必须具有值，甚至不能初始化。 在包含数据元素的那些之间可以存在空数组位置或槽。 或者数组可以是密集的，其中连续的数组插槽都包含数据元素。
在许多编程语言中，您必须关注表中第一个条目的下标。 第一个数字下标是0还是1？ 在Rexx中，第一个下标是你使用的任何东西！ 因此，根据您的喜好将第一个数组元素输入到位置0或1。
array_name.0 = ‘first element’
OR
array_name.1 = ‘first element’
我们来看看阵列可用的不同操作。
创建数组 (Creating Arrays)
使用相同的命名约定创建数组，该约定用于Rexx中的变量。
创建数组的一般语法如下 -
Arrayname.index = value
哪里
Arrayname - 这是提供给阵列的名称。
Index - 这是数组中用于引用特定元素的索引位置。
Value - 这是分配给数组中索引元素的值。
数组声明的示例如下 -
Example
/* Main program */
list.1 = 0
list.2 = 0
list.3 = 0
关于上述计划需要注意以下几点 -
- 数组的名称以列表形式给出
- 数组中有3个元素初始化为0。
将值分配给数组元素
可以使用与初始化数组元素相同的方式将值重新分配给数组元素。
以下程序是可以分配给现有数组的各种索引值的值的示例。
/* Main program */
list.1 = 0
list.2 = 0
list.3 = 0
/* Assigning new values to the array*/
list.1 = 10
list.3 = 30
显示数组的值
可以通过参考数组元素的索引位置来显示数组的值。 以下示例显示了访问数组的各种元素。
Example
/* Main program */
list.1 = 0
list.2 = 0
list.3 = 0
/* Assigning new values to the array*/
list.1 = 10
list.3 = 30
say list.1
say list.2
say list.3
上述计划的输出如下 -
10
0
30
复制数组
数组的所有元素都可以复制到另一个数组中。 这个的一般语法如下 -
Newarray. = sourcearray.
哪里
Newarray - 这是需要复制元素的新数组。
Sourcearray - 这是需要复制元素的源数组。
有关如何执行数组复制操作的示例，请参见以下程序 -
Example
/* Main program */
list.1 = 0
list.2 = 0
list.3 = 0
/* Assigning new values to the array*/
list.1 = 10
list.3 = 30
listnew. = list.
say listnew.1
say listnew.2
say listnew.3
上述计划的输出将是 -
10
0
30
迭代数组元素
也可以使用Rexx中提供的迭代语句来迭代数组的元素。 如何做到这一点的一个例子如下 -
Example
/* Main program */
list.1 = 10
list.2 = 20
list.3 = 30
number_of_elements = 3
do j = 1 to number_of_elements
say list.j
end
关于上述程序需要注意以下几点 -
do loop用于遍历数组元素。
变量number_of_elements用于存储数组中的元素数。
variable j用于迭代数组的每个元素。
上述计划的输出将是 -
10
20
30
Two-dimensional Arrays
还提到我们可以在Rexx中构建多维数组。 让我们看一下如何实现二维数组的示例。
Example
/* Main program */
list.1 = 10
list.1.1 = 11
list.1.2 = 12
say list.1
say list.1.1
say list.1.2
上述程序的输出如下所示 -
10
11
12
关于上述计划，需要注意以下几点 -
要创建多维数组，我们可以使用另一层索引。 所以在我们的例子中，我们使用list.1.1为列表数组的索引值1创建另一个内部数组。
Rexx - Loops
到目前为止，我们已经看到了以顺序方式一个接一个地执行的语句。 此外，Rexx中提供了语句，以改变程序逻辑中的控制流。 然后将它们分类为控制语句流，我们将详细研究。
循环语句允许我们多次执行语句或语句组。 下图是大多数编程语言中循环语句的一般形式。
让我们讨论Rexx支持的各种循环。
| Sr.No. | 循环类型和描述 |
|---|---|
| 1 | 循环 do loop用于执行一定次数的语句。 需要执行语句的次数由传递给do循环的值确定。 |
| 2 | do-while循环 do-while语句用于模拟其他编程语言中存在的简单while循环。 |
| 3 | 直到循环 do-until循环是do while循环的轻微变化。 当被评估的条件为假时，该循环在退出的事实中变化。 |
受控重复
可以满足do循环以执行受控的重复语句。
语法 (Syntax)
这种语句的一般语法如下。
do index = start [to limit] [by increment] [for count]
statement #1
statement #2
end
此语句的不同之处在于存在一个索引，用于控制循环执行的次数。 其次，有一些参数可以说明索引应该从哪个开始的值，它应该在哪里结束以及什么是增量值。
流程图 (Flow Diagram)
让我们看一下这个循环的流程图 -
从上图中，您可以清楚地看到循环是根据索引值以及索引值的递增方式执行的。
以下程序是受控重复语句的示例。
例子 (Example)
/* Main program */
do i = 0 to 5 by 2
say "hello"
end
在上述程序中， count i的值首先设置为0。 然后它以2的计数递增，直到该值不大于5。
上述代码的输出将是 -
hello
hello
hello
Rexx - Decision Making
决策结构要求程序员指定一个或多个要由程序评估或测试的条件。
下图显示了大多数编程语言中的典型决策结构的一般形式。
如果确定条件为true ，则有一个或多个语句要执行，如果确定条件为false ，则可选择执行其他语句。
让我们看看Rexx中提供的各种决策声明。
| Sr.No. | 声明和说明 |
|---|---|
| 1 | If statement 第一个决策声明是if语句。 if语句由一个布尔表达式后跟一个或多个语句组成。 |
| 2 | If-else statement 下一个决策声明是if-else语句。 if语句后面可以跟一个可选的else语句，该语句在布尔表达式为false时执行。 |
嵌套If语句
有时需要将multiple if statements嵌入到彼此内部，这在其他编程语言中是可能的。 在Rexx中，这也是可能的。
语法 (Syntax)
if (condition1) then
do
#statement1
end
else
if (condition2) then
do
#statement2
end
流程图 (Flow Diagram)
嵌套if语句的流程图如下 -
让我们举一个嵌套if语句的例子 -
例子 (Example)
/* Main program */
i = 50
if (i < 10) then
do
say "i is less than 10"
end
else
if (i < 7) then
do
say "i is less than 7"
end
else
do
say "i is greater than 10"
end
上述计划的输出将是 -
i is greater than 10
选择语句
Rexx提供了select语句，可用于根据select语句的输出执行表达式。
语法 (Syntax)
本声明的一般形式是 -
select
when (condition#1) then
statement#1
when (condition#2) then
statement#2
otherwise
defaultstatement
end
本声明的一般工作如下 -
select语句有一系列when语句来评估不同的条件。
每个when clause都有一个不同的条件，需要进行评估并执行后续语句。
如果前面的条件不evaluate to true ，则otherwise语句用于运行任何默认语句。
流程图 (Flow Diagram)
select语句的流程图如下
以下程序是Rexx中的case语句的示例。
例子 (Example)
/* Main program */
i = 50
select
when(i <= 5) then
say "i is less than 5"
when(i <= 10) then
say "i is less than 10"
otherwise
say "i is greater than 10"
end
上述计划的输出将是 -
i is greater than 10
Rexx - Numbers
Rexx在数字方面有以下数据类型。
Integer - 一串不包含小数点或指数标识符的数字。 第一个字符可以是加号（+）或减号（ - ）。 表示的数字必须介于-2147483648和2147483647之间。
Big Integer - 一串不包含小数点或指数标识符的数字。 第一个字符可以是加号（+）或减号（ - ）。 表示的数字必须介于-9223372036854775808和2147483648之间，或者介于2147483648和9223372036854775807之间。
Decimal - 以下格式之一 -
包含小数点但没有指数标识符的数字字符串，其中p表示精度， s表示字符串表示的十进制数的比例。 第一个字符可以是加号（+）或减号（ - ）。
一串数字，不包含小数点或指数标识符。 第一个字符可以是加号（+）或减号（ - ）。 表示的数字小于-9223372036854775808或大于9223372036854775807。
Float - 表示科学记数的数字的字符串。 该字符串由一系列数字后跟一个指数标识符（E或e后跟可选的加号（+）或减号（ - ）和一系列数字）组成。 字符串可以以加号（+）或减号（ - ）开头。
现在让我们看一下methods available for numbers的不同methods available for numbers 。
| Sr.No. | 数字可用的方法 |
|---|---|
| 1 | ABS 此方法返回输入数字的绝对值。 |
| 2 | MAX 此方法从数字列表中返回最大值。 |
| 3 | MIN 此方法从数字列表中返回最小值。 |
| 4 | RANDOM 此方法返回随机生成的数字。 |
| 5 | SIGN 如果number大于0，则返回1;如果number为0，则返回0;如果number小于0，则返回-1。 |
| 6 | TRUNC 此方法会截断一个数字。 |
Rexx - Strings
Rexx中的字符串由一系列字符表示。 以下程序是字符串的示例 -
/* Main program */
a = "This is a string"
say a
上述计划的输出如下 -
This is a string
让我们讨论Rexx中可用于字符串的一些方法。
| Sr.No. | Rexx for Strings中提供的方法 |
|---|---|
| 1 | left 此方法从字符串的左侧返回一定数量的字符。 |
| 2 | right 此方法从字符串的右侧返回一定数量的字符。 |
| 3 | length 此方法返回字符串中的字符数。 |
| 4 | reverse 此方法以反向格式返回字符。 |
| 5 | compare 此方法比较2个字符串。 如果“string1”和“string2”相同，则返回“0”。 否则，它返回不匹配的第一个字符的位置。 |
| 6 | copies 此方法复制string n次。 |
| 7 | substr 此方法从特定字符串获取子字符串。 |
| 8 | pos 此方法返回一个字符串在另一个字符串中的位置。 |
| 9 | delstr 此方法从字符串中删除子字符串。 |
Rexx - 函数
Rexx中的代码通常分为函数和子例程。 使用函数有助于将代码分离为更多逻辑单元。 让我们详细看看这些功能。
定义一个函数 (Defining a Function)
函数声明的语法如下 -
FunctionName:
PARSE ARG arguement1, arguement2… arguementN
Return value
Where,
FunctionName - 这是分配给函数的名称。
PARSE ARG - 这些是Rexx中的关键字，用于提及参数传递给函数。
arguement1, arguement2… arguementN - 这些是传递给函数的参数。
Return value - 这是函数返回的值。
以下程序是Rexx中如何使用函数的简单示例。
/* Main program */
say add(5,6)
exit
add:
PARSE ARG a,b
return a + b
关于上述计划，应注意以下事项 -
我们定义了一个名为add的函数，它接受2个参数a和b。
该函数使用return语句返回a和b的总和。
退出语句必须用于表示主程序的结束。
上述方案的产出如下 -
11
使用参数
在Rexx中，可以使用特定的函数来处理参数。 让我们看看几个这样的论点。
arg
此方法用于返回为函数定义的参数数。
Syntax -
arg()
Parameters - 无
Return Value - 此方法返回为函数定义的参数数。
Example -
/* Main program */
say add(5,6)
exit
add:
PARSE ARG a,b
say arg()
return a + b
Output - 当我们运行上述程序时，我们将得到以下结果。
2
11
arg(index)
此方法用于返回特定位置的参数值。
Syntax -
arg(index)
Parameter -
Index - 要返回的参数的索引位置。
Return Value - 此方法返回特定位置的参数值。
Example -
/* Main program */
say add(5,6)
exit
add:
PARSE ARG a,b
say arg(1)
return a + b
Output - 当我们运行上述程序时，我们将得到以下结果。
5
11
递归函数 (Recursive Functions)
递归函数或例程是自称的函数。 任何递归函数都可以以传统的非递归方式（或迭代）进行编码，但有时递归提供了更好的问题解决方案。 并非所有编程语言都支持递归; 雷克斯。
让我们看一下使用Rexx中的递归函数的着名因子程序的示例。
/* Main program */
do n = 1 to 5
say 'The factorial of' n 'is:' factorial( n )
end
return
/* Function to get factorial */
factorial : procedure
n = arg(1)
if n = 1 then
return 1
return n * factorial( n - 1 )
上述计划的输出如下 -
The factorial of 1 is: 1
The factorial of 2 is: 2
The factorial of 3 is: 6
The factorial of 3 is: 24
The factorial of 3 is: 120
Rexx - Stacks
堆栈有时称为外部数据队列，但我们遵循常见用法并将其称为堆栈。 它是一块逻辑上在Rexx外部的内存块。 像push和queue这样的指令将数据放入堆栈，拉取和解析等指令从中提取数据。 排队的内置函数报告堆栈中有多少项。
我们来看一个堆栈的例子。
/* STACK: */
/* */
/* This program shows how to use the Rexx Stack as either a */
/* stack or a queue. */
do j = 1 to 3
push ‘Stack: line #’ || j
/* push 3 lines onto the stack */
end
do j = 1 to queued()
/* retrieve and display LIFO */
pull line
say line
end
do j = 1 to 3 queue ‘Queue: line #’ || j
/* queue 3 lines onto the stack */
end
do queued()
/* retrieve and display FIFO */
pull line
say line
end
exit 0
程序中的第一个do循环将三行数据放入堆栈。 它使用push指令来执行此操作。 我们对这些行进行编号，以便在以LIFO顺序检索它们时，它们的顺序是明显的。
通过推送指令放入堆栈的项目在LIFO订单中检索 -
do j = 1 to 3
push ‘Stack: line #’ || j /* push 3 lines onto the stack */
end
下一个代码块显示了使用排队的内置函数来发现堆栈上的行数，以及一个从堆栈中检索所有行的循环 -
do j = 1 to queued() /* retrieve and display LIFO */
pull line
say line
end
由于这三个项目是通过推送放在堆栈上的，因此它们是以LIFO顺序检索的。
上述程序的输出如下。
STACK: LINE #3
STACK: LINE #2
STACK: LINE #1
Rexx - File I/O
在使用I/O时，Rexx提供了许多方法。 Rexx提供了更简单的类来为文件提供以下功能。
- 读文件
- 写入文件
- 查看文件是文件还是目录
Rexx for File I/O中可用的功能基于线路输入和字符输入，我们将详细介绍两者可用的功能。
让我们来探讨一下Rexx提供的一些文件操作。 出于这些示例的目的，我们假设有一个名为NewFile.txt的文件，其中包含以下文本行 -
Example1
Example2
Example3
此文件将用于以下示例中的读取和写入操作。 在这里，我们将讨论如何以不同方式读取文件中的内容。
一次读取一行文件的内容
对文件的一般操作是使用Rexx库本身中提供的方法执行的。 读取文件是Rexx中最简单的操作。
让我们看一下用于实现此目的的函数。
linein
此方法从文本文件返回一行。 文本文件是作为函数的输入参数提供的文件名。
Syntax -
linein(filename)
Parameter -
filename - 这是需要读取行的文件的名称。
Return Value - 此方法一次返回文件的一行。
Example -
/* Main program */
line_str = linein(Example.txt)
say line_str
上面的代码非常简单，因为Example.txt文件名被提供给linein函数。 然后，此函数读取一行文本并将结果提供给变量line_str 。
Output - 当我们运行上述程序时，我们将得到以下结果。
Example1
一次读取文件的内容
在Rexx中，可以在while语句的帮助下读取文件的所有内容。 while语句将逐个读取每一行，直到到达文件末尾。
关于如何实现这一点的一个例子如下所示。
/* Main program */
do while lines(Example.txt) > 0
line_str = linein(Example.txt)
say line_str
end
在上述计划中，需要注意以下事项 -
lines函数读取Example.txt文件。
while函数用于检查Example.txt文件中是否存在更多行。
对于从文件读取的每一行， line_str变量保存当前行的值。 然后将其作为输出发送到控制台。
Output - 当我们运行上述程序时，我们将得到以下结果。
Example1
Example2
Example3
将内容写入文件
就像读取文件一样，Rexx也能够写入文件。 让我们看一下用于实现此目的的函数。
lineout
此方法将一行写入文件。 需要将行写入的文件作为lineout语句的参数提供。
Syntax -
lineout(filename)
Parameter -
filename - 这是需要写入行的文件的名称。
Return Value - 此方法返回lineout函数的状态。 如果成功写入行，则返回的值为0，否则返回值1。
Example -
/* Main program */
out = lineout(Example.txt,"Example4")
Output - 每当运行上述代码时，“Example4”行将被写入文件Example.txt 。
Rexx - Functions For Files
在本章中，我们将讨论可用于文件的一些其他功能。
| Sr.No. | 文件功能 |
|---|---|
| 1 | Lines 此函数返回值1或输入流中要读取的行数。 文件名作为函数的输入。 |
| 2 | stream 此功能用于检查文件的状态。 有时需要在使用文件之前检查文件的状态。 如果文件已损坏或不可用，则无法对该文件执行进一步操作。 因此，首先检查文件的状态更有意义。 |
| 3 | charin 此函数用于从文件中一次读取一个字符。 有时程序需要以字符方式读取文件，因此该功能可用于此目的。 |
| 4 | chars 此函数返回1或要在文件本身中读取的字符数。 提到文件名作为函数的参数。 |
| 5 | charout 此函数用于一次将一个字符写入文件。 文件名作为参数输入到函数中。 |
Rexx - Subroutines
在任何编程语言中，整个程序都被分解为逻辑模块。 这样可以更轻松地编写可以轻松维护的代码。 这是任何编程语言的基本要求。
在Rexx中，可以使用子例程和函数编写模块。 让我们详细看一下子程序。
定义子程序
函数声明的语法如下 -
FunctionName:
Statement#1
Statement#2
….
Statement#N
Where,
FunctionName - 这是分配给子例程的名称。
Statement#1 .. Statement#N - 这些是构成子程序的语句列表。
以下程序是一个显示子程序使用的简单示例。
/* Main program */
call add
exit
add:
a = 5
b = 10
c = a + b
say c
关于上述计划，应注意以下事项 -
我们正在定义一个名为add的子程序。
子例程执行简单的添加功能。
退出语句必须用于表示主程序的结束。
上述方案的产出如下 -
15
使用参数
也可以在Rexx中使用参数。 以下示例显示了如何实现此目的。
/* Main program */
call add 1,2
exit
add:
PARSE ARG a,b
c = a + b
say c
关于上述计划，应注意以下事项 -
我们正在定义一个名为add的子程序，它接受2个参数。
在子例程中，使用PARSE和ARG关键字解析2个参数。
上述方案的产出如下 -
3
参数的不同方法
让我们看一下可用于参数的其他一些方法。
arg
此方法用于返回为子例程定义的参数数。
Syntax -
arg()
Parameters - 无
Return Value - 此方法返回为子例程定义的参数数。
Example -
/* Main program */
call add 1,2
exit
add:
PARSE ARG a,b
say arg()
c = a + b
say c
当我们运行上述程序时，我们将得到以下结果。
2
3
arg(index)
此方法用于返回特定位置的参数值。
Syntax -
arg(index)
Parameters
Index - 要返回的参数的索引位置。
Return Value - 此方法返回特定位置的参数值。
Example -
/* Main program */
call add 1,2
exit
add:
PARSE ARG a,b
say arg(1)
c = a + b
say c
当我们运行上述程序时，我们将得到以下结果。
1
3
Rexx - 内置函数
每种编程语言都有一些内置函数，可以帮助程序员完成一些日常任务。 Rexx还有很多内置功能。
让我们看看Rexx中提供的所有这些功能。
| Sr.No. | Rexx中可用的功能 |
|---|---|
| 1 | ADDRESS 此方法返回当前运行Rexx命令的环境的名称。 |
| 2 | BEEP 该方法在特定频率和持续时间内在系统中产生声音。 |
| 3 | DataType 如果输入是有效数字，则此方法返回'NUM'的值，否则它将返回'CHAR'的值。 您还可以指定是否要将输入值与NUM或CHAR值进行比较。 在每种情况下，返回的值将是1或0，具体取决于结果。 |
| 4 | DATE 此方法以以下格式返回本地日期。 |
| 5 | DIGITS 此方法返回当前系统中定义的NUMERIC DIGITS的当前设置。 |
| 6 | ERRORTEXT 此方法返回与错误号'errorno'关联的Rexx错误消息。 请注意，错误号必须是0到99之间的值。这在程序返回错误代码并且您想知道错误代码含义的情况下非常有用。 |
| 7 | FORM 此方法返回'NUMERIC FORM'的当前设置，该设置用于在系统上进行数学计算。 |
| 8 | TIME 此方法以24小时时钟格式返回本地时间，如以下程序所示。 |
| 9 | USERID 此方法返回登录到系统的当前用户标识。 |
| 10 | XRANGE 此方法返回由开始和结束字符指定的范围内的字符。 |
| 11 | X2D 此方法返回hexstring value的十进制转换。 |
| 12 | X2C 此方法返回十六进制值的字符转换。 |
Rexx - System Commands
Rexx的最大优势之一是能够创建可重用的脚本。 现在，在组织中，具有可重复使用的脚本是一个很大的附加值，可以节省执行常见重复性任务的时间。
例如，IT组织中的技术团队可能需要具有执行常见日常任务的脚本。 这些任务可以包括与操作系统交互。 然后可以对这些脚本进行编程以处理错误的返回码或错误。
Rexx提供了许多可用于执行此类重复任务的系统命令。 我们来看看Rexx中可用的一些系统命令。
dir
这是Windows中使用的常规目录列表命令。
语法 (Syntax)
dir
参数 (Parameters)
没有
返回值 (Return Value)
此方法返回系统上的当前目录列表。
例子 (Example)
/* Main program */
dir
输出取决于系统中的目录。
以下程序只是一个例子。
输出 (Output)
Volume in drive D is LENOVO
Volume Serial Number is BAC9-9E3F
Directory of D:\
04/06/2016 12:52 AM 268,205 100008676689.pdf
10/20/2015 08:51 PM <DIR> data
06/01/2016 10:23 AM 31 Example.txt
10/28/2014 06:55 PM <DIR> Intel
06/02/2016 11:15 AM 23 main.rexx
12/22/2014 08:49 AM <DIR> PerfLogs
12/13/2015 11:45 PM <DIR> Program Files
12/24/2015 10:26 AM <DIR> Program Files (x86)
07/17/2015 01:21 AM <DIR> Users
12/23/2015 10:01 AM <DIR> Windows
3 File(s) 268,259 bytes
7 Dir(s) 202,567,680 bytes free
dir command另一个示例显示在以下程序中。 只有这次我们正在使用special rc variable 。 此变量在Rexx中是特殊的，它为您提供系统命令执行的状态。 如果返回的值为0，则表示命令执行成功。 否则，错误号将在rc变量名中给出。
例子 (Example)
/* Main program */
dir
if rc = 0 then
say 'The command executed successfully'
else
say 'The command failed, The error code is =' rc
当我们运行上述程序时，我们将得到以下结果。
输出 (Output)
The command failed, The error code is = 127
Redirection Commands
Rexx还具有使用重定向命令的功能。 Rexx中提供了以下重定向命令。
< - 此命令用于接收来自文件的输入。
> - 此命令用于将内容输出到文件。 如果文件确实存在，则会覆盖该文件。
》》 - 这也用于将内容输出到文件。 但是输出会添加到文件末尾以保留文件的现有内容。
让我们看一下如何使用重定向命令的示例。 在下面的示例中，我们使用sort命令对名为sortin.txt的文件进行排序。 文件中的数据将发送到sort命令。 然后sort命令的输出发送到sortout.txt文件。
例子 (Example)
/* Main program */
'sort <sortin.txt> sortout.txt'
假设文件sortin.txt具有以下数据。
输出 (Output)
b
c
a
然后，文件sortout.txt将具有以下数据。
a
b
c
ADDRESS功能
此方法用于查找用于输入，错误和输出流的默认环境。
语法 (Syntax)
ADDRESS(options)
参数 (Parameters)
什么是特定系统的地址的选项。
返回值 (Return Value)
此方法返回Input，Error和Output流的环境名称。
例子 (Example)
/* Main program */
say ADDRESS('I')
say ADDRESS('O')
say ADDRESS('E')
当我们运行上述程序时，我们将得到以下结果。
输出 (Output)
INPUT NORMAL
REPLACE NORMAL
REPLACE NORMAL
Rexx - XML
XML是一种可移植的开源语言，它允许程序员开发可由其他应用程序读取的应用程序，而不管操作系统和/或开发语言如何。 这是用于在应用程序之间交换数据的最常用语言之一。
什么是XML？
可扩展标记语言XML是一种非常类似于HTML或SGML的标记语言。 这是万维网联盟推荐的，可作为开放标准提供。 XML对于跟踪中小数据量而非需要基于SQL的主干非常有用。
对于我们所有的XML代码示例，让我们使用以下简单的XML文件movies.xml来构建XML文件并随后读取该文件。
<collection shelf = "New Arrivals">
<movie title = "Enemy Behind">
<type>War, Thriller</type>
<format>DVD</format>
<year>2003</year>
<rating>PG</rating>
<stars>10</stars>
<description>Talk about a US-Japan war</description>
</movie>
<movie title = "Transformers">
<type>Anime, Science Fiction</type>
<format>DVD</format>
<year>1989</year>
<rating>R</rating>
<stars>8</stars>
<description>A schientific fiction</description>
</movie>
<movie title = "Trigun">
<type>Anime, Action</type>
<format>DVD</format>
<year>1986</year>
<rating>PG</rating>
<stars>10</stars>
<description>Vash the Stam pede!</description>
</movie>
<movie title = "Ishtar">
<type>Comedy</type>
<format>VHS</format>
<year>1987</year>
<rating>PG</rating>
<stars>2</stars>
<description>Viewable boredom </description>
</movie>
</collection>
入门
默认情况下，Reml解释器中不包含xml功能。 要在Rexx中使用XML，需要遵循以下步骤。
下载以下文件 -
Rexxxml - www.interlog.com/~ptjm/
Libxml2 - www.ctindustries.net/libxml/
iconv-1.9.2.win32 - www.xmlsoft.org/sources/win32/oldreleases/
libxslt-1.1.26.win32 - www.xmlsoft.org/sources/win32/oldreleases/
提取所有文件并确保它们包含在系统路径中。
加载XML函数 (Loading XML Functions)
一旦下载并成功注册了上一节中的所有文件，下一步就是编写代码以加载Rexx XML函数。 这是通过以下代码完成的。
rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs')
if rcc then do
say rxfuncerrmsg()
exit 1
end
call xmlloadfuncs
关于上述计划，可以注意以下事项 -
函数rxfuncadd用于加载外部库。 xmlloadfuncs函数用于将rexxxml文件中的所有库加载到内存中。
如果rcc <> 0的值，则会导致错误。 为此，我们可以调用rxfuncerrmsg来提供有关错误消息的更多详细信息。
我们最终调用xmlloadfuncs ，以便现在可以在Rexx程序中启用所有与xml相关的功能。
我们来看看methods available for XML in Rexx的各种methods available for XML in Rexx 。
xmlVersion
此方法返回系统上使用的XML和XSLT库的版本。
语法 (Syntax)
xmlVersion()
参数 (Parameters)
没有
返回值 (Return Value)
此方法返回系统上使用的XML和XSLT库的版本。
例子 (Example)
rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs')
if rcc then do
say rxfuncerrmsg()
exit 1
end
call xmlloadfuncs
say xmlVersion()
当我们运行上面的程序时，我们将得到以下结果。 这又取决于系统上使用的XML库的版本。
输出 (Output)
1.0.0 20631 10126
xmlParseXML
此函数用于解析发送到函数的XML数据。 文档树由函数返回。
语法 (Syntax)
xmlParseXML(filename)
参数 (Parameters)
Filename - 这是需要解析的XML文件的名称。
返回值 (Return Value)
文档树由函数返回。 如果有错误，则返回0。
例子 (Example)
rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs')
if rcc then do
say rxfuncerrmsg()
exit 1
end
call xmlloadfuncs
say xmlVersion()
sw = xmlParseXML('test.xml')
输出 (Output)
没有一般输出。
xmlFindNode
此方法计算传递给它的XPath expression 。 这用于解析文档树以产生可以进一步处理的nodeset 。
语法 (Syntax)
xmlParseXML(XPath,document)
参数 (Parameters)
XPath - 这是xml文件中节点的路径。
document - 这是XML文档
返回值 (Return Value)
计算XPath表达式并将结果作为节点集返回，以后可以使用。
例子 (Example)
rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs')
if rcc then do
say rxfuncerrmsg()
exit 1
end
call xmlloadfuncs
say xmlVersion()
document = xmlParseXML('test.xml')
nodeset = xmlFindNode('//movie', document)
say xmlNodesetCount(nodeset)
当我们运行上面的程序时，我们将得到以下结果。
输出 (Output)
4
输出显示xml列表中的电影节点数
xmlEvalExpression
以下方法用于评估XPath表达式并返回字符串作为结果。
语法 (Syntax)
xmlParseXML(XPath,Node)
参数 (Parameters)
XPath - 这是xml文件中节点的路径。
document - 特定节点元素。
返回值 (Return Value)
根据发送给它的XPath表达式返回一个字符串。
例子 (Example)
rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs')
if rcc then do
say rxfuncerrmsg()
exit 1
end
call xmlloadfuncs
document = xmlParseXML('test.xml')
nodeset = xmlFindNode('//movie', document)
do j = 1 to xmlNodesetCount(nodeset)
value = xmlEvalExpression('type', xmlNodesetItem(nodeset, j))
say value
end
当我们运行上面的程序时，我们将得到以下结果。
输出 (Output)
War, Thriller
Anime, Science Fiction
Anime, Action
Comedy
Rexx - Regina
Regina是另一个可用于编译和运行Rexx程序的Rexx解释器。 里贾纳的官方网站是 - www.regina-rexx.sourceforge.net/
使用里贾纳的一些优点如下 -
Regina可以在任何平台上运行，无论是Windows，Linux还是Mac OS。
Regina按照所有可用标准工作。
里贾纳有一个很大的社区跟随，因此里贾纳有很多论坛和学习材料。
Regina有很多工具可用于编写和测试Rexx程序。
在Regina中，您可以运行默认Rexx Interpreter中无法执行的命令。 例如，如果包含某些配置设置，则可以实际运行基本系统级命令，这在Rexx中是不可能的。
当您通过Chapter 2 – Rexx Environment记录的安装安装Chapter 2 – Rexx Environment ，Regina解释器随之安装。
现在让我们看看使用Regina时可用的一些常用方法。 这些功能是扩展功能，通过正常使用无法使用。
要使用扩展函数，您需要包含以下代码行。 这使得可以使用Regina扩展功能。
options arexx_bifs
其次，在运行所有Rexx程序时，请使用以下命令。
regina main.rexx
Where,
regina - 这是用于Rexx程序的解释器。
main.rexx - 你的Rexx程序。
我们现在将详细讨论functions of Regina Rexx Interpreter的各种functions of Regina Rexx Interpreter 。
| Sr.No. | Regina Rexx口译员的职能 |
|---|---|
| 1 | b2c 此方法用于将二进制值转换为字符串值。 |
| 2 | bitcomp 该方法用于逐位比较2位串。 |
| 3 | bittst 此方法用于指示位串中指定位的状态。 |
| 4 | find 此方法用于搜索另一个字符串中第一次出现的字符串。 |
| 5 | getenv 此方法返回系统上环境变量的值。 |
| 6 | getpid 此方法用于获取当前运行进程ID的值。 |
| 7 | hash 此方法返回字符串的哈希属性作为十进制数。 它还会更新字符串的内部哈希值。 |
| 8 | justify 此方法用于根据长度值添加对齐或修剪字符串值。 |
| 9 | putenv 此方法用于设置环境变量的值。 |
| 10 | directory 此方法获取系统上当前目录的值。 |
| 11 | chdir 此方法更改系统上当前工作目录的值。 |
| 12 | randu 此方法返回0到1之间的伪随机数。 |
Rexx - Parsing
Rexx最强大的功能之一是它能够解析文本值。 您可能不会在任何其他编程语言中看到这一点。
解析语句的一般格式如下 -
语法 (Syntax)
PARSE {UPPER|LOWER|CASELESS} source {template}
Where,
UPPER - 在解析之前将源转换为大写。
LOWER - 在解析之前将源转换为小写。
CASELESS - 传递此参数时，将忽略大小写。
source - 这是需要解析的源。 有很多选择，可以是以下任何一种 -
ARG - 程序或过程的参数可用作源。
LINEIN - 下一行输入可用作源。
SOURCE - 程序的源信息可用作源。
VAR name - 变量名称的值可用作源。
template - 此参数指定如何解析源。 有很多选择。 其中一些在下面提到。
variable name - 这是分配给变量的值。
literal string - 一个文字字符串，可用于分割串行的模式。
# - 源本身内的绝对字符位置。 因此，如果指定值5，将使用第 5 个字符。
+# - 源本身内的相对字符位置。 因此，如果指定值5，则将相对使用第 5 个字符。
让我们看一个如何在Rexx中完成解析的简单示例。
例子 (Example)
/* Main program */
parse value 'This is a Tutorial' with word1 word2 word3 word4
say "'"word1"'"
say "'"word2"'"
say "'"word3"'"
say "'"word4"'"
上述程序解析短语中的单词。 当值由仅由一个空格分隔的单词组成，并且没有前导或尾随空格时，该值很容易解析为已知数量的单词，如下所示。
在Rexx中使用解析函数获取字符串值，然后将其分解为单词。 在上面的例子中，然后将这些单词拆分，然后存储在单词变量中。
上述方案的产出如下 -
'This'
'is'
'a'
'Tutorial'
解析的另一个示例显示在以下程序中。 这次我们使用while子句来进行解析。
例子 (Example)
/* Main program */
phrase = 'This is a Tutorial'
do while phrase <> ''
parse var phrase word phrase
say "'"word"'"
end
以上程序将给出以下输出 -
'This'
'is'
'a'
'Tutorial'
定位解析
Rexx还允许使用位置解析。 让我们看一个如何使用parse语句实现位置解析的示例。
例子 (Example)
/* Main program */
testString = "Doe John M. 03/03/78 Mumbai India";
parse var testString name1 11 name2 21 birthday 31 town 51 country
say name1
say name2
say birthday
say town
say country
从上面的例子中，您可以注意到，除了变量名，我们还指定了字符串应该结束的位置。 所以对于name1，我们应该以第11个字符结束，然后开始解析name2。
上述计划的输出如下 -
Doe
John M.
03/03/78
Mumbai
India
在这种情况下，您还可以使用relative positional parsing 。
例子 (Example)
/* Main program */
testString = "Doe John M. 03/03/78 Mumbai India";
parse var testString name1 +10 name2 +10 birthday +10 town +20 country
say name1
say name2
say birthday
say town
say country
上述程序的输出如下所示。
Doe
John M.
03/03/78
Mumbai
India
Rexx - Signals
在Rexx中，信号指令通常用于两个目的，即 -
一种是将控制权转移到该计划的另一部分。 这通常类似于其他编程语言中使用的首选标签。
另一种是去特定的陷阱标签。
如果在以下任何指令命令中使用signal命令，则将自动停用待处理的控制结构。
如果......那么......其他......
做...结束
做我= 1到n ...结束[和类似的做循环]
选择......然后......等等。 否则......结束
signal语句的一般语法如下所示 -
语法 (Syntax)
signal labelName
signal [ VALUE ] labelExpression
我们来看一个如何使用signal语句的例子。
例子 (Example)
/* Main program */
n = 100.45
if\datatype( n, wholenumber ) then
signal msg
say 'This is a whole number'
return 0
msg :
say 'This is an incorrect number'
上述程序的输出如下所示。
输出 (Output)
This is an incorrect number.
如果将变量n的值更改为整数，如以下程序所示 -
/* Main program */
n = 100
if\datatype( n, wholenumber ) then
signal msg
say ' This is a whole number '
return 0
msg :
say ' This is an incorrect number '
您将获得以下输出 -
This is a whole number
也可以转移到标签的值，如下面的程序所示 -
/* Main program */
n = 1
if\datatype( n, wholenumber ) then
signal msg
if n < 1 | n > 3 then
signal msg
signal value n
3 : say 'This is the number 3'
2 : say ' This is the number 2'
1 : say ' This is the number 1'
return n
msg :
say ' This is an incorrect number '
exit 99
上述程序的输出如下所示 -
This is the number 1
陷阱标签转移激活/取消激活
正如我们前面提到的，信号指令也可用于将控制转移到陷阱标签。
陷阱标签传输的一般语法如下 -
语法 (Syntax)
signal ON conditionName [ NAME Label ]
signal OFF conditionName
Where,
conditionName - 这是应该打开或关闭信号的条件。
Label - 程序应转移到的可选标签。
让我们看一个使用陷阱标签传输的示例。
例子 (Example)
/* Main program */
signal on error
signal on failure
signal on syntax
signal on novalue
beep(1)
signal off error
signal off failure
signal off syntax
signal off novalue
exit 0
error: failure: syntax: novalue:
say 'An error has occured'
在上面的例子中，我们首先打开错误信号。 然后我们添加一个会导致错误的语句。 然后我们有错误陷阱标签来显示自定义错误消息。
上述程序的输出如下所示 -
An error has occurred.
Rexx - Debugging
调试是任何编程语言的重要特性。 它可以帮助开发人员诊断错误，找到根本原因，然后相应地解决它们。 在Rexx中，跟踪实用程序用于调试。 跟踪指令可以通过两种方式实现，一种是批处理模式，另一种是交互模式。 我们来看看如何实现这两个选项。
以批处理模式跟踪
trace命令用于给出执行的每个Rexx命令的详细级别。
trace语句的一般语法如下所示 -
语法 (Syntax)
trace [setting]
设置可以是以下任何选项 -
A - 跟踪所有命令。
C - 仅跟踪发送到操作系统的主机命令。
E - 仅跟踪发送到操作系统的导致错误的主机命令。
F - 仅跟踪发送到操作系统的导致失败的主机命令。
I - 这提供了Rexx命令的中间级跟踪。
L - 如果要在跟踪发生时标记跟踪，则此选项。
N - 这是默认选项，不会发生跟踪。
我们来看一下trace命令的一个例子。
例子 (Example)
/* Main program */
trace A
/* Main program */
n = 100.45 if datatype( n, wholenumber ) then signal msg
say 'This is a whole number'
return 0
msg :
say ' This is an incorrect number '
上述计划的输出如下 -
5 *-* n = 100.45 if datatype( n, wholenumber ) then signal msg
7 *-* say 'This is a whole number
This is a whole number
8 *-* return 0
从输出中，您可以看到附加跟踪已添加到程序的输出中。 关于输出可以注意以下事项 -
行号和执行的语句将添加到跟踪输出中。
执行的每一行都显示在跟踪输出中。
跟踪功能
也可以在跟踪功能的帮助下启用跟踪。 一般语法和示例如下所示。
语法 (Syntax)
trace()
上述函数返回当前跟踪级别。
参数 (Parameters)
没有
返回值 (Return Value)
上面的函数给出了当前的跟踪级别。
例子 (Example)
/* Main program */
say trace()
/* Main program */
n = 100.45 if datatype( n, wholenumber ) then signal msg
say 'This is a whole number'
return 0
msg :
say 'This is an incorrect number '
上述程序的输出如下。
N
This is an incorrect number
N的第一行表示跟踪设置为Normal。
设置跟踪值
可以使用跟踪功能设置跟踪级别。 一般语法和示例如下所示。
语法 (Syntax)
trace(travel_level)
参数 (Parameters)
trace_level - 这类似于可用于设置跟踪级别的选项。
返回值 (Return Value)
上面的函数给出了当前的跟踪级别。
例子 (Example)
/* Main program */
say trace()
current_trace = trace('A')
say current_trace
/* Main program */
n = 100.45 if datatype( n, wholenumber ) then
signal msg say 'This is a whole number'
return 0
msg :
say ' This is an incorrect number '
上述计划的输出如下 -
N
4 *-* say current_trace
N
6 *-* n = 100.45
7 *-* if\datatype( n, wholenumber ) then
8 *-* signal msg
12 *-* say 'This is an incorrect number'
'This is an incorrect number'
互动追踪
交互式跟踪是其中，跟踪是在程序运行时执行的。 就像在Visual Studio for .Net等IDE中一样，您可以在其中添加断点并查看每个语句的执行方式，同样在这里您也可以看到每个代码行运行时的程序。
一般语法如下 -
语法 (Syntax)
trace ?options
其中，trace命令的选项相同，如下所示。
A - 跟踪所有命令
C - 仅跟踪发送到操作系统的主机命令。
E - 仅跟踪发送到操作系统的导致错误的主机命令。
F - 仅跟踪发送到操作系统的导致失败的主机命令。
I - 这提供了Rexx命令的中间级跟踪。
L - 如果要在跟踪发生时标记跟踪，则此选项。
N - 这是默认选项，不会发生跟踪。
我们来看一个实现主动跟踪的示例。
例子 (Example)
/* Main program */
trace ?A
/* Main program */
n = 100.45 if datatype( n, wholenumber ) then
signal msg
say 'This is a whole number'
return 0
msg : say 'This is an incorrect number'
上述程序的输出将如以下程序所示。 跟踪将在每行代码处停止; 然后你需要按Enter按钮移动到下一行代码。
This is an incorrect number
+++ "LINUX COMMAND /home/cg/root/5798511/main.rex"
5 *-* n = 100.45 if datatype( n, wholenumber ) then
+++ Interactive trace. "Trace Off" to end debug, ENTER to Continue. +++
6 *-* signal msg
10 *-* msg :
10 *-* say 'This is an incorrect number'
Rexx - Error Handling
与其他编程语言一样，Rexx也能够处理错误处理。
以下是Rexx中出现的各种错误情况。
ERROR - 只要发送到操作系统的命令导致ERROR ，就会引发此偶数。
FAILURE - 每当发送到操作系统的命令导致失败时，都会引发此故障。
HALT - 每当操作依赖于另一个操作时，通常会引发此操作。 例如，如果由于任何原因暂停I/O操作。
NOVALUE - 未将值赋给变量时引发此事件。
NOTREADY - 由任何未准备接受任何操作的I/O设备引发。
SYNTAX - 如果代码中存在任何语法错误，则会引发此事件。
LOSTDIGITS - 当算术运算导致操作期间丢失数字时，将引发此事件。
陷阱错误
在signal命令的帮助下捕获错误。 我们来看看语法和示例。
语法 (Syntax)
signal on [Errorcondition]
Where,
错误条件 - 这是上面给出的错误条件。
例子 (Example)
我们来看一个例子吧。
/* Main program */
signal on error
signal on failure
signal on syntax
signal on novalue beep(1)
signal off error
signal off failure
signal off syntax
signal off novalue
exit 0
error: failure: syntax: novalue:
say 'An error has occured'
在上面的例子中，我们首先打开错误信号。 然后我们添加一个会导致错误的语句。 然后我们有错误陷阱标签来显示自定义错误消息。
上述程序的输出如下所示。
An error has occurred.
以下程序中显示了错误代码的示例。
/* Main program */
signal on error
signal on failure
signal on syntax
signal on novalue beep(1)
exit 0
error: failure: syntax: novalue:
say 'An error has occured'
say rc
say sigl
上述程序的输出如下所示。
An error has occured
40
6
Rexx - Object Oriented
根据环境章节安装ooRexx时，您还可以使用类和对象。 请注意，以下所有代码都需要在ooRexx解释器中运行。 普通的Rexx解释器将无法运行此面向对象的代码。
类和方法声明
使用以下语法声明定义类。
语法 (Syntax)
::class classname
其中classname是给予classname的名称。
使用以下语法声明定义类中的方法。
语法 (Syntax)
::method methodname
其中methodname是为方法指定的名称。
使用以下语法声明定义类中的属性。
语法 (Syntax)
::attribute propertyname
其中propertyname是为该propertyname指定的名称。
例子 (Example)
以下是Rexx中的类的示例。
::class student
::attribute StudentID
::attribute StudentName
关于上述计划，需要注意以下几点。
- class的名字是学生。
- 该类有2个属性，StudentID和StudentName。
Getter和Setter方法
Getter和Setter方法用于自动设置和获取属性的值。 在Rexx中，当您使用attribute关键字声明属性时，getter和setter方法已经到位。
例子 (Example)
::class student
::attribute StudentID
::attribute StudentName
在上面的示例中，将有StudentId和StudentName的Getter和Setter方法。
以下程序显示了如何使用它们的示例。
/* Main program */
value = .student~new
value~StudentID = 1
value~StudentName = 'Joe'
say value~StudentID
say value~StudentName
exit 0
::class student
::attribute StudentID
::attribute StudentName
上述程序的输出如下所示。
1
Joe
实例方法
可以通过~new operator从类创建对象。 可以通过以下方式调用该类中的方法。
Object~methodname
其中methodname是需要从类中调用的方法。
例子 (Example)
以下示例显示如何从类创建对象以及调用的相应方法。
/* Main program */
value = .student~new
value~StudentID = 1
value~StudentName = 'Joe'
value~Marks1 = 10
value~Marks2 = 20
value~Marks3 = 30
total = value~Total(value~Marks1,value~Marks2,value~Marks3)
say total
exit 0
::class student
::attribute StudentID
::attribute StudentName
::attribute Marks1
::attribute Marks2
::attribute Marks3
::method 'Total'
use arg a,b,c
return (ABS(a) + ABS(b) + ABS(c))
上述程序的输出如下所示。
60
创建多个对象
人们还可以创建一个类的多个对象。 以下示例将说明如何实现此目的。
在这里，我们创建了3个对象（st，st1和st2）并相应地调用它们的实例成员和实例方法。
我们来看一个如何创建多个对象的示例。
例子 (Example)
/* Main program */
st = .student~new
st~StudentID = 1
st~StudentName = 'Joe'
st~Marks1 = 10
st~Marks2 = 20
st~Marks3 = 30
total = st~Total(st~Marks1,st~Marks2,st~Marks3)
say total
st1 = .student~new
st1~StudentID = 2
st1~StudentName = 'John'
st1~Marks1 = 10
st1~Marks2 = 20
st1~Marks3 = 40
total = st1~Total(st1~Marks1,st1~Marks2,st1~Marks3)
say total
st2 = .student~new
st2~StudentID = 3
st2~StudentName = 'Mark'
st2~Marks1 = 10
st2~Marks2 = 20
st2~Marks3 = 30
total = st2~Total(st2~Marks1,st2~Marks2,st2~Marks3)
say total
exit 0
::class student
::attribute StudentID
::attribute StudentName
::attribute Marks1
::attribute Marks2
::attribute Marks3
::method 'Total'
use arg a,b,c
return (ABS(a) + ABS(b) + ABS(c))
上述程序的输出如下所示。
60
70
60
继承 (Inheritance)
继承可以定义为一个类获取另一个类的属性（方法和字段）的过程。 通过使用继承，可以按层次顺序管理信息。
继承其他属性的subclass称为subclass （派生类，子类），其属性被继承的superclass称为superclass （基类，父类）。
让我们看一下Rexx中的继承示例。 在下面的示例中，我们将创建一个名为Person的类。 从那里我们使用subclass关键字将Student class创建sub-class of Person的sub-class of Person 。
例子 (Example)
/* Main program */
st = .student~new
st~StudentID = 1
st~StudentName = 'Joe'
st~Marks1 = 10
st~Marks2 = 20
st~Marks3 = 30
say st~Total(st~Marks1,st~Marks2,st~Marks3)
exit 0
::class Person
::class student subclass Person
::attribute StudentID
::attribute StudentName
::attribute Marks1
::attribute Marks2
::attribute Marks3
::method 'Total'
use arg a,b,c
return (ABS(a) + ABS(b) + ABS(c))
上述程序的输出如下所示。
60
Rexx - Portability
可移植性是任何编程语言的重要方面。 众所周知，Rexx可用于各种操作系统，如Windows和Linux。 因此，需要确保在Windows平台上开发程序时，如果在Linux平台上运行相同的程序，则需要采取必要的预防措施。
Rexx能够运行系统级命令。 有些命令可用于了解运行它的操作系统是什么。 根据输出，它可以采取适当的操作来查看可以在此操作系统上运行的命令。
例子 (Example)
以下示例显示了如何使用解析函数来获取运行程序的操作系统的详细信息。
/* Main program */
parse version language level date month year.
parse source system invocation filename.
language = translate(language)
if pos('REGINA',language) = 0 then
say 'Error , the default interpreter is not Regina' language
say 'The Interpreter version/release date is:' date month year
say 'The Language level is: ' level say 'The Operating System is'
select
when system = 'WIN32' then
'ver'
when system = 'UNIX' | system = 'LINUX' then
'uname -a'
otherwise
say 'Unknown System:' system
end
if rc <> 0 then
say 'Error :' rc
输出将根据操作系统而有所不同。 下面给出了一个示例输出。
The Interpreter version/release date: 5 Apr 2015
The Language level is: 5.00
The Operating System is
Unknown System: WIN64
Bad return code: RC
扩展功能 (Rexx - Extended Functions)
Rexx提供了许多扩展功能，可提供各种功能，其中大部分功能允许您与操作系统进行交互。 让我们详细看一下它们中的一些，如下所述。
| Sr.No. | 扩展功能 |
|---|---|
| 1 | b2c 此函数将二进制值转换为字符串值。 |
| 2 | bitclr 此函数用于将二进制字符串中的指定位切换为0。 |
| 3 | bitcomp 此函数用于比较从位0开始的2个二进制字符串。 |
| 4 | buftype 此函数用于显示通常用于调试目的的堆栈内容。 |
| 5 | crypt 此函数用于加密字符串。 |
| 6 | fork 此函数用于在系统上生成新的子进程。 |
| 7 | getpid 此函数获取当前正在运行的进程的id。 |
| 8 | hash 此函数返回字符串的哈希值。 |
Rexx - Instructions
Rexx提供了许多指令，这些指令提供了各种功能，其中大多数功能允许您与操作系统进行交互。 让我们详细看一下它们中的一些。
| Sr.No. | Rexx说明 |
|---|---|
| 1 | address 此函数用于显示当前命令环境。 |
| 2 | drop 此函数用于取消分配变量。 |
| 3 | interpret 解释或执行定义的指令。 |
| 4 | nop 该功能意味着不执行任何操作。 此命令通常用于if statements 。 |
| 5 | Pull 这用于从堆栈或默认流中提取输入。 |
| 6 | push 这用于将值推送到Rexx堆栈。 |
Rexx - Implementations
Rexx语言有很多不同的实现，正如我们在前面章节中已经看到的那样。 每个实现都有自己的功能。 让我们看看Rexx可用的各种实现。
OoRexx
这是Rexx的面向对象版本。 默认情况下，Rexx基本实现都基于过程。 但是使用ooRexx，您可以通过面向对象的Rexx方法提供更大的灵活性。 通过使用ooRexx，您可以通过创建可重用的类和对象来更好地重用。
以下程序是一个简单的Rexx程序示例，可以与ooRexx实现程序一起运行。
例子 (Example)
/* Main program */
say ‘hello’
要运行此程序，请运行以下命令。
rexx main.rexx
运行上面的命令时，您将获得以下输出。
hello
Netrexx
这适用于所有基于Java的开发人员，因为它为Rexx语言提供了基于Java的替代方案。 所以所有对象都基于Java对象模型。 这个框架的优点是，由于Java是一种广泛流行的语言，开发人员使用这个框架变得更容易。 因此，在此实现中，Rexx代码将转换为Java程序，然后可以在任何Java虚拟机上运行。
以下代码是NetRexx程序的示例。
创建一个名为main.nrx的文件，并将以下代码放在该文件中。
/* Main program */
say ‘hello’
要编译代码，请运行以下命令 -
NetRexxC main.nrx
然后，您将获得以下输出。 NetRexxC是将Rexx程序转换为其Java等价物的编译器。
java -cp ";;G:\NetRexx-3.04GA\lib\NetRexxF.jar;."
-Dnrx.compiler = ecj org.netrexx.process.NetRexxC main.nrx
NetRexx portable processor 3.04 GA build 4-20150630-1657
Copyright (c) RexxLA, 2011,2015. All rights reserved.
Parts Copyright (c) IBM Corporation, 1995,2008.
Program main.nrx
Compilation of 'main.nrx' successful
您现在可以使用以下java命令运行Java程序。
java main
运行上面的命令时，您将获得以下输出。
Hello
Brexx
这是Rexx的轻量级实现。 这是比标准Rexx实现者更轻的包。 但它仍然具有Rexx的全部功能。
以下代码是BRexx程序的示例。
/* Main program */
say ‘hello’
要运行该程序，请运行以下命令。
rexx32 main.rexx
运行上面的命令时，您将获得以下输出。
hello
Rexx - Netrexx
NetRexx是Rexx的java实现。 在NetRexx中，实现者用于将Rexx程序转换为java程序，然后可以在任何Java虚拟机上运行。
设置NetRexx
NetRexx的第一步是在本地计算机上进行设置。 要做到这一点，需要执行以下步骤 -
Step 1 - http://www.netrexx.org/downloads.nsp NetRexx下载站点 - http://www.netrexx.org/downloads.nsp
下载NetRexx.3.04.GA文件。
Step 2 - 确保已在系统上安装并运行java。 您可以使用java-version命令验证java是否正在运行。
输出的示例如下所示。
H:\>java -version
java version "1.7.0_79"
Java(TM) SE Runtime Environment (build 1.7.0_79-b15)
Java HotSpot(TM) Client VM (build 24.79-b02, mixed mode, sharing)
Step 3 - 解压缩Netrexx压缩文件的内容。 将文件从NetRexx3.04GA\lib文件夹复制到java安装/ lib/etc文件夹。
Step 4 - 将NetRexx-3.04GA\bin路径添加到系统上的路径变量。
运行第一个NetRexx程序
创建一个名为main.nrx的文件，并将以下代码放在该文件中。
/* Main program */
say ‘hello’
要编译代码，请运行以下命令。
NetRexxC main.nrx
然后，您将获得以下输出。 NetRexxC是将rexx程序转换为其Java等价物的编译器。
java -cp ";;G:\NetRexx-3.04GA\lib\NetRexxF.jar;."
-Dnrx.compiler = ecj org.netrexx.process.NetRexxC main.nrx
NetRexx portable processor 3.04 GA build 4-20150630-1657
Copyright (c) RexxLA, 2011,2015. All rights reserved.
Parts Copyright (c) IBM Corporation, 1995,2008.
Program main.nrx
Compilation of 'main.nrx' successful
您现在可以使用以下java命令运行Java程序。
java main
运行上面的命令时，您将获得以下输出。
Hello
现在让我们讨论一下special aspects of the Netrexx library一些special aspects of the Netrexx library 。
索引字符串
在NetRexx中，字符串可以成为数组的索引。 一个例子如下所示。
例子 (Example)
/* Main program */
value = 'unknown'
value['a'] = 'b'
c = 'a'
say value[c]
当我们运行上述程序时，我们将得到以下结果。
输出 (Output)
b
多个索引
在NetRexx中，您可以为阵列提供多个索引。 一个例子如下所示。
例子 (Example)
/* Main program */
value = 'null'
value['a', 'b'] = 1
say value['a', 'b']
当我们运行上述程序时，我们将得到以下结果。
输出 (Output)
1
| Sr.No. | 命令和描述 |
|---|---|
| 1 | 问命令 此命令用于从默认输入流中读取一行。 |
| 2 | 数字命令 此命令用于显示数字值的当前值。 |
| 3 | 表单命令 此命令用于显示表单值的当前值。 |
| 4 | 长度命令 此命令用于显示字符串值的长度。 |
| 5 | 版本命令 此命令用于返回当前使用的NetRexx版本。 |
| 6 | trace命令 此命令用于返回NetRexx使用的当前跟踪设置。 |
Rexx - Brexx
BRexx是Rexx的轻量级实现。 作为Rexx实现的一部分，它仍然具有许多功能。
设置BRexx
BRexx的第一步是在本地计算机上进行设置。 要做到这一点，需要执行以下步骤 -
Step 1 - 访问BRexx下载站点 - https://ftp.gwdg.de/pub/languages/rexx/brexx/html/rx.html
转到下载部分并下载产品。
Step 2 - 解压缩Brexx压缩文件的内容。
Step 3 - 将BRexx\bin路径添加到系统上的路径变量。
Step 4 - 创建一个名为RXLIB的新变量，并将其指向Brexx文件夹中的lib文件夹。
运行第一个BRexx计划
创建一个名为main.rexx的文件，并将以下代码放在该文件中。
/* Main program */
say ‘hello’
要运行该程序，请运行以下命令。
rexx32 main.rexx
运行上面的命令时，您将获得以下输出。
hello
现在让我们讨论一下BRexx库中可用的一些最常用的函数。
| Sr.No. | BRexx库中提供的功能 |
|---|---|
| 1 | acos命令 此命令用于获取数字的反余弦转换。 |
| 2 | cos命令 此命令用于获取数字的余弦转换。 |
| 3 | 罪司令部 此命令用于获取数字的正弦转换。 |
| 4 | asin命令 此命令用于获取数字的正弦转换。 |
| 5 | tan命令 此命令用于获取数字的切线转换。 |
| 6 | atan司令部 此命令用于获取数字的反正切转换。 |
| 7 | mkdir命令 此命令用于在当前工作目录中创建目录。 |
| 8 | rmdir命令 此命令用于删除当前工作目录中的目录。 |
| 9 | dir命令 此命令用于返回整个目录列表。 |
Rexx - Databases
Rexx能够使用下面列出的各种数据库。
- HSQLDB
- Oracle
- SQL Server
- MySQL
- MongoDB
单击以下链接后，可以找到Rexx数据库的所有信息 - https://rexxsql.sourceforge.net/
在我们的示例中，我们将使用MySQL DB作为示例。 因此，第一步是确保从Rexx SQL站点下载所需的驱动程序，以便Rexx程序可以相应地使用SQL。 因此，请遵循后续步骤以确保Rexx程序可以与MySQL数据库一起使用。
Step 1 - 从Rexx站点转到以下驱动程序下载页面 - https://sourceforge.net/projects/rexxsql/files/rexxsql/2.6/
Step 2 - 下载MYSQL驱动程序 - rxsql26B3_my_w32_ooRexx
Step 3 - 将内容解压缩到本地计算机。
Step 4 - 将解压缩文件夹的路径添加到计算机上的路径变量中。
对于所有后续示例，请确保以下指针到位 -
您已经创建了一个数据库TESTDB。
您已在TESTDB中创建了一个表EMPLOYEE。
此表包含FIRST_NAME，LAST_NAME，AGE，SEX和INCOME字段。
用户ID“testuser”和密码“test123”设置为访问TESTDB。
确保已下载mysql jar文件并将该文件添加到类路径中。
你已经完成了MySQL教程
数据库连接 (Database Connection)
要建立数据库连接，首先需要Rexxsql DLL，然后使用SQLConnect函数建立与数据库的连接。 下面给出了如何实现这一目的的语法和示例。
语法 (Syntax)
SQLConnect(cname,username,password,dbname)
参数 (Parameters)
cname - 这是给连接的名称。
username - 要连接到数据库的用户名。
password - 连接数据库的密码。
dbname - 要连接的数据库模式。
返回值 (Return Value)
值等于0表示数据库连接成功。
例子 (Example)
/* Main program */
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs'
Call SQLLoadFuncs
say SQLConnect(c1,' testuser ',' test123','testdb')
上述程序的输出如下所示。
0
创建数据库表
连接到数据库后的下一步是在数据库中创建表。 以下示例说明如何使用Rexx在数据库中创建表。 Rexx SQL中的所有命令都是使用SQLCommand函数执行的。
语法 (Syntax)
SQLConnect(sname,statement)
参数 (Parameters)
sname - 这是要赋予要执行的语句的名称。
statement - 这是需要对数据库执行的语句。
返回值 (Return Value)
值等于0表示命令成功。
例子 (Example)
/* Main program */
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs'
Call SQLLoadFuncs
if SQLConnect(c1,'testuser','test123','testdb') == 0 then say 'Connect Succedded'
if SQLCommand(u1,"use testdb") == 0 then say 'Changed database to testdb'
sqlstr = 'create table employee (first_name char(20) not null, last_name
char(20),age int, sex
char(1), income float)'
if SQLCommand(c2,sqlstr) == 0 then say 'Employee table created'
上述程序的输出如下所示。
Connect Succedded
Changed database to testdb
Employee table created
数据库表上的操作
以下类型的操作通常在数据库表上执行。
| Sr.No. | 操作和说明 |
|---|---|
| 1 | 插入操作 当您想要将记录创建到数据库表中时，它是必需的。 |
| 2 | 读操作 对任何数据库的READ操作意味着从数据库中获取一些有用的信息。 |
| 3 | 更新操作 任何数据库上的UPDATE操作都意味着更新一个或多个已在数据库中可用的记录。 |
| 4 | 删除操作 如果要从数据库中删除某些记录，则需要DELETE操作。 |
| 5 | 关闭连接 以下命令可用于关闭与数据库的连接。 |
执行交易
事务是一种确保数据一致性的机制。 交易具有以下四个属性 -
Atomicity - 事务完成或根本没有任何事情发生。
Consistency - 事务必须以一致状态启动，并使系统保持一致状态。
Isolation - 在当前事务之外不可见事务的中间结果。
Durability - 提交事务后，即使系统出现故障，影响也会持续存在。
这是一个如何实现事务的简单示例。
例子 (Example)
/* Main program */
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs'
Call SQLLoadFuncs
if SQLConnect(c1,'testuser','test123','testdb') == 0 then say 'Connect Succedded'
if SQLCommand(u1,"use testdb") == 0 then say 'Changed database to testdb'
sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20"
if SQLCommand(c2,sqlstr) == 0 then
if sqlcommit() == 0 then say committed
上述程序的输出如下所示。
Connect Succedded
Changed database to testdb
COMMITTED
提交操作 (Commit Operation)
提交操作告诉数据库继续执行操作并最终完成对数据库的所有更改。 在上面的示例中，这是通过以下命令实现的。
Sqlcommit()
回滚操作 (Rollback Operation)
如果您对一个或多个更改不满意并且想要完全还原这些更改，请使用回滚方法。 在上面的示例中，这是通过以下命令实现的。
SqlRollback()
Rexx - Handheld & Embedded Programming
手持设备已经走过了漫长的道路，Rexx有很多方法可以在这些设备上运行。 Rexx支持Pocket PC，Palm设备，PDA和其他智能手机设备。 Rexx在这些平台上工作的优势在于Rexx实际上是一个小重量编程系统，它只能在几千字节的范围内运行。 因此，在这些设备上运行Rexx程序变得更加容易。
手持设备上的Rexx可以在以下模式下运行 -
第一种模式是本机节点，它直接在操作系统上运行。 在此模式下运行的优势在于它更快，因为它直接从操作系统运行。
下一个模式位于手持设备顶部的DOS或仿真器程序之上。 此模式的优点是只要模拟器在该操作系统上运行，就可以在任何类型的操作系统上运行。
各种手持设备类别的Rexx口译员如下所示。
- Windows CE - Brexx
- Palm OS - Palm OS的Rexx
- Symbian操作系统 - 里贾纳
对于DOS模拟器，需要执行以下步骤 -
Step 1 - 首先是下载PocketDOS，这是一个流行的DOS模拟器。 它设计用于在许多操作系统上运行，并支持通用VGA屏幕以及串行和并行端口。
Step 2 - 下一步是将16位DOS的BRexx文件下载到Windows PC。
Step 3 - 最后一步是使用ActiveSync将Rexx程序同步到手持设备。
还有一些其他商业DOS产品可用。 XTM是属于此类别的产品。 该产品的特点如下 -
支持80186 CPU和指令集。
它有点像BIOS代码，以获得更好的性能。
它可以为Math协处理器8087版MPU提供仿真
它提供对串行端口的访问。
它支持多种语言，如英语，法语和德语。
Rexx - Performance
任何编程语言的关键方面之一是应用程序的性能。 需要注意特殊实践，以确保应用程序的性能不受影响。 让我们看一下步骤中描述的一些注意事项，以便更好地理解 -
Step 1 - 尝试减少指令数量 - 在Rexx中，每条指令都有一个开销。 因此，请尝试减少程序中的指令数量。 可以重新设计的指令示例如下所示。
可以使用parse语句而不是使用多个if else语句。 因此，在下面的程序中，不是对每个值都有if条件，而是获取word1，word2，word3和word4的值，请使用parse语句。
/* Main program */
parse value 'This is a Tutorial' with word1 word2 word3 word4
say "'"word1"'"
say "'"word2"'"
say "'"word3"'"
say "'"word4"'"
Step 2 - 尝试将多个语句组合成一个语句。 一个例子如下所示。
假设您有以下代码为-a a and b执行赋值并将其传递给名为proc的方法。
do i = 1 to 100
a = 0
b = 1
call proc a,b
end
您可以使用parse语句使用以下代码轻松替换上面给出的代码。
do i = 1 for 100
parse value 0 1 with
a,
b,
call proc a,b
end
Step 3 - 尝试尽可能用do..to loop替换do..to loop 。 当控制变量通过循环迭代时，通常建议这样做。
/* Main program */
do i = 1 to 10
say i
end
上述程序应由以下程序取代。
/* Main program */
do i = 1 for 10
say i
end
Step 4 - 如果可能，从do循环中删除for条件，如以下程序所示。 如果不需要控制变量，那么只需将结束值放在do循环中，如下所示。
/* Main program */
do 10
say hello
end
Step 5 - 在select clause ，无论你感觉到什么，最好的条件都需要在when clause放在第一位。 因此，在下面的示例中，如果我们知道1是最常见的选项，我们将when 1 clause作为select语句中的第一个子句。
/* Main program */
select
when 1 then say'1'
when 2 then say'2'
otherwise say '3'
end
Rexx - Best Programming Practices
每个程序员都希望他们的程序在质量和效率方面是最好的。 以下是编写Rexx程序时可以帮助实现这些目标的一些最佳编程实践或提示。
Hint 1
在向操作系统或命令提示符发出任何命令之前，请使用address命令。 这将帮助您事先在内存中获取地址空间，从而使您的程序更有效地运行。
地址命令的示例如下所示。
例子 (Example)
/* Main program */
address system dir
该命令的输出如下，但它可能因系统而异。
Volume in drive H is Apps
Volume Serial Number is 8E66-AC3D
Directory of H:\
06/30/2016 01:28 AM <DIR> Apps
07/05/2016 03:40 AM 463 main.class
07/07/2016 01:30 AM 46 main.nrx
07/07/2016 01:42 AM 38 main.rexx
3 File(s) 547 bytes
Dir(s) 313,085,173,760 bytes free
Hint 2
确保操作系统的所有命令均为大写，并尽可能使用引号。
其示例如下所示。
例子 (Example)
/* Main program */
options arexx_bifs
say chdir('\REXXML100')
say directory()
当我们运行上述程序时，我们将得到以下结果。
0
D:\rexxxml100
Hint 3
避免创建大注释块，如以下程序所示。
例子 (Example)
/******/
/* */
/* */
/* */
/******/
/* Main program */
address system dir
Hint 4
使用Parse语句指定默认值。 其示例如下所示。
例子 (Example)
parse value 0 1 with
a,
b
Hint 5
尽可能使用“Left（var1,2）”语句而不是“substr（var1,1,2）”语句。
Hint 6
尽可能使用“Right（var1,2）”语句而不是“substr（var1，length（var1），2）”语句。
Rexx - Graphical User Interface
为了使用Rexx中提供的图形用户界面，需要使用2个包，一个称为ActiveTcl ，另一个称为Rexxtk包。 除了这两个包之外，还可以设计普通表单，这些表单可以在表单上有按钮和其他控件。
环境设置 (Environment Setup)
首先要做的是环境设置。 让我们通过以下步骤来确定环境。
Step 1 - 从以下网站下载Activetcl软件包 - https://www.activestate.com/activetcl
Step 2 - 下一步是开始安装ActiveTCl。 单击屏幕上的“下一步”按钮继续。
Step 3 - 接受许可协议，然后单击“下一步”按钮。
Step 4 - 选择安装位置，然后单击下一步按钮。
Step 5 - 选择安装演示的位置，然后单击“下一步”按钮。
Step 6 - 单击“下一步”按钮继续安装。
Step 7 - 单击“完成”按钮完成安装。
Step 8 - 下一步是从以下链接下载Rexxtk软件 - https://sourceforge.net/projects/rexxtk/
Step 9 - 双击上一步中链接的安装程序文件以开始安装。 单击下一步按钮继续。
Step 10 - 在下一个屏幕中，单击是按钮以同意许可协议。
Step 11 - 在下一个屏幕中，选择安装位置，然后单击“下一步”按钮。
Step 12 - 选择Program文件夹位置，然后单击下一步按钮。
一旦安装完成，我们现在可以开始在Rexx中编程GUI。
基本课程
让我们看看如何使用Rexx以图形用户界面格式设计简单的基本程序。
例子 (Example)
/* Main program */
call RxFuncAdd 'TkLoadFuncs','rexxtk','TkLoadFuncs'
call TkLoadFuncs
do forever
interpret 'Call' TkWait()
end
call TkDropFuncs
exit 0
关于上述计划需要注意以下事项 -
使用RxFuncAdd命令加载Rexxtk库及其所有函数。
do forever循环将保持窗口打开并等待用户输入。
检测到用户输入后，程序将退出。
执行上述程序时，您将获得以下输出。
创建菜单
菜单是在TkMenu和TkAdd功能的帮助下创建的。 这些函数的语法如下。
语法 (Syntax)
TkMenu(widgetname,options,0)
参数 (Parameters)
Widgetname - 提供给菜单的名称。
选项可以是以下任何一种 -
selectcolor - 如果复选框或单选按钮用作菜单选项，则此选项指定选择任何菜单选项时要选择的颜色。
tearoff - 此选项用于将子菜单添加到主菜单。
title - 需要用于为窗口提供标题的字符串。
返回值 (Return Value)
创建菜单的句柄。
例子 (Example)
/* Main program */
call RxFuncAdd 'TkLoadFuncs','rexxtk','TkLoadFuncs'
call TkLoadFuncs
menubar = TkMenu('.m1')
filemenu = TkMenu('.m1.file','-tearoff', 0)
call TkAdd menubar, 'cascade', '-label', 'File', '-menu', filemenu
call TkAdd filemenu, 'command', '-label', 'Open...', '-rexx', 'getfile'
call TkConfig '.', '-menu', menubar
do forever
interpret 'Call' TkWait()
end
call TkDropFuncs
exit 0
关于上述计划需要注意以下事项 -
菜单栏是使用TkMenu函数创建的。 'tearoff'参数意味着我们需要创建将附加到主菜单的子菜单。
然后，我们使用TkAdd函数添加名为File和Open的2个菜单选项。
执行上述程序时，您将获得以下输出。
Rexx - Reginald
Reginald是另一个Rexx解释器，由Jeff Glantt开发，并对如何运行Rexx程序进行了一些定制。 在本节中，我们将了解如何获得Reginald并在其中运行一些Rexx程序。
环境设置 (Environment Setup)
第一步是下载Reginald文件的环境设置。 这可以通过以下网站链接完成 - http://www.manmrk.net/tutorials/rexx/Reginald/win32/rxusrw32.htm
下载完成并启动安装程序后，下一个屏幕将允许您选择安装位置。
单击“安装”按钮继续。
完成后，我们现在可以开始在Reginald解释器中运行一个示例程序。 创建一个简单的程序，如下所示。
/* Main program */
say 'Hello'
然后运行以下命令 -
RxLaunch.exe main.rexx
然后，您将获得以下输出。 该程序现在将在Reginald口译员中运行。
其他可用功能
除了正常的Rexx命令外，Reginald还有一些为Windows操作系统量身定制的特定命令。 DriveMap就是这样一个命令 -
DriveMap
此功能提供有关驱动器的信息。
Syntax -
Drivemap(,options)
Parameters -
Options - 这些是关键字列表，可用于获取有关本地计算机驱动器的各种信息。
Return Value
一个字符串值，其中包含有关驱动器的信息。
Example -
/* Main program */
say 'Drives on system : ' DriveMap(,'FIXED')
如果运行上述程序，您将获得以下输出。 此输出取决于系统。
List of disk drives : C:\ D:\
Rexx - Web Programming
Rexx也可以使用Web服务器。 最常见的是apache web服务器。 为了将Rexxw与Apache Web服务器一起使用，您需要首先从以下链接下载Rexx模块 - https://sourceforge.net/projects/modrexx/?source=typ_redirect
完成后，请确保将mod Rexx模块添加到类路径中。
需要将以下行添加并修改为Apache配置文件。
以下几行需要添加到相应的末尾 -
- httpd.conf LoadModule列表。
- LoadModule rexx_module modules/mod_rexx.dll
应在http.conf文件的末尾添加以下行。
AddType application/x-httpd-rexx-script .rex .rexx
AddType application/x-httpd-rexx-rsp .rsp
添加这些以获得REXX Server Page支持
RexxRspCompiler“c:/ Program Files/Apache Group/Apache2/bin/rspcomp.rex”
完成上述更改后，您需要关闭并重新启动Apache Web服务器。
上面的行还允许您使用基于Rexx的服务器页面，就像Java服务器页面一样。 您可以将Rexx代码直接添加到html页面。
一个例子如下所示 -
<p>The current date and time is
<?rexx
/* Inserting the rexx statement */
say date() time()
?>
</p>
运行基于Rexx的服务器页面时，会执行以下操作 -
首先创建一个临时文件。
然后Rexx Server编译器将文件编译为Rexx程序并将其放入临时文件中。
下一步是实际运行Rexx程序。
最后，删除临时文件。
