Rexx - 快速指南

---

Rexx - 概述

Rexx（重组扩展执行器）被设计为一种脚本语言。其目标是使脚本编写尽可能简单、快速、可靠且无错误。许多编程语言都是为了与旧语言兼容而设计的，并且是为特定受众或平台编写的。Rexx 会忽略无关的目标。它从第一天起就被设计为功能强大且易于使用。

^{Rexx 是由 IBM 的 Mike Cowlishaw 于 1979 年3}月 20日至 1982 年中期以汇编语言设计并首次实现的，作为一个“自己的时间”项目，最初是作为一种脚本编程语言来取代EXEC 和 EXEC 2语言。它被设计为适用于任何系统的宏或脚本语言。因此，Rexx 被认为是 Tcl 和 Python 的先驱。Rexx 的创建者还希望成为 PL/I 编程语言的简化且更易于学习的版本。

雷克斯的特点

Rexx 作为一种编程语言具有以下主要特征 -

• 语法简单

• 将命令路由到多个环境的能力

• 支持与特定调用环境相关的函数、过程和命令的能力。

• 内置堆栈，能够与主机堆栈（如果有）进行互操作。

• 仅包含两打指令的小型指令集

• 自由格式语法

• 不区分大小写的标记，包括变量名称

• 字符串基础

• 动态数据类型，无声明

• 除本地上下文外，没有保留关键字

• 没有包含文件设施

• 任意数值精度

• 小数运算、浮点运算

• 丰富的内置函数选择，特别是字符串和文字处理

• 自动存储管理

• 碰撞保护

• 内容可寻址数据结构

• 关联数组

• 直接访问系统命令和设施

• 简单的错误处理以及内置的跟踪和调试器

• 很少人为限制

• 简化的 I/O 设施

Rexx 的官方网站是www.oorexx.org

Rexx - 环境

在开始使用 Rexx 之前，您需要确保系统上运行的是功能齐全的 Rexx 版本。本章将解释如何在 Windows 计算机上安装 Rexx 及其后续配置，以开始使用 Rexx。

在继续安装之前，请确保满足以下系统要求。

系统要求

下载雷克斯

要下载 Rexx，您应该使用以下 URL - https://www.oorexx.org/download.html

此页面有各种版本的 Rexx 的下载，如下面的屏幕截图所示。

单击表中标题为版本 4.2.0 的“ooRexx 安装文件”。

之后，您将被重定向到以下页面。

单击ooRexx-4.2.0.windows.x86_64.exe下载64 位版本的软件。我们将在下一章讨论软件的安装。

Rexx - 安装

以下步骤将详细说明如何在 Windows 系统上安装 Rexx。

步骤 1 - 启动在前面部分中下载的安装程序。安装程序启动后，单击“运行”按钮。

步骤 2 - 单击以下屏幕上的下一步按钮继续安装。

步骤 3 - 单击“我同意”按钮继续。

步骤 4 - 接受默认组件，然后单击下一步按钮。

步骤 5 - 选择安装位置，然后单击“下一步”按钮。

步骤 6 - 接受将安装的默认进程，然后单击“下一步”按钮。

步骤 7 - 选择默认文件关联，然后单击“下一步”按钮。

步骤 8 - 单击将 Rexx 项目发送到可执行文件的复选框，然后单击“下一步”按钮，如以下屏幕截图所示。

步骤 9 - 在下一个屏幕中，选择用于处理 Rexx 文件的编辑器。将记事本保留为默认选项。还接受每个 Rexx 文件的默认扩展名。

步骤 10 - 接受出现的以下屏幕上的默认设置，然后单击“下一步”按钮进一步继续安装。

步骤 11 - 最后单击“安装”按钮继续安装。

步骤 12 - 安装完成后，您需要单击“下一步”按钮以继续。

步骤 13 - 单击“完成”按钮完成安装。

Rexx - 插件安装

