REXX

标签：一节 主程序 示例 程序 say REXX Rexx

Rexx - 基本语法

为了理解Rexx的基本语法，让我们首先看一个简单的Hello World程序。
示例
/* 主程序 */ say "Hello World"
可见 hello world 程序是多么简单。 这是一个简单的脚本行，用于执行 Hello World 程序。
上述程序需要注意以下几点−
say 命令用于将值输出到控制台。
/* */ 用于 Rexx 中的注释。
上述程序的输出将是 −
Hello World 声明的一般形式
在 Rexx 中，让我们看看程序的一般形式。 看一下下面的例子。
/* 主程序 */

say add(5,6)
exit
add:
parse arg a,b
return a + b

上述程序的输出将是 −11

让我们回顾一下我们从上面的程序中了解到的内容 −
Add 是一个定义为将 2 个数字相加的函数。
在主程序中，5和6的值被用作add函数的参数。
exit 关键字用于退出主程序。 这是用来区分主程序和add函数的。
add 函数用":"符号区分。
parse 语句用于解析传入的参数。
最后，return 语句用于返回数值的总和。
子例程和函数
在 Rexx 中，代码通常分为子例程和函数。 子例程和函数用于将代码区分为不同的逻辑单元。 子例程和函数之间的主要区别在于函数返回值，而子例程则不返回值。
下面是用于加法实现的子例程和函数之间的关键区别示例 −
函数实现
/* 主程序 */ say add(5,6)
exit
add:
parse arg a,b
return a + b 子程序实现
/* 主程序 */ add(5,6)
exit
add:
parse arg a,b
say a + b 两个程序的输出均为值 11。
执行命令
Rexx 可用作各种基于命令的系统的控制语言。 Rexx在这些系统中执行命令的方式如下。 当Rexx遇到既不是指令也不是赋值的程序行时，它会将该行视为要计算的字符串表达式，然后传递到环境。
示例如下 −
示例
/* 主程序 */

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 关键字的示例有 DO 指令中的 WHILE 以及 IF 或 WHEN 子句 后面的 THEN（在本例中充当子句终止符）。
除了这些情况之外，仅检查子句中第一个标记且后面不跟"="或":"的简单符号，以确定它们是否是指令关键字。 您可以在子句中的其他位置自由使用这些符号，而无需将它们视为关键字。
Rexx 中的注释
注释用于记录您的代码。 单行注释通过在行中的任意位置使用 /* */ 来标识。
示例如下 −
/* 主程序 */ /* 调用add函数 */ add(5,6) /* 退出主程序 */ exit add: /* 解析传递给add函数的参数 */ parse arg a,b /* 显示添加的数值 */ say a + b 注释也可以写在代码行之间，如以下程序所示 −
/* 主程序 */ /* 调用add函数 */ add(5,6)
/* 退出主程序 */ exit
add:
parse /* 解析传递给 add 函数的参数 */
arg a,b
/* 显示添加的数值 */ say a + b 上述程序的输出将是 −
11 您还可以在注释中包含多行，如以下程序所示 −
/* 主程序 下面的程序用于数字相加 调用add函数*/ add(5,6)
exit
add:
parse arg a,b
say a + b 上述程序的输出将是 −
11 

Rexx - 数据类型

任何编程语言中，都需要使用各种变量来存储各种类型的信息。 变量只不过是用于存储值的保留内存位置。 这意味着当您创建变量时，您会在内存中保留一些空间来存储与该变量关联的值。
您可能想要存储各种数据类型的信息，例如字符串、字符、宽字符、整数、浮点、布尔值等。操作系统根据变量的数据类型分配内存并决定保留内存中可以存储什么内容。
内置数据类型
Rexx 提供多种内置数据类型。 以下是 Rexx 中定义的数据类型列表。
整数 − 不包含小数点或指数标识符的数字字符串。 第一个字符可以是加号 (+) 或减号 (-)。 表示的数字必须介于 -2147483648 和 2147483647 之间（包含 -2147483648 和 2147483647）。
大整数 − 不包含小数点或指数标识符的数字字符串。 第一个字符可以是加号 (+) 或减号 (-)。 表示的数字必须介于 -9223372036854775808 和 2147483648（含）之间，或者介于 2147483648 和 9223372036854775807 之间。
十进制 − 它将来自以下格式之一 −
包含小数点但不包含指数标识符的数字字符串。 p 表示精度，s 表示字符串所表示的十进制数的小数位数。 第一个字符可以是加号 (+) 或减号 (-)。
不包含小数点或指数标识符的数字字符串。 第一个字符可以是加号 (+) 或减号 (-)。 表示的数字小于-9223372036854775808或大于9223372036854775807。
Float − 表示科学记数法中的数字的字符串。 该字符串由一系列数字后跟指数标识符（E 或 e 后跟可选的加号 (+) 或减号 (-) 以及一系列数字）组成。 该字符串可以以加号 (+) 或减号 (-) 开头。
String − 一个普通的字符串。
以下是如何使用每种数据类型的一些示例。 同样，每种数据类型将在后续章节中详细讨论。 这只是为了让您加快了解上述数据类型的简要描述。
整数
以下程序显示了如何使用数字数据类型的示例。 该程序显示 2 个整数的加法。
示例
/* 主程序 下面的程序用于数字相加 调用add函数*/ add(5,6)
exit
add:
parse arg a,b
say a + b
上述程序的输出将是 −
11 大整数
以下程序显示了 Rexx 处理大整数的能力。 该程序展示了如何将 2 个大整数相加。
示例
/* 主程序 下面的程序用于数字相加 调用add函数*/ add(500000000000,6000000000000000000000)
exit
add:
parse arg a,b
say a + b 上述程序的输出将是 −
6.00000000E+21 十进制
以下程序显示了 Rexx 处理十进制数的能力。 该程序展示了如何添加 2 个小数。
示例
/* 主程序 下面的程序用于数字相加 调用add函数*/ add(5.5,6.6)
exit
add:
parse arg a,b
say a + b
上述程序的输出将是 −
12.1
浮点数
以下示例展示了数字如何作为浮点数工作。
示例
/* 主程序 下面的程序用于数字相加 调用add函数*/ add(12E2,14E4)
exit
add:
parse arg a,b
say a + b 上述程序的输出将是 −
141200 字符串
以下程序显示了如何使用元组数据类型的示例。
这里我们定义一个元组P，它有3个项。 tuple_size 是 Rexx 中定义的内置函数，可用于确定元组的大小。
示例
/* 主程序 */ display("hello")
exit
display:
parse arg a
say a 上述程序的输出将是 −
hello ❮ 上一节
下一节 ❯

Rexx - 变量

在 Rexx 中，所有变量都与"="语句绑定。 变量名有时称为符号。 它们可能由字母、数字和字符（例如 '. ! ? _'）组成。 您创建的变量名称不得以数字或句点开头。 简单变量名不包含句点。 包含句点的变量名称称为复合变量，代表数组或表。
以下是Rexx中变量的基本类型，在上一章中也有解释 −
整数 − 这用于表示整数或浮点数。 例如 10。
大整数 − 这表示一个大整数值。
十进制 − 小数值是包含小数点但不包含指数标识符的数字字符串。
浮点数 − 浮点值是用科学记数法表示数字的字符串。
字符串 − 一系列字符定义 Rexx 中的字符串。
不同类型的变量函数
在本节中，我们将讨论变量可以执行的各种功能。
变量声明
定义变量的一般语法如下所示 −
var-name = var-value
其中
var-name − 这是变量的名称。
var-value − 这是绑定到变量的值。
以下程序是变量声明的示例 −
示例
/* 主程序 */ X = 40
Y = 50
Result = X + Y
say Result 在上面的示例中，我们有 2 个变量，一个是 X，它绑定到值 40，下一个是 Y，它绑定到值 40。 绑定到值50。 另一个名为 Result 的变量绑定到 X 和 Y 的加法。
上述程序的输出如下 −
90 命名变量
变量名称有时称为符号。 它们可以由字母、数字和字符（例如 '. ! ? _' ）组成。 您创建的变量名称不得以数字或句点开头。
如果变量尚未赋值，则称为未初始化。 未初始化变量的值是变量本身的大写字母名称。
未赋值变量的示例如下 −
示例
/* 主程序 */ unassignedvalue
say unassignedvalue
如果运行上面的程序，你将得到以下输出 −
UNASSIGNEDVALUE sh: UNASSIGNEDVALUE: command not found 2 *-* unassignedvalue
>>> "UNASSIGNEDVALUE" +++ "RC(127)" 变量可以多次赋值。 下面的程序展示了如何对X的值进行多次赋值。
示例
/* 主程序 */ X = 40
X = 50
say X
上述程序的输出如下 −
50 打印变量
使用say命令打印变量的值。 以下是打印多个变量的示例。
示例
/* 主程序 */ 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 - 运算符
❮ 上一节
下一节 ❯
Rexx - 运算符
运算符是告诉编译器执行特定数学或逻辑操作的符号。
Rexx有多种类型的运算符，详细解释如下 −
算术运算符
关系运算符
逻辑运算符
按位运算符
算术运算符
Rexx 语言与任何语言一样支持普通算术运算符。 以下是 Rexx 中可用的算术运算符。
显示示例
运算符
描述
示例
+
两个操作数相加
1 + 2 将给出 3
−
从第一个操作数中减去第二个操作数
1 - 2 将给出 -1
∗
两个操作数相乘
2 ∗ 2 将给出 4
/
分子除以分母
2 / 2 将给出 1
//
第一个数字除以第二个数字的余数
3 // 2 将给出 1
%
将执行除法并返回整数。
3 % 2 将给出 1
关系运算符
关系运算符允许对对象进行比较。 以下是 Rexx 中可用的关系运算符。 在Rexx中，真值用1表示，假值用0表示。
显示示例
运算符
描述
示例
==
测试两个对象之间的相等性
2 = 2 将给出 1
<
检查左侧对象是否小于右侧操作数。
2 < 3 将给出 1
=<
检查左侧对象是否小于或等于右侧操作数。
2 =< 3 将给出 1
>
检查左侧对象是否大于右侧操作数。
3 > 2 将给出 1
>=
检查左侧对象是否大于或等于右侧操作数。
3 > 2 将给出 1
逻辑运算符
逻辑运算符用于计算布尔表达式。 以下是 Rexx 中可用的逻辑运算符。
显示示例
运算符
描述
示例
&
这是逻辑"与"运算符
1 or 1 将给出 1
|
这是逻辑"或"运算符
1 or 0 将给出 1
\
这是逻辑"非"运算符
\0 将给出 1
&&
这是逻辑"异或"运算符
1 && 0 将给出 1
按位运算符
Groovy 提供了四种按位运算符。 以下是 Groovy 中可用的按位运算符。
显示示例
序号
运算符 & 描述
1
bitand
这是按位"与"运算符
2
bitor
这是按位"或"运算符
3
bitxor
这是按位"异或"或异或运算符
运算符优先级
下表按优先级降序显示了 Rexx 运算符的运算符优先级。
运算符
优先级
前缀运算符
&plus; - \
加法和减法
&plus; -
比较运算符
= == > < >= <=
逻辑与
&
逻辑或
|
异或
&&
❮ 上一节
下一节 ❯
Rexx - 数组
❮ 上一节
下一节 ❯

Rexx - 数组

任何编程语言中的数组都允许您对相同类型的值列表进行分组。 数组的用途在于它允许您构建相似类型值的列表，这些值可排序、可搜索并且可以轻松操作。 Rexx 还允许定义数组。 这些数组可以是一维或多维的。
Rexx 数组可能比较稀疏。 也就是说，并非每个数组位置都必须有一个值，甚至不需要初始化。 在包含数据元素的数组位置之间可以有空的数组位置或槽。 或者数组可以是密集的，其中连续的数组槽都包含数据元素。
在许多编程语言中，您必须关心表中第一个条目的下标是什么。 第一个数字下标是0还是1? 在 Rexx 中，第一个下标是您使用的任何内容！ 因此，根据您的喜好将第一个数组元素输入位置 0 或 1。
array_name.0 = ‘first element’ or
array_name.1 = ‘first element’ 让我们看看可用于数组的不同操作。
创建数组
数组是使用与 Rexx 中的变量相同的命名约定创建的。
创建数组的一般语法如下 −
Arrayname.index = value
其中
Arrayname − 这是提供给数组的名称。
Index − 这是数组中引用特定元素的索引位置。
Value − 这是分配给数组中索引元素的值。
数组声明的示例如下 −
示例
/* 主程序 */ list.1 = 0
list.2 = 0
list.3 = 0 上述程序需要注意以下几点 −
数组的名称以列表形式给出
数组中有 3 个元素，初始化值为 0。
为数组元素赋值
可以按照与初始化数组元素相同的方式将值重新分配给数组元素。
以下程序是可分配给现有数组的各种索引值的值的示例。
/* 主程序 */ list.1 = 0
list.2 = 0
list.3 = 0
/* 为数组分配新值 */
list.1 = 10
list.3 = 30
显示数组的值
数组的值可以通过引用数组元素的索引位置来显示。 以下示例显示如何访问数组的各个元素。
示例
/* 主程序 */ list.1 = 0
list.2 = 0
list.3 = 0
/* 为数组分配新值*/
list.1 = 10
list.3 = 30
say list.1
say list.2
say list.3
上述程序的输出如下 −
10 0 30 复制数组
一个数组的所有元素都可以复制到另一个数组中。 其一般语法如下 −
Newarray. = sourcearray.
其中
Newarray − 这是需要将元素复制到其中的新数组。
Sourcearray − 这是需要从中复制元素的源数组。
以下程序显示了如何执行数组复制操作的示例 −
示例
/* 主程序 */ list.1 = 0
list.2 = 0
list.3 = 0
/* 为数组分配新值 */
list.1 = 10
list.3 = 30
listnew. = list.
say listnew.1
say listnew.2
say listnew.3
上述程序的输出将是 −
10 0 30 迭代数组元素
还可以使用 Rexx 中提供的迭代语句来迭代数组的元素。 有关如何完成此操作的示例如下 −
示例
/* 主程序 */ 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 循环用于迭代数组元素。
变量number_of_elements用于存储数组中元素的数量。
变量 j 用于迭代数组的每个元素。
上述程序的输出将是 −
10 20 30 二维数组
还提到我们可以在 Rexx 中构造多维数组。 让我们看一个如何实现二维数组的示例。
示例
/* 主程序 */ 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 - 循环

❮ 上一节
下一节 ❯
Rexx - 循环
到目前为止，我们已经看到了按顺序依次执行的语句。 此外，Rexx 中还提供了语句来改变程序逻辑中的控制流。 然后将它们分类为我们将详细研究的控制语句流。
循环语句允许我们多次执行一条语句或一组语句。 下图是大多数编程语言中循环语句的一般形式。
让我们讨论一下 Rexx 支持的各种循环。
序号
循环类型 & 描述
1
do 循环
do 循环用于执行多个语句一定次数。 该语句需要执行的次数由传递给 do 循环的值决定。
2
do-while 循环
do-while 语句用于模拟其他编程语言中存在的简单 while 循环。
3
do-until 循环
do-until 循环是 do while 循环的轻微变体。 该循环的不同之处在于，当评估的条件为假时，循环就会退出。
控制重复
do 循环可以满足执行语句的受控重复。
语法
此类语句的一般语法如下。
do index = start [to limit] [by increment] [for count]
statement #1
statement #2
end
该语句的不同之处在于有一个索引，用于控制循环执行的次数。 其次，有一些参数规定索引应该从哪个值开始，应该在哪里结束以及增量值是多少。
流程图
让我们看看这个循环的流程图 −
从上图中可以清楚地看到循环是根据索引值执行的，以及索引值是如何递增的。
以下程序是受控重复语句的示例。
示例
/* 主程序 */

#do

do i = 0 to 5 by 2
say "hello"
end

do forever
   say "Let's play a game! Type 'Heads', 'Tails'",
      "or 'Quit' and press ENTER."
   pull answer

   select
      when answer = "HEADS"
         then say "Sorry! It was TAILS. Hard luck!"
      when answer = "TAILS"
          then say "Sorry! It was HEADS. Hard luck!"
      when answer = "QUIT"
         then exit
      otherwise
         say "That's not a valid answer. Try again!"
   end
   say
end

在上面的程序中，count i的值首先被设置为0。 然后以 2 为单位递增，直到该值不大于 5。
上述代码的输出将是 −
hello
hello
hello
❮ 上一节
下一节 ❯

Rexx - 决策

❮ 上一节
下一节 ❯
Rexx - 决策语句
决策结构要求程序员指定一个或多个由程序评估或测试的条件。
下图显示了大多数编程语言中典型决策结构的一般形式。
如果确定条件为true，则有一个或多个语句要执行，并且可选地，如果确定条件为 false，则要执行其他语句。
让我们看看 Rexx 中提供的各种决策语句。
序号
语句 & 描述
1
if 语句
第一个决策语句是if语句。 if 语句由一个布尔表达式后跟一个或多个语句组成。
2
if-else 语句
下一个决策语句是 if-else 语句。 if 语句后面可以跟一个可选的 else 语句，该语句在布尔表达式为 false 时执行。
嵌套 If 语句
有时需要将多个 if 语句相互嵌入，这在其他编程语言中是可能的。 在 Rexx 中这也是可能的。
语法
if (condition1) then
do
#statement1
end
else
if (condition2) then
do
#statement2
end 流程图
嵌套if语句的流程图如下 −
让我们以嵌套 if 语句为例 −
示例
/* 主程序 */