在本章中，我们将讨论如何在流行的IDE（集成开发环境）上安装插件。Rexx 作为一种编程语言也可在流行的 IDE（例如Eclipse）中使用。让我们看看如何在这些 IDE 中获取所需的插件，以便您在使用 Rexx 时有更多选择。

在 Eclipse 中安装

要在 Eclipse 中顺利安装 Rexx，您需要遵循以下步骤。

步骤 1 - 打开 Eclipse 并单击菜单项“帮助”→“Eclipse Marketplace”，如以下屏幕截图所示。

步骤 2 - 在下一个对话框中，在搜索条件中输入 Rexx，然后单击搜索按钮。

完成后，单击“安装”按钮。

步骤 3 - 单击“确认”按钮进一步继续安装功能。

步骤 4 - 然后 Eclipse 将下载必要的文件以开始安装。完成后，Eclipse 将要求您接受许可协议。单击接受许可协议，然后单击完成按钮，如以下屏幕截图所示。

然后 Eclipse 将开始在后台安装该软件。

步骤 5 - 您可能会收到安全警告（如以下屏幕截图所示）。单击“确定”按钮继续。

步骤 6 - 安装更新后，系统将提示您重新启动 Eclipse。单击“是”重新启动 Eclipse。

Rexx - 基本语法

为了理解Rexx的基本语法，让我们首先看一个简单的Hello World程序。

例子

/* Main program */ 
say "Hello World" 

可见 hello world 程序是多么简单。这是一个简单的脚本行，用于执行 Hello World 程序。

关于上述程序需要注意以下事项 -

• say 命令用于向控制台输出一个值。

• / * */用于 Rexx 中的注释。

上述程序的输出将是 -

Hello World

声明的一般形式

在 Rexx 中，让我们看看程序的一般形式。看一下下面的例子。

/* Main program */ 
say add(5,6) 
exit 
add: 
parse arg a,b 
return a + b

上述程序的输出将是 -

11

让我们回顾一下我们从上面的程序中了解到的内容 -

• Add 是一个定义为将 2 个数字相加的函数。

• 在主程序中，5和6的值用作add函数的参数。

• exit 关键字用于退出主程序。这用于区分主程序和添加函数。

• add 函数用“:”符号区分。

• parse 语句用于解析传入的参数。

• 最后，return 语句用于返回数值的总和。

子程序和函数

在 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。

执行命令

Rexx 可用作各种基于命令的系统的控制语言。Rexx在这些系统中执行命令的方式如下。当 Rexx 遇到既不是指令也不是赋值的程序行时，它会将该行视为要计算的字符串表达式，然后传递到环境。

一个例子如下 -

例子

/* 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 关键字的示例包括DO 指令中的 WHILE以及IF 或 WHEN 子句后面的THEN（在本例中充当子句终止符）。

除了这些情况之外，仅检查子句中第一个标记且后面不跟“=”或“:”的简单符号，以查看它们是否是指令关键字。您可以在子句中的其他位置自由使用这些符号，而无需将它们视为关键字。

雷克斯的评论

注释用于记录您的代码。单行注释通过在行中的任意位置使用 /* */ 来标识。

一个例子如下 -