#if

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
select 语句
Rexx 提供了 select 语句，可用于根据 select 语句的输出执行表达式。
语法
该语句的一般形式是 −
select
when (condition#1) then
statement#1
when (condition#2) then
statement#2
otherwise
defaultstatement
end
该语句的一般工作原理如下 −
select 语句有一系列when 语句来评估不同的条件。
每个when子句都有一个不同的条件，需要对其进行评估并执行后续语句。
otherwise 语句用于在前面的条件评估为 true 时运行任何默认语句。
流程图
select语句的流程图如下
以下程序是 Rexx 中 case 语句的示例。
示例
/* 主程序 */

#select

 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 - 数字

❮ 上一节
下一节 ❯
Rexx - 数字
当涉及到数字时，Rexx 具有以下数据类型。
整数 − 不包含小数点或指数标识符的数字字符串。 第一个字符可以是加号 (+) 或减号 (-)。 表示的数字必须介于 -2147483648 和 2147483647 之间（包含 -2147483648 和 2147483647）。
大整数 − 不包含小数点或指数标识符的数字字符串。 第一个字符可以是加号 (+) 或减号 (-)。 表示的数字必须介于 -9223372036854775808 和 2147483648（含）之间，或者介于 2147483648 和 9223372036854775807 之间。
十进制 − 以下格式之一 −
包含小数点但不包含指数标识符的数字字符串，其中 p 表示精度，s 表示该字符串表示的十进制数的小数位。 第一个字符可以是加号 (+) 或减号 (-)。
不包含小数点或指数标识符的数字字符串。 第一个字符可以是加号 (+) 或减号 (-)。 表示的数字小于-9223372036854775808或大于9223372036854775807。
浮点数 − 表示科学记数法中的数字的字符串。 该字符串由一系列数字后跟指数标识符（E 或 e 后跟可选的加号 (+) 或减号 (-) 以及一系列数字）组成。 该字符串可以以加号 (+) 或减号 (-) 开头。
现在让我们看看可用于数字的不同方法。
序号
适用于 Numbers 的方法
1ABS
此方法返回输入数字的绝对值。
2MAX
此方法返回数字列表中的最大值。
3MIN
此方法返回数字列表中的最小值。
4RANDOM
此方法返回一个随机生成的数字。
5SIGN
如果数字大于 0，则返回 1；如果数字为 0，则返回 0；如果数字小于 0，则返回 -1。
6TRUNC
此方法截断数字。
❮ 上一节
下一节 ❯

Rexx - 字符串

Rexx - 字符串 (w3ccoo.com)
Rexx 中的字符串由字符序列表示。 以下程序是字符串的示例 −
/* 主程序 */ a = "This is a string"
say a 上述程序的输出如下 −
This is a string
让我们讨论一下 Rexx 中可用于字符串的一些方法。
序号
Rexx 中可用于字符串的方法

1#left

此方法从字符串左侧返回一定数量的字符。

/* 主程序 */
a = "Hello World" 
say left(a,5) 

=>Hello 

2#right

此方法从字符串右侧返回一定数量的字符。

3#length

此方法返回字符串中的字符数。

4#reverse

此方法以相反格式返回字符。

/* 主程序 */
a = "Hello World" 
say reverse(a) 
=>dlroW olleH

5#compare

此方法比较 2 个字符串。 如果"string1"和"string2"相同，则返回"0"。 否则，它返回第一个不匹配的字符的位置。

6#copies

此方法将字符串复制n次。

7#substr

此方法从特定字符串中获取子字符串。

8#pos

此方法返回一个字符串在另一个字符串中的位置。

/* 主程序 */
a = "Hello World" 
say pos("Hello",a)  
=>1

9#delstr

此方法从字符串中删除子字符串。
❮ 上一节
下一节 ❯

Rexx - 函数

❮ 上一节
下一节 ❯
Rexx - 函数
Rexx 中的代码通常分为函数和子例程。 使用函数有助于将代码分成更多的逻辑单元。 让我们详细看看这些函数。
定义函数
函数声明的语法如下 −
FunctionName:
PARSE ARG arguement1, arguement2… arguementN
Return value
其中,
FunctionName − 这是分配给该函数的名称。
PARSE ARG − 这些是 Rexx 中的关键字，用于提及参数正在传递给函数。
arguement1, arguement2… arguementN − 这些是传递给函数的参数。
返回值 − 这是函数返回的值。
以下程序是如何在 Rexx 中使用函数的简单示例。
/* 主程序 */

say add(5,6)
exit
add:
PARSE ARG a,b
return a + b

 

上述程序需要注意以下几点 −
我们正在定义一个名为 add 的函数，它接受 2 个参数 a 和 b。
该函数使用 return 语句返回 a 和 b 的和。
exit 语句必须用于表示主程序的结束。
上述程序的输出如下 −
11 使用参数
在 Rexx 中，有一些特定的函数可以与参数一起使用。 让我们看几个这样的论点。

#arg

此方法用于返回为函数定义的参数数量。
语法 −
arg()
参数 − None
返回值 − 此方法返回为函数定义的参数数量。
示例 −
/* 主程序 */ say add(5,6)
exit
add:
PARSE ARG a,b
say arg()
return a + b
输出 − 当我们运行上面的程序时，我们将得到以下结果。
2
11
arg(index)
该方法用于返回特定位置处参数的值。
语法 −
arg(index) 参数 −
Index − 要返回的参数的索引位置。
返回值 − 此方法返回特定位置处参数的值。
示例 −
/* 主程序 */ 

say add(5,6)
exit
add:
PARSE ARG a,b
say arg(1)
return a + b

输出 − 当我们运行上面的程序时，我们将得到以下结果。
5
11
递归函数
递归函数或例程是调用自身的函数或例程。 任何递归函数都可以以传统的非递归方式（或迭代）进行编码，但有时递归提供了更好的问题解决方案。 并非所有编程语言都支持递归； 雷克斯做到了。
让我们看一下在 Rexx 中使用递归函数的著名阶乘程序的示例。
/* 主程序 */ do n = 1 to 5
say 'The factorial of' n 'is:' factorial( n )
end
return
/* 求阶乘的函数 */

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 - 堆栈

❮ 上一节
下一节 ❯
Rexx - 堆栈
堆栈有时也被称为外部数据队列，但我们按照通常的用法，将其称为栈。 它是逻辑上位于 Rexx 外部的一块内存。 像push和queue这样的指令将数据放入堆栈中，像pull和parse这样的指令从堆栈中提取数据。 排队的内置函数报告堆栈中有多少项。
让我们看一个堆栈的例子。

push

/* 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 - 文件 I/O

❮ 上一节
下一节 ❯
Rexx - 文件 I/O
Rexx 在使用 I/O 时提供了多种方法。 Rexx 提供了更简单的类来为文件提供以下功能。
读取文件
写入文件
查看文件是文件还是目录
Rexx 中用于文件 I/O 的可用函数基于行输入和字符输入，我们将详细研究这两种输入的可用函数。
让我们探索一下 Rexx 提供的一些文件操作。 出于这些示例的目的，我们假设有一个名为 NewFile.txt 的文件，其中包含以下文本行 −
示例1
示例2
示例3
该文件将用于以下示例中的读写操作。 这里我们将讨论如何以不同的方式读取文件的内容。
一次读取一行文件的内容
对文件的一般操作是通过使用 Rexx 库本身提供的方法来执行的。 文件的读取是 Rexx 中所有操作中最简单的。
让我们看看用于完成此操作的函数。
linein
此方法返回文本文件中的一行。 文本文件是作为函数输入参数提供的文件名。
语法 −
linein(filename)
参数 −
filename − 这是需要读取该行的文件的名称。
返回值 − 此方法一次返回文件的一行。
示例 −
/* 主程序 */ line_str = linein(Example.txt)
say line_str 上面的代码非常简单，因为 Example.txt 文件名被提供给 linein 函数。 然后，该函数读取一行文本并将结果提供给变量 line_str。
输出 − 当我们运行上面的程序时，我们将得到以下结果。
Example1 一次性读取文件内容
在Rexx中，通过while语句可以实现读取文件的全部内容。 while 语句将逐行读取每一行，直到到达文件末尾。
下面显示了如何实现这一目标的示例。
/* 主程序 */ do while lines(Example.txt) > 0
line_str = linein(Example.txt)
say line_str
end
在上面的程序中，需要注意以下几点 −
lines 函数读取Example.txt 文件。
while 函数用于检查Example.txt 文件中是否存在其他行。
对于从文件中读取的每一行，line_str 变量保存当前行的值。 然后将其作为输出发送到控制台。
输出 − 当我们运行上面的程序时，我们将得到以下结果。
Example1
Example2
Example3
将内容写入文件
就像读取文件一样，Rexx 也具有写入文件的能力。 让我们看看用于完成此操作的函数。
lineout
此方法将一行写入文件。 需要写入该行的文件作为 lineout 语句的参数提供。
语法 −
lineout(filename)
参数 −
filename − 这是需要写入该行的文件的名称。
返回值 − 此方法返回 lineout 函数的状态。 如果该行写入成功，则返回值为 0，否则返回值 1。
示例 −
/* 主程序 */ out = lineout(Example.txt,"Example4")
输出 − 每当运行上述代码时，"Example4"行都会被写入文件 Example.txt。
❮ 上一节
下一节 ❯
Rexx - 文件函数
❮ 上一节
下一节 ❯
Rexx - 文件函数
在本章中，我们将讨论可用于文件的一些其他功能。
序号
文件函数
1#Lines
此函数返回值 1 或输入流中剩余要读取的行数。 文件名作为函数的输入给出。
2#stream

LINES.=""
DSNR1=PDS_NAME'('MBR')'
"ALLOC DS('"DSNR1"'FILE(FILER1) SHR"
"EXECIO * DISKR FILER1( STEM LINES. FINIS"
"FREE FILE(MEM)"
#OPEN

"EXECIO 0 DISKR DSNR1( OPEN)" "EXECIO * DISKR DSNR1( STEM LISTR1." "EXECIO * DISKR DSNR1( FINIS)" DISKW LINES.="A" DSN=PDS_NAME'('MBR')' "ALLOC DS('"DOUT"'FILE(DF) SHR" "EXECIO * DISKW DF( STEM LINES. FINIS" "FREE FILE(MEM)" "ALLOC DA('IBMUSER.JCL(MEMBER)') FILE(DSNW) SHR REUSE" "EXECIO 0 DISKW DSNW( OPEN )" "EXECIO * DISKW DSNW( STEM LISTW. )" "EXECIO * DISKW DSNW( FINIS )"

 

该函数用于检查文件的状态。 有时需要在使用文件之前检查文件的状态。 如果文件已损坏或不可用，则无法对该文件执行进一步的操作。 因此，首先检查文件的状态更有意义。
3
charin
该函数用于一次从文件中读取一个字符。 有时程序需要按字符读取文件，因此可以使用此函数来实现此目的。
4
chars
此函数返回 1 或文件本身中剩余要读取的字符数。 文件名作为函数的参数提及。
5
charout
该函数用于一次向文件写入一个字符。 文件名作为函数的参数输入。
❮ 上一节
下一节 ❯

Rexx - 子例程

❮ 上一节
下一节 ❯
Rexx - 子例程
在任何编程语言中，整个程序都被分成逻辑模块。 这使得编写易于维护的代码变得更加容易。 这是任何编程语言的基本要求。
在Rexx中，可以使用子例程和函数来编写模块。 让我们详细看看子例程。
定义子例程
函数声明的语法如下 −
FunctionName:
Statement#1
Statement#2
….
Statement#N 其中，
FunctionName − 这是分配给子例程的名称。
Statement#1 .. Statement#N − 这些是构成子例程的语句列表。
下面的程序是一个简单的示例，展示了子例程的使用。
/* 主程序 */ call add
exit
add:
a = 5
b = 10
c = a + b
say c
上述程序需要注意以下几点 −
我们正在定义一个名为add的子例程。
子例程执行简单的添加功能。
exit 语句必须用于表示主程序的结束。
上述程序的输出如下 −
15 使用参数
也可以在 Rexx 中使用参数。 以下示例展示了如何实现这一点。
/* 主程序 */ 

call add 1,2
exit
add:
PARSE ARG a,b
c = a + b

　　

say c 上述程序需要注意以下几点 −
我们正在定义一个名为 add 的子例程，它采用 2 个参数。
在子例程中，使用 PARSE 和 ARG 关键字解析 2 个参数。
上述程序的输出如下 −
3 不同的参数方法
让我们看看其他一些可用于参数的方法。
arg
此方法用于返回为子例程定义的参数数量。
语法 −
arg()
参数 − None
返回值 − 此方法返回为子例程定义的参数数量。
示例 −
/* 主程序 */ call add 1,2
exit
add:
PARSE ARG a,b
say arg()
c = a + b
say c
当我们运行上面的程序时，我们将得到以下结果。
2
3
arg(index)
该方法用于返回特定位置处参数的值。
语法 −
arg(index) 参数
Index − 要返回的参数的索引位置。
返回值 − 此方法返回特定位置处参数的值。
示例 −
/* 主程序 */ call add 1,2
exit
add:
PARSE ARG a,b
say arg(1)
c = a + b
say c
当我们运行上面的程序时，我们将得到以下结果。
1
3
❮ 上一节
下一节 ❯
Rexx - 内置函数
❮ 上一节
下一节 ❯

Rexx - 内置函数

每种编程语言都有一些内置函数可以帮助程序员完成一些日常任务。 Rexx 还具有许多内置功能。
让我们看看 Rexx 中提供的所有这些函数。
序号
Rexx 提供的函数
1
ADDRESS
此方法返回当前运行 Rexx 命令的环境名称。
2
BEEP
此方法在系统中以特定频率和持续时间产生声音。
3
DataType
如果输入是有效数字，此方法将返回"NUM"值，否则将返回"CHAR"值。 您还可以指定是否要将输入值与 NUM 或 CHAR 值进行比较。 在每种情况下，返回的值将是 1 或 0，具体取决于结果。

4#DATE

此方法按以下格式返回本地日期。

Options − 这是格式化日期值的选项。 它们可以是以下给出的选项中的任何一个。 −

• Base − 此参数返回自 1 月 1 日 0001 起的完整天数

• Days − 该参数返回当前年份已经过去的天数

• European − 此参数返回格式为 dd/mm/yy 的日期

• Full − 此参数返回自 0001 年 1 月 1 日起的微秒数

• Month − 该参数返回当前月份的完整英文名称。 一个例子是，九月

• Normal − 此参数以正常格式返回日期，如下所示。 这是默认参数选项，即 dd mon yyyy

• Ordered − 此参数返回格式为 - yy/mm/dd 的日期

• Standard − 此参数返回格式为 - yyyymmdd 的日期

• Weekday − 此参数返回星期几的英文名称。 例如，星期三

DATE(,'200010709','S') =>'9 JULY 2001'
DATE('B','25 SEP 2001') 
73023
DATE('E') 
2023/8/19
DATE('J') 
23345YYDDD
DATE('M') 
MM
DATE('S') 
20230819
DATE('U','25 SEP 2001') 
08/19/2023

　　

5#DIGITS

此方法返回当前系统中定义的数字数字的当前设置。
6
ERRORTEXT
此方法返回与错误号"errorno"关联的 Rexx 错误消息。 请注意，错误号必须是 0 到 99 之间的值。这在您的程序返回错误代码并且您想知道错误代码的含义的情况下非常有用。
7
FORM
此方法返回"NUMERIC FORM"的当前设置，该设置用于在系统上进行数学计算。
8
TIME
此方法返回 24 小时制格式的本地时间，如以下程序所示。
9
USERID
此方法返回登录系统的当前用户 ID。
10
XRANGE
此方法返回由开始和结束字符指定的范围内的字符。
11
X2D
此方法返回十六进制字符串值的十进制转换。
12
X2C
此方法返回十六进制字符串值的字符转换。
❮ 上一节
下一节 ❯
Rexx - 系统命令
❮ 上一节
下一节 ❯
Rexx - 系统命令
Rexx 的最大优势之一是能够创建可重复使用的脚本。 在当今的组织中，拥有可重用的脚本通常可以节省执行常见重复任务的时间，从而带来巨大的附加值。
例如，IT 组织中的技术团队可能需要拥有执行常见日常任务的脚本。 这些任务可以包括与操作系统交互。 然后可以对这些脚本进行编程来处理错误的返回代码或错误。
Rexx 提供了许多可用于执行此类重复任务的系统命令。 让我们看一下 Rexx 中可用的一些系统命令。
dir
这是 Windows 中使用的普通目录列表命令。
语法
dir 参数
None
返回值
此方法返回系统上的当前目录列表。
示例
/* 主程序 */ dir
输出取决于系统中的目录。
以下程序只是一个示例。
输出
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 命令的另一个示例。 只是这一次我们使用了特殊的 rc 变量。 该变量在 Rexx 中很特殊，它为您提供系统命令的执行状态。 如果返回值为0，则表示命令执行成功。 否则，错误号将在 rc 变量名称中给出。
示例
/* 主程序 */ dir
if rc = 0 then
say 'The command executed successfully'
else
say 'The command failed, The error code is =' rc
当我们运行上面的程序时，我们将得到以下结果。
输出
The command failed, The error code is = 127
重定向命令
Rexx 还具有使用重定向命令的功能。 Rexx 中提供以下重定向命令。
< − 该命令用于接收来自文件的输入。
> − 该命令用于将内容输出到文件中。 如果文件确实存在，它将被覆盖。
>> − 这也用于将内容输出到文件。 但输出会添加到文件末尾以保留文件的现有内容。
让我们看一个如何使用重定向命令的示例。 在下面的示例中，我们使用 sort 命令对名为 sortin.txt 的文件进行排序。 文件中的数据被发送到排序命令。 然后，排序命令的输出将发送到 sortout.txt 文件。
示例
/* 主程序 */ 'sort <sortin.txt> sortout.txt'
假设文件 sortin.txt 具有以下数据。
输出
b
c
a 文件sortout.txt将包含以下数据。
a
b
c
ADDRESS 函数
此方法用于找出输入、错误和输出流使用的默认环境。
语法
ADDRESS(options)
参数
特定系统地址的选项。
返回值
此方法返回输入、错误和输出流的环境名称。
示例
/* 主程序 */ say ADDRESS('I')
say ADDRESS('O')
say ADDRESS('E') 当我们运行上面的程序时，我们将得到以下结果。
输出
INPUT NORMAL
REPLACE NORMAL
REPLACE NORMAL ❮ 上一节
下一节 ❯
Rexx - XML
❮ 上一节
下一节 ❯
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> 开始使用
默认情况下，Rexx 解释器中不包含 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 函数
下载并成功注册上述部分中的所有文件后，下一步就是编写代码来加载 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 相关功能。
让我们看看 Rexx 中可用于 XML 的各种方法。
xmlVersion
此方法返回系统上使用的 XML 和 XSLT 库的版本。
语法
xmlVersion() 参数
None
返回值
此方法返回系统上使用的 XML 和 XSLT 库的版本。
示例
rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs')
if rcc then do
say rxfuncerrmsg()
exit 1
end
call xmlloadfuncs
say xmlVersion()
当我们运行上面的程序时，我们将得到以下结果。 这又取决于系统上使用的 XML 库的版本。
输出
1.0.0 20631 10126
xmlParseXML
该函数用于解析发送到该函数的XML数据。 该函数返回文档树。
语法
xmlParseXML(filename)
参数
Filename − 这是需要解析的XML文件的名称。
返回值
该函数返回文档树。 否则，如果有错误，则返回 0。
示例
rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs')
if rcc then do
say rxfuncerrmsg()
exit 1
end
call xmlloadfuncs
say xmlVersion()
sw = xmlParseXML('test.xml')
输出
无常规输出。
xmlFindNode
此方法计算传递给它的XPath 表达式。 这用于解析文档树以生成可以进一步处理的节点集。
语法
xmlParseXML(XPath,document)
参数
XPath − 这是xml文件中节点的路径。
document − 这是 XML 文档
返回值
计算 XPath 表达式并将结果作为节点集返回，供以后使用。
示例
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) 当我们运行上面的程序时，我们将得到以下结果。
输出
4 输出显示 xml 列表中 movie 节点的数量
xmlEvalExpression
以下方法用于计算 XPath 表达式并返回字符串作为结果。
语法
xmlParseXML(XPath,Node)
参数
XPath − 这是xml文件中节点的路径。
document − 具体的节点元素。
返回值
根据发送给它的 XPath 表达式返回一个字符串。
示例
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 当我们运行上面的程序时，我们将得到以下结果。
输出
War, Thriller
Anime, Science Fiction
Anime, Action
Comedy
❮ 上一节
下一节 ❯
Rexx - Regina
❮ 上一节
下一节 ❯
Rexx - Regina 解释器
Regina 是另一个可用于编译和运行 Rexx 程序的 Rexx 解释器。 Regina 的官方网站是 − www.regina-rexx.sourceforge.net/
使用 Regina 的一些优点如下 −
Regina 可以在任何平台上运行，无论是 Windows、Linux 还是 Mac OS。
Regina 按照所有可用标准工作。
Regina 拥有大量关注者，因此有很多论坛和学习材料可供 Regina 使用。
Regina 有很多可用于编写和测试 Rexx 程序的工具。
在 Regina 中，您可以运行默认 Rexx 解释器中无法运行的命令。 例如，如果包含某些配置设置，则实际上可以运行基本的系统级命令，这在 Rexx 中是不可能的。
当您通过第 2 章 – Rexx 环境中记录的安装方式安装 Rexx 时，Regina 解释器会随之安装。
现在让我们看看使用 Regina 时可用的一些常用方法。 这些功能是扩展功能，正常使用时无法使用。
要使用扩展功能，您需要包含以下代码行。 这使得可以使用 Regina 扩展功能。
options arexx_bifs
其次，在运行所有 Rexx 程序时，使用以下命令。
regina main.rexx
其中
regina − 这是用于 Rexx 程序的解释器。
main.rexx − 您的 Rexx 程序。
我们现在将详细讨论Regina Rexx Interpreter 的各种功能。
序号
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 - 解析

❮ 上一节
下一节 ❯
Rexx - 解析
Rexx 最强大的功能之一是它解析文本值的能力。 您可能不会在任何其他编程语言中看到这一点。
PARSE 解析语句的一般格式如下 −
语法
PARSE {UPPER|LOWER|CASELESS} source {template}
其中
UPPER − 在解析之前将源代码转换为大写。
LOWER − 在解析之前将源代码转换为小写。
CASELESS − 传递此参数时，大小写将被忽略。
source − 这就是需要解析的源码。 有许多选项可用于此，可以是以下任意一项 −
ARG − 程序或过程的参数可以用作源。
LINEIN − 下一行输入可以用作源。
SOURCE − 可以将程序的源码信息作为来源。
VAR name − 变量名称的值可以用作源。
template − 该参数指定如何解析源。 为此有很多选项可用。 下面提到了其中一些。
variable name − 这是分配给变量的值。
literal string − 一个文字字符串，可以使用模式来分割字符串。
# − 源本身内的绝对字符位置。 因此，如果您指定值 5，则将使用第 5 个字符。
&plus;# − 源本身内的相对字符位置。 因此，如果您指定值 5，则将相对使用第 5 个字符。
让我们看一个简单的示例，了解如何在 Rexx 中完成解析。
示例
/* 主程序 */ 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 子句来进行解析。
示例
/* 主程序 */ phrase = 'This is a Tutorial'
do while phrase <> ''
parse var phrase word phrase
say "'"word"'"
end
上面的程序将给出以下输出 −
'This'
'is'
'a'
'Tutorial'
位置解析
Rexx 还允许进行位置解析。 让我们看一个如何使用 parse 语句实现位置解析的示例。
示例
/* 主程序 */ 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 在这种情况下，您还可以使用相对位置解析。
示例
/* 主程序 */ 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 - 信号
❮ 上一节
下一节 ❯
Rexx - 信号指令
在Rexx中，信号指令一般有两个用途，分别是 −
一是将控制权转移到程序的另一部分。 这通常类似于其他编程语言中使用的转到标签。
另一个是转到特定的陷阱标签。
如果在以下任何指令命令中使用信号命令，则挂起的控制结构将自动停用。
if ... then ... else ...
do ... end
do i = 1 to n ... end [and similar do loops]
select when ... then ... ...etc. otherwise ... end
信号语句的一般语法如下所示 −
语法

#signal

signal labelName

signal [ VALUE ] labelExpression
让我们看一个如何使用信号语句的示例。
示例
/* 主程序 */ 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' 上述程序的输出如下所示。
输出
This is an incorrect number. 如果将变量 n 的值更改为整数，如以下程序所示 −
/* 主程序 */ 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 还可以传递标签的值，如下面的程序所示 −
/* 主程序 */ 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 陷阱标签传输激活/停用
正如我们之前提到的，信号指令也可用于将控制权转移到陷阱标签。
陷阱标签传输的一般语法如下 −
语法
signal ON conditionName [ NAME Label ]

signal OFF conditionName 其中，
conditionName − 这是应打开或关闭信号的条件。
Label − 程序应转向的可选标签。
让我们看一个使用陷阱标签传输的示例。
示例
/* 主程序 */ 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 - 调试
❮ 上一节
下一节 ❯
Rexx - 调试
调试是任何编程语言的一个重要功能。 它可以帮助开发人员诊断错误，找到根本原因，然后相应地解决它们。 在 Rexx 中，跟踪实用程序用于调试。 跟踪指令可以通过两种方式实现，一种是批处理方式，另一种是交互方式。 让我们看看如何实现这两个选项。
以批处理模式跟踪
trace 命令用于给出执行的每个 Rexx 命令的详细级别。
trace 语句的一般语法如下所示 −
语法
trace [setting]
其中设置可以是以下选项中的任何一个 −
A − 跟踪所有命令。
C − 仅跟踪发送到操作系统的主机命令。
E − 仅跟踪发送到操作系统并导致错误的主机命令。
F − 仅跟踪发送到操作系统并导致失败的主机命令。
I − 这提供了 Rexx 命令的中级跟踪。
L − 如果您想在跟踪发生时对其进行标记，则可以选择此选项。
N − 这是默认选项，不会发生任何跟踪。
让我们看一下跟踪命令的示例。
示例
/* 主程序 */ trace A
/* 主程序 */ 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 从输出中，您可以看到程序的输出中添加了额外的跟踪。 关于输出，需要注意以下几点 −
行号与执行的语句一起添加到跟踪输出中。
执行的每一行都显示在跟踪输出中。
trace 跟踪函数
还可以借助跟踪功能来启用跟踪。 一般语法和示例如下所示。
语法
trace()
上述函数返回当前跟踪级别。
参数
None
返回值
上面的函数给出了当前的跟踪级别。
示例
/* 主程序 */ say trace()
/* 主程序 */ 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 表示迹线设置为"正常"。
设置跟踪级别
可以使用跟踪功能设置跟踪级别。 一般语法和示例如下所示。
语法
trace(travel_level)
参数
trace_level − 这与可用于设置跟踪级别的选项类似。
返回值
上面的函数给出了当前的跟踪级别。
示例
/* 主程序 */ say trace()
current_trace = trace('A')
say current_trace
/* 主程序 */ 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 中一样，您可以在其中添加断点并查看每个语句的执行情况，同样，您也可以在每个代码行运行时看到程序。
一般语法如下 −
语法
trace ?options
其中，options 选项与跟踪命令相同，如下所示。
A − 跟踪所有命令
C − 仅跟踪发送到操作系统的主机命令。
E − 仅跟踪发送到操作系统并导致错误的主机命令。
F − 仅跟踪发送到操作系统并导致失败的主机命令。
I − 这提供了 Rexx 命令的中级跟踪。
L − 如果您想在跟踪发生时对其进行标记，则可以选择此选项。
N − 这是默认选项，不会发生任何跟踪。
让我们看一个实现主动跟踪的示例。
示例
/* 主程序 */ trace ?A /* 主程序 */ 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 - 错误处理
❮ 上一节
下一节 ❯
Rexx - 错误处理
Rexx 还能够像其他编程语言一样进行错误处理。
以下是 Rexx 中出现的一些各种错误情况。
ERROR − 每当发送到操作系统的命令导致错误时，甚至会引发此错误。
FAILURE − 每当发送到操作系统的命令导致失败时，就会引发此事件。
HALT − 当一个操作依赖于另一个操作时，通常会引发此错误。 例如，如果 I/O 操作因任何原因而停止。
NOVALUE − 当值尚未分配给变量时会引发此事件。
NOTREADY − 这是由任何未准备好接受任何操作的 I/O 设备引发的。
SYNTAX − 如果代码中存在任何语法错误，则会引发此事件。
LOSTDIGITS − 当算术运算导致运算期间数字丢失时，将引发此事件。
捕获错误
借助信号命令捕获错误。 让我们看一下语法和示例。
语法

#signal on [Errorcondition] 其中，

Errorcondition − 这是上面给出的错误情况。
示例
让我们看一个关于此的示例。
/* 主程序 */ 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. 以下程序显示了错误代码的示例。
/* 主程序 */ 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 signal
上述程序的输出如下所示。
An error has occured
40
6 ❮ 上一节
下一节 ❯
Rexx - 面向对象
❮ 上一节
下一节 ❯
Rexx - 面向对象
当您按照环境章节安装 ooRexx 时，您还可以使用类和对象。 请注意，以下所有代码都需要在 ooRexx 解释器中运行。 普通的 Rexx 解释器将无法运行此面向对象的代码。
类和方法声明
类是使用以下语法声明定义的。
语法
::class classname
其中classname是为类指定的名称。
类中的方法是使用以下语法声明定义的。
语法
::method methodname
其中methodname是为方法指定的名称。
类中的属性是使用以下语法声明定义的。
语法
::attribute propertyname
其中propertyname是为属性指定的名称。
示例
以下是 Rexx 中的类示例。
::class student
::attribute StudentID
::attribute StudentName
上述程序需要注意以下几点。
类名称为 student。
该类有 2 个属性:StudentID 和 StudentName。
Getter 和 Setter 方法
Getter 和 Setter 方法用于自动设置和获取属性的值。 在 Rexx 中，当您使用 attribute 关键字声明属性时，getter 和 setter 方法就已经就位。
示例
::class student
::attribute StudentID
::attribute StudentName
在上面的示例中，StudentId 和 StudentName 都有 Getter 和 Setter 方法。
以下程序显示了如何使用它们的示例。
/* 主程序 */ 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 运算符从类创建对象。 可以通过以下方式调用该类的方法。
Object~methodname
其中methodname是需要从类中调用的方法。
示例
以下示例展示了如何从类创建对象并调用相应的方法。
/* 主程序 */ 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）并相应地调用它们的实例成员和实例方法。
让我们看一个如何创建多个对象的示例。
示例
/* 主程序 */ 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
继承
继承可以定义为一个类获取另一个类的属性（方法和字段）的过程。 通过使用继承，可以按层次结构顺序管理信息。
继承其他类的属性的类称为子类（派生类、子类），而其属性被继承的类称为超类（基类、父类）。
让我们看一下 Rexx 中的继承示例。 在下面的示例中，我们将创建一个名为 Person 的类。 从那里，我们使用 subclass 关键字创建 Student 类 作为 Person 的子类。
示例
/* 主程序 */ 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 - 可移植性
❮ 上一节
下一节 ❯
Rexx - 可移植性
可移植性是任何编程语言的一个重要方面。 众所周知，Rexx 可在 Windows 和 Linux 等多种操作系统中使用。 因此需要确保在Windows平台上开发程序时，如果相同的程序在Linux平台上运行，也采取了必要的预防措施。
Rexx 能够运行系统级命令。 有一些命令可用于了解它运行的操作系统是什么。 然后，它可以根据输出采取适当的操作来查看可以在此操作系统上运行的命令。
示例
以下示例显示如何使用解析函数来获取程序运行所在操作系统的详细信息。
/* 主程序 */ 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 - 扩展函数
❮ 上一节
下一节 ❯
Rexx - 扩展函数
Rexx 提供了许多扩展函数，这些函数提供了各种各样的功能，其中大多数允许您与操作系统交互。 让我们详细看看其中的一些，如下所述。
序号
扩展函数
1
b2c
此函数将二进制值转换为字符串值。
2
bitclr
该函数用于将二进制字符串中的指定位切换为 0。
3
bitcomp
该函数用于比较从位0开始的2个二进制字符串。
4
buftype
该函数用于显示堆栈的内容，通常用于调试目的。
5
crypt
该函数用于加密字符串。
6
fork
该函数用于在系统上生成一个新的子进程。
7
getpid
该函数获取当前正在运行的进程的id。
8
hash
该函数返回字符串的哈希值。
❮ 上一节
下一节 ❯
Rexx - 指令
❮ 上一节
下一节 ❯

Rexx - 指令说明

Rexx 提供了许多指令，这些指令提供了各种各样的功能，其中大多数允许您与操作系统交互。 让我们详细看看其中的一些。
序号
Rexx 指令

1#address

该函数用于显示当前的命令环境。

2#drop

此函数用于取消分配变量。

3#interpret

解释或执行定义的指令。

4#nop

该函数表示不执行任何操作。 该命令通常用在if语句中。
5
Pull
这用于从堆栈或默认流中提取输入。
6
push
这用于将值推送到 Rexx 堆栈上。
❮ 上一节
下一节 ❯
Rexx - 实现
❮ 上一节
下一节 ❯
Rexx - 实现
正如我们在前面的章节中已经看到的，Rexx 语言有很多不同的实现。 每个实现都有其自己的功能。 让我们看看可用于 Rexx 的各种实现。
OoRexx
这是 Rexx 的面向对象版本。 默认情况下，Rexx的基本实现都是基于程序的。 但使用 ooRexx，您可以通过采用面向对象的 Rexx 方法来提供更大的灵活性。 通过使用 ooRexx，您可以通过创建可重用的类和对象来更好地重用。
以下程序是一个简单的 Rexx 程序示例，可以与 ooRexx 实现程序一起运行。
示例
/* 主程序 */ say ‘hello’
要运行此程序，请运行以下命令。
rexx main.rexx
当您运行上述命令时，您将得到以下输出。
hello Netrexx
这适用于所有基于 Java 的开发人员，因为它为 Rexx 语言提供了基于 Java 的替代方案。 所以所有的对象都是基于Java对象模型的。 该框架的优势在于，由于 Java 是一种广泛流行的语言，因此开发人员更容易使用该框架。 因此，在这个实现中，Rexx代码被转换为Java程序，然后可以在任何Java虚拟机上运行。
以下代码是 NetRexx 程序的示例。
创建一个名为 main.nrx 的文件，并将以下代码放入该文件中。
/* 主程序 */ 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 程序的示例。
/* 主程序 */ say ‘hello’ 要运行该程序，请运行以下命令。
rexx32 main.rexx 当您运行上述命令时，您将得到以下输出。
hello ❮ 上一节
下一节 ❯
Rexx - Netrexx
❮ 上一节
下一节 ❯
Rexx - Netrexx 实现器
NetRexx 是 Rexx 的 java 实现。 在NetRexx中，实现器用于将Rexx程序转换为可以在任何Java虚拟机上运行的java程序。
设置 NetRexx
NetRexx 的第一步是在本地计算机上进行设置。 为此，需要执行以下步骤−
步骤 1 − 转至 NetRexx 下载站点 − http://www.netrexx.org/downloads.nsp
下载 NetRexx.3.04.GA 文件。
步骤 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)
步骤 3 − 解压缩 Netrexx 压缩文件的内容。 将文件从 NetRexx3.04GA\lib 文件夹复制到 java 安装/lib/etc 文件夹。
步骤 4 − 将 NetRexx-3.04GA\bin 路径添加到系统上的路径变量中。
运行第一个 NetRexx 程序
创建一个名为 main.nrx 的文件，并将以下代码放入该文件中。
/* 主程序 */ 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 现在让我们讨论一下Netrexx 库的一些特殊方面。
索引字符串
在 NetRexx 中，字符串可以成为数组的索引。 一个例子如下所示。
示例
/* 主程序 */ value = 'unknown'
value['a'] = 'b'
c = 'a'
say value[c]
当我们运行上面的程序时，我们将得到以下结果。
输出
b 多个索引
在 NetRexx 中，您可以为数组设置多个索引。 下面显示了一个示例。
示例
/* 主程序 */ value = 'null'
value['a', 'b'] = 1
say value['a', 'b'] 当我们运行上面的程序时，我们将得到以下结果。
输出
1 序号
命令与描述
1
ask 命令
该命令用于从默认输入流中读取一行。
2
digits 命令
该命令用于显示当前数值。
3
form 命令
该命令用于显示表单值的当前值。
4
length 命令
该命令用于显示字符串值的长度。
5
version 命令
此命令用于返回当前使用的 NetRexx 版本。
6
trace 命令
此命令用于返回 NetRexx 使用的当前跟踪设置。
❮ 上一节
下一节 ❯
Rexx - Brexx
❮ 上一节
下一节 ❯
Rexx - Brexx 功能
BRexx 是 Rexx 的轻量级实现。 作为 Rexx 实现的一部分，它仍然可以提供许多功能。
设置 BRexx
BRexx 的第一步是在本地计算机上进行设置。 为此，需要执行以下步骤 −
步骤 1 − 前往 BRexx 下载网站 − https://ftp.gwdg.de/pub/languages/rexx/brexx/html/rx.html
转到下载部分并下载产品。
步骤 2 − 解压 Brexx 压缩文件的内容。
步骤 3 − 将 BRexx\bin 路径添加到系统上的路径变量中。
步骤 4 − 创建一个名为 RXLIB 的新变量并将其指向 Brexx 文件夹中的 lib 文件夹。
运行第一个 BRexx 程序
创建一个名为 main.rexx 的文件，并将以下代码放入该文件中。
/* 主程序 */ say ‘hello’
要运行该程序，请运行以下命令。
rexx32 main.rexx
当您运行上述命令时，您将得到以下输出。
hello 现在让我们讨论 BRexx 库中一些最常用的函数。
序号
BRexx 库中提供的函数
1
acos 命令
该命令用于获取数字的反余弦转换。
2
cos 命令
该命令用于获取数字的余弦转换。
3
sin 命令
该命令用于获取数字的正弦转换。
4
asin 命令
该命令用于获取数字的反正弦转换。
5
tan 命令
该命令用于获取数字的正切转换。