/* 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 - 数据类型

在任何编程语言中，都需要使用各种变量来存储各种类型的信息。变量只不过是用于存储值的保留内存位置。这意味着当您创建变量时，您会在内存中保留一些空间来存储与该变量关联的值。

您可能想要存储各种数据类型的信息，如字符串、字符、宽字符、整数、浮点、布尔值等。操作系统根据变量的数据类型分配内存并决定保留的内容可以存储记忆。

内置数据类型

Rexx 提供多种内置数据类型。以下是 Rexx 中定义的数据类型列表。

• 整数- 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字必须介于 -2147483648 和 2147483647 之间（包含 -2147483648 和 2147483647）。

• 大整数- 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字必须介于 -9223372036854775808 和 2147483648（含）之间，或者介于 2147483648 和 9223372036854775807 之间。

• 十进制- 它将采用以下格式之一 -

  • 包含小数点但不包含指数标识符的数字字符串。p表示精度，s表示字符串表示的十进制数的小数位数。第一个字符可以是加号 (+) 或减号 (-)。

  • 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字小于-9223372036854775808或大于9223372036854775807。

• Float - 表示科学计数法中的数字的字符串。该字符串由一系列数字后跟指数标识符（E 或 e 后跟可选的加号 (+) 或减号 (-) 以及一系列数字）组成。该字符串可以以加号 (+) 或减号 (-) 开头。

• String - 普通字符串。

以下是如何使用每种数据类型的一些示例。同样，每种数据类型将在后续章节中详细讨论。这只是为了让您快速了解上述数据类型的简要描述。

整数

以下程序显示了如何使用数字数据类型的示例。该程序显示 2 个整数的加法。

例子

/* 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 个大整数相加。

例子

/* 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

十进制

以下程序显示了 Rexx 处理十进制数的能力。该程序展示了如何添加 2 个小数。

例子

/* 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 

漂浮

以下示例展示了数字如何作为浮点数工作。

例子

/* 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

细绳

以下程序显示了如何使用元组数据类型的示例。

这里我们定义一个有 3 项的元组 P。tuple_size是 Rexx 中定义的内置函数，可用于确定元组的大小。

例子

/* Main program */ 
display("hello")  

exit 
display:  

parse arg a 
say a

上述程序的输出将是 -

hello

Rexx - 变量

在 Rexx 中，所有变量都与“=”语句绑定。变量名有时称为符号。它们可能由字母、数字和字符（例如 ' ）组成。！？_ '。您创建的变量名称不得以数字或句点开头。简单变量名不包含句点。包含句点的变量名称称为复合变量，代表数组或表。

以下是 Rexx 中变量的基本类型，前一章也对此进行了解释 -

• 整数- 用于表示整数或浮点数。一个例子是 10。

• 大整数- 这代表一个大整数值。

• 小数- 小数值是包含小数点但不包含指数标识符的数字字符串。

• Float - 浮点值是表示科学记数法中的数字的字符串。

• 字符串- 一系列字符定义 Rexx 中的字符串。

不同类型的变量函数

在本节中，我们将讨论变量可以执行的各种功能。

变量声明

定义变量的一般语法如下所示 -

var-name = var-value 

在哪里

• var-name - 这是变量的名称。

• var-value - 这是绑定到变量的值。

以下程序是变量声明的示例 -

例子

/* Main program */ 
X = 40 
Y = 50 
Result = X + Y 
say Result

在上面的示例中，我们有 2 个变量，一个是X，它绑定到值40，下一个是Y，它绑定到值50。另一个名为 Result 的变量绑定到X 和 Y的加法。

上述程序的输出如下 -

90

命名变量

变量名有时称为符号。它们可能由字母、数字和字符（例如“.”）组成。！？_'。您创建的变量名称不得以数字或句点开头。

如果变量尚未赋值，则称为未初始化。未初始化变量的值是变量本身的大写字母名称。

未分配变量的示例如下 -

例子

/* Main program */ 
unassignedvalue 
say unassignedvalue 

如果运行上述程序，您将得到以下输出 -

UNASSIGNEDVALUE
sh: UNASSIGNEDVALUE: command not found
     2 *-* unassignedvalue 
       >>>   "UNASSIGNEDVALUE"
       +++   "RC(127)"

变量可以多次赋值。下面的程序显示了如何对 X 的值进行多次赋值。

例子

/* Main program */ 
X = 40 
X = 50 
say X 

上述程序的输出如下 -

50

打印变量

使用say命令打印变量的值。以下是打印多个变量的示例。

例子

/* 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 - 操作员

运算符是告诉编译器执行特定数学或逻辑操作的符号。

Rexx 有各种类型的运算符，详细解释如下 -

• 算术运算符
• 关系运算符
• 逻辑运算符
• 按位运算符

算术运算符

Rexx 语言与任何语言一样支持普通算术运算符。以下是 Rexx 中可用的算术运算符。

显示示例

关系运算符

关系运算符允许对对象进行比较。以下是 Rexx 中可用的关系运算符。在 Rexx 中，真值用 1 表示，假值用 0 表示。

显示示例

逻辑运算符

逻辑运算符用于计算布尔表达式。以下是 Rexx 中可用的逻辑运算符。

显示示例

按位运算符

Groovy 提供了四种按位运算符。以下是 Groovy 中可用的按位运算符。

显示示例

运算符优先级

下表按优先级降序显示了 Rexx 运算符的运算符优先级。

Rexx - 数组

任何编程语言中的数组都允许您对相同类型的值列表进行分组。数组的用途在于它允许您构建相似类型值的列表，这些值可排序、可搜索且易于操作。Rexx 还允许定义数组。这些数组可以是一维或多维的。

Rexx 数组可能是稀疏的。也就是说，并非每个数组位置都必须有一个值，甚至不需要初始化。在包含数据元素的数组位置之间可以有空的数组位置或槽。或者数组可以是密集的，其中连续的数组槽都包含数据元素。

在许多编程语言中，您必须关心表中第一个条目的下标是什么。第一个数字下标是0还是1？在 Rexx 中，第一个下标是您使用的任何下标！因此，根据需要将第一个数组元素输入到位置 0 或 1。

array_name.0 = ‘first element’

或者

array_name.1 = ‘first element’

让我们看看可用于数组的不同操作。

创建数组

数组是使用与 Rexx 中的变量相同的命名约定创建的。

创建数组的一般语法如下 -

Arrayname.index = value 

在哪里

• Arrayname - 这是提供给数组的名称。

• 索引- 这是数组中引用特定元素的索引位置。

• 值- 这是分配给数组中索引元素的值。

数组声明的示例如下 -

例子

/* 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 

显示数组的值

数组的值可以通过引用数组元素的索引位置来显示。以下示例显示如何访问数组的各个元素。

例子

/* 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 - 这是需要从中复制元素的源数组。

以下程序显示了如何执行数组复制操作的示例 -

例子

/* 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 中提供的迭代语句来迭代数组的元素。如何做到这一点的示例如下 -

例子

/* 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循环用于迭代数组元素。

• 变量number_of_elements用于存储数组中元素的数量。

• 变量j用于迭代数组的每个元素。

上述程序的输出将是 -

10
20
30

二维数组

还提到我们可以在 Rexx 中构造多维数组。让我们看一个如何实现二维数组的示例。

例子

/* 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 - 循环

到目前为止，我们已经看到了以顺序方式一个接一个地执行的语句。此外，Rexx 中还提供了语句来更改程序逻辑中的控制流。然后将它们分类为我们将详细研究的控制语句流。

循环语句允许我们多次执行一条语句或一组语句。下图是大多数编程语言中循环语句的一般形式。

让我们讨论 Rexx 支持的各种循环。

受控重复

do 循环可以满足执行语句的受控重复。

句法

此类语句的一般语法如下。

do index = start [to limit] [by increment] [for count] 
statement #1 
statement #2 
end 

该语句的不同之处在于有一个索引，用于控制循环执行的次数。其次，有一些参数规定索引应该从哪个值开始，应该在哪里结束以及增量值是多少。

流程图

让我们看看这个循环的流程图 -

从上图中可以清楚地看到循环是根据索引值执行的以及索引值如何递增。

以下程序是受控重复语句的示例。

例子

/* Main program */ 
do i = 0 to 5 by 2 
   say "hello" 
end 

在上面的程序中，首先将计数 i的值设置为 0。然后以 2 为单位递增，直到该值不大于 5。

上述代码的输出将是 -