6#atan 命令

该命令用于获取数字的反正切转换。

7#mkdir 命令

该命令用于在当前工作目录中创建一个目录。
8
rmdir 命令
该命令用于删除当前工作目录中的目录。

9#dir 命令

该命令用于返回整个目录列表。
❮ 上一节
下一节 ❯
Rexx - 数据库
❮ 上一节
下一节 ❯
Rexx - 数据库
Rexx 能够使用下面列出的各种数据库。
HSQLDB
Oracle
SQL Server
MySQL
MongoDB
点击以下链接即可找到Rexx数据库的所有信息 − https://rexxsql.sourceforge.net/
在我们的示例中，我们将使用 MySQL DB 作为示例。 因此，第一步是确保从 Rexx SQL 站点下载所需的驱动程序，以便 Rexx 程序可以相应地使用 SQL。 因此，请按照后续步骤确保Rexx程序可以与MySQL数据库配合使用。
步骤 1 − 从 Rexx 站点转至以下驱动程序下载页面 − https://sourceforge.net/projects/rexxsql/files/rexxsql/2.6/
步骤 2 − 下载 MYSQL 驱动程序 - rxsql26B3_my_w32_ooRexx
步骤 3 − 将内容解压到本地计算机。
步骤 4 − 将解压文件夹的路径添加到您计算机上的路径变量中。
对于所有后续示例，请确保以下指针已就位 −
您已创建数据库 TESTDB。
您已在 TESTDB 中创建了一个表 EMPLOYEE。
该表包含字段 FIRST_NAME、LAST_NAME、AGE、SEX 和 INCOME。
设置用户 ID"testuser"和密码"test123"来访问 TESTDB。
确保您已下载 mysql jar 文件并将该文件添加到类路径中。
您已完成 MySQL 教程
数据库连接
要建立数据库连接，首先需要Rexxsql DLL，然后使用SQLConnect函数建立与数据库的连接。 下面给出了如何实现这一点的语法和示例。
语法
SQLConnect(cname,username,password,dbname)
参数
cname − 这是为连接指定的名称。
username − 连接数据库的用户名。
password − 连接数据库的密码。
dbname − 要连接的数据库架构。
返回值
等于0的值表示数据库连接成功。
示例
/* 主程序 */ Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs'
Call SQLLoadFuncs
say SQLConnect(c1,' testuser ',' test123','testdb') 上述程序的输出如下所示。
0 创建数据库表
连接到数据库后的下一步是在我们的数据库中创建表。 以下示例显示如何使用 Rexx 在数据库中创建表。 Rexx SQL 中的所有命令均通过使用 SQLCommand 函数执行。
语法
SQLConnect(sname,statement) 参数
sname − 这是要执行的语句的名称。
statement − 这是需要对数据库执行的语句。
返回值
值等于 0 表示命令成功。
示例
/* 主程序 */ 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
对数据库表的操作
以下类型的操作最常在数据库表上执行。
序号
操作 & 描述
1
插入操作
当您想要将记录创建到数据库表中时，这是必需的。
2
读操作
对任何数据库的读取操作都意味着从数据库中获取一些有用的信息。
3
更新操作
任何数据库上的 UPDATE 操作都意味着更新数据库中已有的一条或多条记录。
4
删除操作
当您想从数据库中删除某些记录时，需要执行 DELETE 操作。
5
关闭连接
以下命令可用于关闭与数据库的连接。
执行事务
事务是一种确保数据一致性的机制。 事务具有以下四个属性 −
原子性 − 一个事务是一个不可分割的工作单位，事务中包括的许多操作要么都做，要么都不做。
一致性 − 事务必须是使数据库从一个一致性的状态变到另外一个一致性状态。一致性与原子性的密切相关的。
隔离性 − 一个事务的执行不能被其他事务干扰。既一个事务内部操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能相互干扰。
持久性 − 持续性也称永久性。指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的，接下来的其他操作或者故障对其没有任何的影响。
这是一个如何实现事务的简单示例。
示例
/* 主程序 */ 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 提交操作
提交操作告诉数据库继续操作并完成对数据库的所有更改。 在上面的示例中，这是通过以下命令实现的。
Sqlcommit()
回滚操作
如果您对一项或多项更改不满意，并且想要完全恢复这些更改，请使用回滚方法。 在上面的示例中，这是通过以下命令实现的。
SqlRollback()
❮ 上一节
下一节 ❯
手持设备和嵌入式设备
❮ 上一节
下一节 ❯
Rexx - 手持式和嵌入式编程
手持设备已经取得了长足的进步，Rexx 有很多方法可以在这些设备上运行。 Rexx 支持 Pocket PC、Palm 设备、PDA 和其他智能手机设备。 Rexx 在这些平台上工作的优势在于，Rexx 确实是一个轻量级编程系统，运行时间只有几千字节。 因此，在这些设备上运行 Rexx 程序变得更加容易。
手持设备上的 Rexx 可以在以下模式下运行 −
第一种模式是本机节点，它直接在操作系统本身上运行。 在此模式下运行的优点是速度更快，因为它直接脱离操作系统运行。
下一个模式是在手持设备之上的 DOS 或仿真器程序之上。 这种模式的优点是可以在任何类型的操作系统上运行，只要模拟器在该操作系统上运行即可。
下面显示了适用于各种手持设备类别的 Rexx 解释器。
Windows CE − Brexx
Palm OS − Rexx for Palm OS
Symbian OS − Regina
对于DOS模拟器，需要执行以下步骤 −
步骤 1 − 首先是下载 PocketDOS，这是一个流行的 DOS 模拟器。 它设计为可以在多种操作系统上运行，并支持常见的 VGA 屏幕以及串行和并行端口。
步骤 2 − 下一步是将 16 位 DOS 的 BRexx 文件下载到 Windows PC。
步骤 3 − 最后一步是使用 ActiveSync 将 Rexx 程序同步到手持设备。
还有一些其他基于 DOS 的商业产品可用。 XTM 就是属于此类别的产品。 该产品的特点如下 −
支持 80186 CPU 和指令集。
它可以通过 BIOS 代码来实现更好的性能。
它可以为数学协处理器（版本 8087 MPU）提供仿真
它提供对串行端口的访问。
它支持多种语言，例如英语、法语和德语。
❮ 上一节
下一节 ❯
Rexx - 性能
❮ 上一节
下一节 ❯
Rexx - 性能
任何编程语言的关键方面之一是应用程序的性能。 需要注意特殊实践，以确保应用程序的性能不受影响。 让我们看一下步骤中描述的一些注意事项，以便更好地理解 −
步骤 1 − 尝试减少指令数量——在 Rexx 中，每条指令都会产生开销。 因此，请尝试减少程序中的指令数量。 下面显示了可以重新设计的指令示例。
可以使用解析语句，而不是使用多个 if else 语句。 因此，就像在下面的程序中一样，不要为每个值设置 if 条件并获取 word1、word2、word3 和 word4 的值，而是使用 parse 语句。
/* 主程序 */
parse value 'This is a Tutorial' with word1 word2 word3 word4
say "'"word1"'"
say "'"word2"'"
say "'"word3"'"
say "'"word4"'"
步骤 2 − 尝试将多个语句合并为一个语句。 下面显示了一个示例。
假设您有以下代码，它为 - a 和 b 进行赋值并将其传递给名为 proc 的方法。
do i = 1 to 100
a = 0
b = 1
call proc a,b
end 您可以使用解析语句轻松地将上面给出的代码替换为以下代码。
do i = 1 for 100
parse value 0 1 with
a,
b,
call proc a,b
end
步骤 3 − 尽可能尝试用 do..for 循环 替换 do..to 循环。 当控制变量通过循环迭代时，通常建议这样做。
/* 主程序 */ do i = 1 to 10
say i
end
上述程序应替换为以下程序。
/* 主程序 */ do i = 1 for 10
say i
end 步骤 4 − 如果可能，请从 do 循环中删除 for 条件，如以下程序所示。 如果不需要控制变量，则只需将最终值放入 do 循环中，如下所示。
/* 主程序 */ do 10
say hello
end 步骤 5 − 在 select 子句中，无论您认为要评估的最佳条件，都需要放在 when 子句中。 因此，在下面的示例中，如果我们知道 1 是最常见的选项，我们会将 when 1 子句 作为 select 语句中的第一个子句。
/* 主程序 */ select
when 1 then say'1'
when 2 then say'2'
otherwise say '3'
end
❮ 上一节
下一节 ❯
Rexx - 最佳编程实践
❮ 上一节
下一节 ❯
Rexx - 最佳编程实践
每个程序员都希望他们的程序在质量和效率方面是最好的。 以下是编写 Rexx 程序时的一些最佳编程实践或提示，可以帮助人们实现这些目标。
提示1
在向操作系统或命令提示符发出任何命令之前，请使用 address 命令。 这将帮助您预先获取内存中的地址空间，并使您的程序运行更高效。
address 命令的示例如下所示。
示例
/* 主程序 */ 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 提示2
确保对操作系统的所有命令均大写并尽可能用引号引起来。
下面显示了相同的示例。
示例
/* 主程序 */ options arexx_bifs
say chdir('\REXXML100')
say directory() 当我们运行上面的程序时，我们将得到以下结果。
0
D:\rexxxml100
提示3
避免创建大注释块，如以下程序所示。
示例
/******/
/* */
/* */
/* */
/******/
/* 主程序 */ address system dir 提示4
使用 Parse 语句分配默认值。 下面显示了相同的示例。
示例
parse value 0 1 with
a,
b
提示5
尽可能使用"Left(var1,2)"语句而不是"substr(var1,1,2)"语句。
提示6
尽可能使用"Right(var1,2)"语句而不是"substr(var1,length(var1),2)"语句。
❮ 上一节
下一节 ❯
Rexx - 图形用户界面
❮ 上一节
下一节 ❯
Rexx - 图形用户界面
为了使用Rexx中提供的图形用户界面，需要使用2个包，一个称为ActiveTcl，另一个是Rexxtk包。 除了这两个包之外，还可以设计普通表单，其中可以在表单上包含按钮和其他控件。
环境设置
首先要做的是环境设置。 让我们完成以下步骤来准备好环境。
步骤 1 − 从以下网站下载Activetcl包 − https://www.activestate.com/activetcl
步骤 2 − 下一步是开始安装ActiveTCl。 单击屏幕上的"下一步"按钮继续。
步骤 3 − 接受许可协议并单击"下一步"按钮。
步骤 4 − 选择安装位置，然后单击下一步按钮。
步骤 5 − 选择演示的安装位置，然后单击"下一步"按钮。
步骤 6 − 单击"下一步"按钮继续安装。
步骤 7 − 单击"完成"按钮完成安装。
步骤 8 − 下一步是从以下链接下载 Rexxtk 软件 − https://sourceforge.net/projects/rexxtk/
步骤 9 − 双击上一步链接中的安装程序文件开始安装。 单击下一步按钮继续。
步骤 10 − 在下一个屏幕中，单击"是"按钮以同意许可协议。
步骤 11 − 在下一个屏幕中，选择安装位置，然后单击"下一步"按钮。
步骤 12 − 选择程序文件夹位置，然后单击下一步按钮。
安装完成后，我们现在可以开始在 Rexx 中对 GUI 进行编程。
基本程序
让我们看看如何使用 Rexx 以图形用户界面格式设计一个简单的基本程序。
示例
/* 主程序 */ call RxFuncAdd 'TkLoadFuncs','rexxtk','TkLoadFuncs'
call TkLoadFuncs
do forever
interpret 'Call' TkWait()
end
call TkDropFuncs
exit 0
上述程序需要注意以下几点−
Rexxtk 库及其所有函数均使用 RxFuncAdd 命令加载。
do Forever 循环将使窗口保持打开状态并等待用户输入。
一旦检测到用户输入，程序就会退出。
执行上述程序时，您将得到以下输出。
创建菜单
菜单是在 TkMenu 和 TkAdd 函数的帮助下创建的。 这些函数的语法如下所示。
语法
TkMenu(widgetname,options,0)
参数
Widgetname − 为菜单指定的名称。
选项可以是以下任意一个 −
selectcolor − 如果复选框或单选按钮用作菜单选项，则此选项指定选择任何菜单选项时要选择的颜色。
tearoff − 该选项用于向主菜单添加子菜单。
title − 需要用于为窗口提供标题的字符串。
返回值
所创建菜单的句柄。
示例
/* 主程序 */ 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 函数添加 2 个名为"File"和"Open"的菜单选项。
执行上述程序时，您将得到以下输出。
❮ 上一节
下一节 ❯
Rexx - Reginald
❮ 上一节
下一节 ❯
Rexx - Reginald 解释器
Reginald 是另一个 Rexx 解释器，由 Jeff Glantt 开发，并对 Rexx 程序的运行方式进行了一些自定义。 在本节中，我们将了解如何安装 Reginald 并在其中运行一些 Rexx 程序。
环境设置
第一步是环境设置，即下载 Reginald 文件。 这可以通过以下网站链接完成 − http://www.manmrk.net/tutorials/rexx/Reginald/win32/rxusrw32.htm
下载完成并启动安装程序后，下一个屏幕将允许您选择安装位置。
单击"安装"按钮继续。
完成后，我们现在可以开始在 Reginald 解释器中运行一个示例程序。 创建一个简单的程序，如下所示。
/* 主程序 */ say 'Hello'
然后运行以下命令 −
RxLaunch.exe main.rexx
然后您将得到以下输出。 该程序现在将在 Reginald 解释器中运行。
其他可用功能
除了正常的 Rexx 命令之外，Reginald 还有一些专为 Windows 操作系统量身定制的特定命令。 DriveMap 就是这样一个命令 −
DriveMap
此函数提供有关驱动器的信息。
语法 −
Drivemap(,options)
参数 −
选项 − 这些是关键字列表，可用于获取本地计算机驱动器上的各种信息。
返回值
包含驱动器信息的字符串值。
示例 −
/* 主程序 */ say 'Drives on system : ' DriveMap(,'FIXED')
如果运行上述程序，您将得到以下输出。 此输出取决于系统的不同。
List of disk drives : C:\ D:\
❮ 上一节
下一节 ❯
Rexx - 网络编程
❮ 上一节
下一节 ❯
Rexx - 网络编程
Rexx 还可以与 Web 服务器一起使用。 最常见的是 apache Web 服务器。 为了将 Rexxw 与 Apache Web 服务器一起使用，您需要首先从以下链接下载 Rexx 模块 − https://sourceforge.net/projects/modrexx/?source=typ_redirect
完成后，请确保将 mod Rexx 模块添加到类路径中。
需要在 Apache 配置文件中添加和修改以下行。
以下行需要添加到相应的末尾 −
httpd.conf LoadModule list.
LoadModule rexx_module modules/mod_rexx.dll
以下行应添加到 http.conf 文件的末尾。
AddType application/x-httpd-rexx-script .rex .rexx
AddType application/x-httpd-rexx-rsp .rsp
Add these for REXX Server Page support
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 程序。
最后，临时文件被删除。
❮ 上一节
下一节 ❯
关于
关于我们
W3Schools 在线教程提供主要网络编程语言的免费学习教程,参考资料和实例练习。
W3Schools 是完全免费的
W3Schools 是非盈利性的
W3Schools 一直在升级和更新
W3Schools 致力于推广 W3C 标准技术
提供 WEB 开发技术资源
W3Schools 提供因特网上 WEB 开发技术资源，包括比较全面的教程、完善的参考手册以及庞大的代码库。
完全免费
W3Schools 把提供高品质的 WEB 技术资源作为自身的使命。
W3Schools 将为用户提供永久免费的内容和服务。
非盈利
W3Schools 不以盈利为目的，尽管维持网站正常运营的费用非常可观。
W3Schools 的运营费用主要来自两方面:创办人的无私投入，以及少量的广告收入。
W3Schools 一直将全部资金用于网站内容的开发以及服务器硬件的升级和维护。
坚持不懈的更新和升级
W3Schools 一直在对内容进行更新和完善，并适时地推出重要的升级版本。
W3Schools 将紧随 WEB 技术的飞速发展，为广大用户提供最新鲜的内容和服务。

标签：一节,主程序,示例,程序,say,REXX,Rexx
From： https://www.cnblogs.com/haosc210213/p/18404033