hello 
hello 
hello 

Rexx - 决策

决策结构要求程序员指定一个或多个由程序评估或测试的条件。

下图显示了大多数编程语言中典型决策结构的一般形式。

如果条件被确定为true ，则有一个或多个语句要执行，并且可选地，如果条件被确定为false ，则要执行其他语句。

让我们看看 Rexx 中可用的各种决策语句。

嵌套 If 语句

有时需要将多个 if 语句相互嵌入，这在其他编程语言中是可能的。在 Rexx 中这也是可能的。

句法

if (condition1) then 
   do 
      #statement1 
   end 
else 
   if (condition2) then 
      do 
      #statement2 
   end

流程图

嵌套if语句的流程图如下 -

让我们以嵌套if语句为例-

例子

/* 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 语句的输出执行表达式。

句法

该声明的一般形式是 -

select 
when (condition#1) then 
statement#1 

when (condition#2) then 
statement#2 
otherwise 

defaultstatement 
end 

该声明的一般工作原理如下 -

• select 语句有一系列when 语句来评估不同的条件。

• 每个when 子句都有一个不同的条件，需要对其进行评估并执行后续语句。

• else 语句用于在前面的 when 条件不计算为 true时运行任何默认语句。

流程图

select语句的流程图如下

以下程序是 Rexx 中 case 语句的示例。

例子

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

当涉及到数字时，Rexx 具有以下数据类型。

• 整数- 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字必须介于 -2147483648 和 2147483647 之间（包含 -2147483648 和 2147483647）。

• 大整数- 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字必须介于 -9223372036854775808 和 2147483648（含）之间，或者介于 2147483648 和 9223372036854775807 之间。

• 十进制- 以下格式之一 -

  • 包含小数点但不包含指数标识符的数字字符串，其中p表示精度，s表示字符串表示的十进制数的小数位数。第一个字符可以是加号 (+) 或减号 (-)。

  • 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字小于-9223372036854775808或大于9223372036854775807。

• Float - 表示科学计数法中的数字的字符串。该字符串由一系列数字后跟指数标识符（E 或 e 后跟可选的加号 (+) 或减号 (-) 以及一系列数字）组成。该字符串可以以加号 (+) 或减号 (-) 开头。

现在让我们看看可用于 number 的不同方法。

Rexx - 弦乐

Rexx 中的字符串由字符序列表示。以下程序是字符串的示例 -

/* Main program */ 
a = "This is a string" 
say a

上述程序的输出如下 -

This is a string 

让我们讨论一下 Rexx 中可用于字符串的一些方法。

Rexx - 功能

Rexx 中的代码通常分为函数和子例程。使用函数有助于将代码分成更多的逻辑单元。让我们详细看看这些函数。

定义函数

函数声明的语法如下 -

FunctionName: 
PARSE ARG arguement1, arguement2… arguementN 
Return value 

在哪里，

• FunctionName - 这是分配给函数的名称。

• PARSE ARG - 这些是 Rexx 中的关键字，用于提及参数正在传递给函数。

• argument1, argument2... argumentN - 这些是传递给函数的参数。

• 返回值- 这是函数返回的值。

以下程序是如何在 Rexx 中使用函数的简单示例。

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 
return a + b 

上述程序应注意以下事项 -

• 我们正在定义一个名为 add 的函数，它接受 2 个参数 a 和 b。

• 该函数使用 return 语句返回 a 和 b 的和。

• 必须使用 exit 语句来表示主程序的结束。

上述程序的输出如下 -

11

使用参数

在 Rexx 中，有一些特定的函数可以与参数一起使用。让我们看几个这样的论点。

精氨酸

此方法用于返回为函数定义的参数数量。

语法-

arg() 

参数- 无

返回值- 此方法返回为函数定义的参数数量。

示例-

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 

say arg() 
return a + b 

输出- 当我们运行上面的程序时，我们将得到以下结果。

2 
11 

参数（索引）

该方法用于返回特定位置处参数的值。

语法-

arg(index)

参数-

• Index - 要返回的参数的索引位置。

返回值- 此方法返回特定位置处的参数值。

示例-

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 

say arg(1) 
return a + b 

输出- 当我们运行上面的程序时，我们将得到以下结果。

5 
11 

递归函数

递归函数或例程是调用自身的函数或例程。任何递归函数都可以以传统的非递归方式（或迭代）进行编码，但有时递归提供了更好的问题解决方案。并非所有编程语言都支持递归；雷克斯确实如此。

让我们看一下在 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 - 堆栈

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

让我们看一个堆栈的例子。

/* 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 提供了更简单的类来为文件提供以下功能。

• 读取文件
• 写入文件
• 查看文件是文件还是目录

Rexx 中用于文件 I/O 的可用函数基于行输入和字符输入，我们将详细了解这两种输入的可用函数。

让我们探讨一下 Rexx 提供的一些文件操作。出于这些示例的目的，我们假设有一个名为NewFile.txt的文件，其中包含以下文本行 -

示例1

例2

例3

该文件将用于以下示例中的读写操作。在这里我们将讨论如何以不同的方式读取文件的内容。

一次一行读取文件的内容

对文件的一般操作是通过使用 Rexx 库本身提供的方法来执行的。文件的读取是 Rexx 中所有操作中最简单的。

让我们看一下用于完成此操作的函数。

亚麻

此方法返回文本文件中的一行。文本文件是作为函数的输入参数提供的文件名。

语法-

linein(filename) 

参数-

• filename - 这是需要读取行的文件的名称。

返回值- 此方法一次返回文件的一行。

示例-

/* Main program */ 
line_str = linein(Example.txt) 
say line_str

上面的代码非常简单，因为Example.txt文件名被提供给linein 函数。然后，该函数读取一行文本并将结果提供给变量line_str。

输出- 当我们运行上面的程序时，我们将得到以下结果。

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变量保存当前行的值。然后将其作为输出发送到控制台。

输出- 当我们运行上面的程序时，我们将得到以下结果。

Example1 
Example2 
Example3 

将内容写入文件

就像读取文件一样，Rexx 也具有写入文件的能力。让我们看一下用于完成此操作的函数。

线路输出

此方法将一行写入文件。需要写入该行的文件作为 lineout 语句的参数提供。

语法-

lineout(filename) 

参数-

• filename - 这是需要写入该行的文件的名称。

返回值- 此方法返回 lineout 函数的状态。如果该行写入成功，则返回值为 0，否则返回值 1。

示例-

/* Main program */ 
out = lineout(Example.txt,"Example4") 

输出- 每当运行上述代码时，“Example4”行将被写入文件Example.txt中。

Rexx - 文件函数

在本章中，我们将讨论可用于文件的一些其他功能。

Rexx - 子程序

在任何编程语言中，整个程序都被分成逻辑模块。这使得编写易于维护的代码变得更加容易。这是任何编程语言的基本要求。

在 Rexx 中，可以使用子例程和函数来编写模块。让我们详细看看子程序。

定义子程序

函数声明的语法如下 -

FunctionName: 
   Statement#1 
   Statement#2 
   …. 
   Statement#N

在哪里，

• FunctionName - 这是分配给子例程的名称。

• Statement#1 .. Statement#N - 这些是组成子例程的语句列表。

下面的程序是一个简单的例子，展示了子例程的使用。

/* Main program */ 
call add 
exit 
add: 
a = 5 
b = 10 
c = a + b 
say c 

上述程序应注意以下事项 -

• 我们正在定义一个名为add的子例程。

• 该子例程执行简单的添加功能。

• 必须使用 exit 语句来表示主程序的结束。

上述程序的输出如下 -

15

使用参数

也可以在 Rexx 中使用参数。以下示例展示了如何实现这一点。