欣快感 - 快速指南

---

欣快感 - 概述

Euphoria代表使用分层对象进行最终用户编程以实现鲁棒解释应用程序。_ Euphoria 的第一个版本是由 Robert Craig 在 Atari Mega-ST 上创建的，并于 1993 年首次发布。现在由 Rapid Deployment Software 维护。

它是一种免费、简单、灵活、易于学习和解释性但速度极快的 32 位高级编程语言，适用于 DOS、Windows、Linux、FreeBSD 等。

Euphoria 用于开发 Windows GUI 程序、高速 DOS 游戏和 Linux/FreeBSD X Windows 程序。Euphoria 还可用于 CGI（基于 Web）编程。

欣快感特征

以下是 Euphoria 的主要功能列表 -

• 它是一种简单、灵活、强大的语言定义，易于学习和使用。

• 它支持动态存储分配，这意味着变量可以增长或缩小，而程序员不必担心分配和释放内存。它会自动处理垃圾收集。

• 它比 Perl 和 Python 等传统解释器要快得多。

• Euphoria 程序可以在 Linux、FreeBSD、32 位 Windows 和任何 DOS 环境下运行。

• Euphoria 程序不受任何 640K 内存限制。

• 它提供了一个优化的 Euphoria-To-C 转换器，您可以使用它将 Euphoria 程序转换为 C，然后使用 C 编译器对其进行编译以获得可执行 (.exe) 文件。这可以将你的程序速度提高 2 到 5 倍。

• 底层硬件是完全隐藏的，这意味着程序不知道字长、值的底层位级表示、字节顺序等。

• Euphoria 安装附带了全屏源调试器、执行分析器和全屏多文件编辑器。

• 它支持运行时错误处理、下标和类型检查。

• 它是一种开源语言，并且完全免费。

平台要求

Euphoria 可在 Windows、Linux、FreeBSD 和 OSX 上使用。这是以下平台所需的最低版本 -

• WIN32 版本- 您需要 Windows 95 或任何更高版本的 Windows。它在 XP 和 Vista 上运行良好。

• Linux 版本- 您需要任何具有 libc6 或更高版本的合理最新的 Linux 发行版。例如，Red Hat 5.2 或更高版本可以正常工作。

• FreeBSD 版本- 您需要任何合理的最新 FreeBSD 发行版。

• Mac OS X 版本- 您需要任何基于 Intel 的最新 Mac。

欣快感的局限性

以下是 Euphoria 的一些突出局限性 -

• 尽管 Euphoria 对程序员来说足够简单、快速和灵活；它不为许多重要功能提供呼叫支持。例如网络编程。

• Euphoria 于 1993 年发明，但你仍然找不到任何关于这种语言的书籍。该语言的可用文档也并不多。

但如今，该语言正在快速流行，您可以希望很快就会有针对该语言的优秀实用程序和书籍。

幸福感许可

该产品是免费且开源的，并且受益于许多人的贡献。您拥有完全免版税的权利来分发您开发的任何 Euphoria 程序。

图标文件（例如 euphoria.ico 和 euphoria\bin 中提供的二进制文件）可能会在经过或不经过您的更改后进行分发。

您可以隐藏或绑定您的程序并免版税分发生成的文件。当您使用 Euphoria-To-C 转换器时，一些额外的^{第三方法律限制可能适用。}

慷慨的 开源许可证 允许 Euphoria 用于个人和商业目的。与许多其他开源许可证不同，您的更改不必开源。

欣快感 - 环境

本章介绍了 Euphoria 在各种平台上的安装。您可以按照以下步骤在 Linux、FreeBSD 和 32 位 Windows 上安装 Euphoria。因此，您可以根据您的工作环境选择步骤。

Linux，免费 BSD 安装

官方网站提供了.tar.gz文件来在 Linux 或 BSD 操作系统上安装 Euphoria。您可以从其官方网站下载最新版本的 Euphoria -下载 Euphoria。

获得 .tar.gz 文件后，执行以下三个简单步骤即可在 Linux 或 Free BSD 计算机上安装 Euphoria -

步骤 1 - 安装文件

将下载的文件euphoria-4.0b2.tar.gz解压到要安装 Euphoria 的目录中。如果您想将其安装在 /home 目录中，如下所示：

$cp euphoria-4.0b2.tar.gz /home
$cd /home
$gunzip euphoria-4.0b2.tar.gz
$tar -xvf euphoria-4.0b2.tar

这将在/home/euphoria-4.0b2目录内创建一个目录层次结构，如下所示 -

$ls -l
-rw-r--r-- 1 1001 1001 2485 Aug 17 06:15 Jamfile
-rw-r--r-- 1 1001 1001 5172 Aug 20 12:37 Jamrules
-rw-r--r-- 1 1001 1001 1185 Aug 13 06:21 License.txt
drwxr-xr-x 2 1001 1001 4096 Aug 31 10:07 bin
drwxr-xr-x 7 1001 1001 4096 Aug 31 10:07 demo
-rw-r--r-- 1 1001 1001 366 Mar 18 09:02 file_id.diz
drwxr-xr-x 4 1001 1001 4096 Aug 31 10:07 include
-rw-r--r-- 1 1001 1001 1161 Mar 18 09:02 installu.doc
drwxr-xr-x 4 1001 1001 4096 Aug 31 10:07 source
drwxr-xr-x 19 1001 1001 4096 Sep 7 12:09 tests
drwxr-xr-x 2 1001 1001 4096 Aug 31 10:07 tutorial

注意- 文件名 euphoria-4.0b2.tar.gz 取决于可用的最新版本。我们在本教程中使用该语言的 4.0b2 版本。

第 2 步- 设置路径

安装 Euphoria 后，您需要设置正确的路径，以便 shell 可以找到所需的 Euphoria 二进制文件和实用程序。在继续之前，您需要设置以下三个重要的环境变量 -

• 将 PATH 环境变量设置为指向 /home/euphoria-4.0b2/bin 目录。

• 将 EUDIR 环境变量设置为指向 /home/euphoria-4.0b2。

• 将 EUINC 环境变量设置为指向 /home/euphoria-4.0b2/include。

这些变量可以设置如下 -

$export PATH=$PATH:/home/euphoria-4.0b2/bin
$export EUDIR=/home/euphoria-4.0b2
$export EUINC=/home/euphoria-4.0b2/include

注意- 上述用于设置环境变量的命令可能会有所不同，具体取决于您的 Shell。我们使用bash shell 执行这些命令来设置变量。

步骤 3 - 确认安装

确认Euphoria是否安装成功。

执行以下命令 -

$eui -version

如果得到如下结果，则说明Euphoria安装成功；否则你必须返回并再次检查所有步骤。

$eui -version
Euphoria Interpreter 4.0.0 beta 2 (r2670) for Linux
Using System Memory
$

就这样，Euphoria 编程环境已在您的 UNIX 计算机上准备就绪，您可以通过简单的步骤开始编写复杂的程序。

WIN32和DOS安装

官方网站提供了.exe文件来在 WIN32 或 DOS 操作系统上安装 Euphoria。您可以从其官方网站下载最新版本的 Euphoria -下载 Euphoria。

获得 .exe 文件后，请遵循以下三个简单步骤，在 WIN32 或 DOS 计算机上安装 Euphoria 编程语言 -

步骤 1 - 安装文件

双击下载的.exe安装程序以安装所有文件。我们下载了 euphoria-40b2.exe 文件进行安装。

文件名 euphoria-40b2.exe 取决于可用的最新版本。我们使用该语言的版本 4 beta 2。

默认情况下，Euphoria 将安装在 C:\ euphoria-40b2目录中，但您也可以选择所需的位置。

步骤 2 - 重新启动机器

重新启动机器以完成安装。

步骤 3 - 确认安装

确认Euphoria是否安装成功。

执行以下命令 -

c:\>eui -version

如果得到如下结果，则说明Euphoria安装成功；否则你必须返回并再次检查所有步骤。

c:\>eui -version
Euphoria Interpreter 4.0.0 beta 2 (r2670) for Windows
Using Managed Memory

c:\>

就这样，Euphoria 编程环境已经在您的 WIN32 机器上准备好了，您可以通过简单的步骤开始编写复杂的程序。

欣快感翻译员

根据您使用的平台，Euphoria 有多个解释器 -

• 主要解释器是eui。

• 在 Windows 平台上，您有两种选择。如果运行eui，则会创建一个控制台窗口。如果运行euiw，则不会创建控制台，使其适合 GUI 应用程序。

• Euphoria 并不关心您选择的文件扩展名。然而按照惯例；基于控制台的应用程序带有.ex扩展名。

• 基于 GUI 的应用程序具有.exw扩展名，包含文件具有.e扩展名。

Euphoria - 基本语法

Euphoria 语言与 Perl、C 和 Java 有许多相似之处。然而，这些语言之间存在一些明显的差异。本章旨在让您快速掌握 Euphoria 中所需的语法。

本教程假设您使用的是 Linux，并且所有示例都是在 Linux 平台上编写的。但观察发现Linux和WIN32上的程序语法没有任何显着差异。因此，您可以在 WIN32 上执行相同的步骤。

第一个欣快计划

让我们在脚本中编写一个简单的 Euphoria 程序。在 test.ex 文件中键入以下源代码并保存。

#!/home/euphoria-4.0b2/bin/eui

puts(1, "Hello, Euphoria!\n")

假设 Euphoria 解释器位于/home/euphoria-4.0b2/bin/目录中。现在运行该程序如下 -

$ chmod +x test.ex    # This is to make file executable
$ ./test.ex

这会产生以下结果 -

Hello, Euphoria!

该脚本使用内置函数put()，它接受两个参数。第一个参数表示文件名或设备号，第二个参数表示要打印的字符串。这里1表示STDOUT设备。

欣快感标识符

Euphoria 标识符是用于标识变量、函数、类、模块或其他对象的名称。标识符以字母 A 到 Z 或 a 到 z 开头，后跟字母、数字或下划线。

Euphoria 不允许在标识符中使用标点符号，例如 @、$ 和 %。

Euphoria 是一种区分大小写的编程语言。因此，Manpower和manpower在 Euphoria 中是两个不同的标识符。例如，有效的标识符是 -

• n
• 颜色26
• 希尔排序
• 快速排序
• 非常长的标识符

保留字

以下列表显示了 Euphoria 中的保留字。这些保留字不得用作常量、变量或任何其他标识符名称。Euphoria 关键字仅包含小写字母。

表达式

Euphoria 允许您通过形成表达式来计算结果。然而，在 Euphoria 中，您可以使用一个表达式对整个数据序列执行计算。

您可以像处理单个数字一样处理序列。它可以被复制、传递给子例程或作为一个单元进行计算。例如 -

{1,2,3} + 5

该表达式将序列 {1, 2, 3} 与Atomics 5 相加，得到结果序列 {6, 7, 8}。您将在后续章节中学习序列。

代码块

程序员在学习 Euphoria 时遇到的第一个警告是，没有大括号来指示过程和函数定义或流程控制的代码块。代码块由关联的关键字表示。

以下示例显示if...then...end if块 -

if condition then
   code block comes here
end if

多行语句

Euphoria 中的语句通常以换行结束。然而，Euphoria 确实允许在多行中编写一条语句。例如 -

total = item_one + 
   item_two + 
   item_three

逃脱角色

可以使用反斜杠输入转义字符。例如 -

下表是可以用反斜杠表示法表示的转义字符或不可打印字符的列表。

欣快感的评论

任何注释都会被编译器忽略，并且不会影响执行速度。建议在程序中使用更多注释以使其更具可读性。

评论文本有三种形式 -

• 注释以两个破折号开始，并延伸到当前行的末尾。

• 多行格式注释保留在 /*...*/ 内，即使它出现在不同的行上。

• 您可以使用以两个字符序列“#!”开头的特殊注释。仅在程序的第一行。

例子

#!/home/euphoria-4.0b2/bin/eui
-- First comment
puts(1, "Hello, Euphoria!\n") -- second comment

/* This is a comment which extends over a number
   of text lines and has no impact on the program
*/

这会产生以下结果 -

Hello, Euphoria!

注意- 您可以使用以“#!”开头的特殊注释。这会通知 Linux shell 您的文件应该由 Euphoria 解释器执行。

欣快感 - 变量

变量只不过是用于存储值的保留内存位置。这意味着当您创建变量时，您会在内存中保留一些空间。

根据变量的数据类型，解释器分配内存并决定可以在保留内存中存储什么。因此，通过为变量分配不同的数据类型，您可以在这些变量中存储整数、小数或字符。Euphoria 数据类型在不同的章节中进行了解释。

这些内存位置称为变量，因为它们的值在其生命周期内可以更改。

变量声明

Euphoria 变量必须显式声明以保留内存空间。因此，在为变量赋值之前必须先声明变量。

变量声明有一个类型名称，后跟所声明的变量列表。例如 -

integer x, y, z

sequence a, b, x

声明变量时，您可以为该变量命名，并定义在程序执行期间可以合法地将哪种值分配给该变量。

声明变量的简单Behave不会为其分配任何值。如果您在给它赋值之前尝试读取它，Euphoria 将发出运行时错误，因为“变量 xyz 从未被赋值”。

赋值

等号 (=) 用于给变量赋值。可以通过以下方式分配变量 -

变量名称 = 变量值

例如 -

#!/home/euphoria/bin/eui

-- Here is the declaration of the variables.
integer counter
integer miles
sequence name

counter = 100 -- An integer assignment
miles = 1000.0 -- A floating point
name = "John" -- A string ( sequence )

printf(1, "Value of counter %d\n", counter )
printf(1, "Value of miles %f\n", miles )
printf(1, "Value of name %s\n", {name} )

这里 100、1000.0 和“John”分别是分配给counter、miles和name变量的值。该程序产生以下结果 -

Value of counter 100
Value of miles 1000.000000
Value of name John

为了防止忘记初始化变量，也因为它可以使代码更清晰易读，您可以结合声明和赋值 -

integer n = 5

这相当于以下内容 -

integer n
n = 5

标识符范围

标识符的范围是对哪些代码可以访问它的描述。与标识符相同范围内的代码可以访问该标识符，而与标识符不在同一范围内的代码则无法访问该标识符。

变量的范围取决于声明它的位置和方式。

• 如果它是在for、while、loop或switch中声明的，则其作用域从声明开始，到相应的结束语句结束。

• 在if语句中，作用域从声明开始，到下一个else、elsif或end if语句结束。

• 如果在例程中声明变量，则变量的范围从声明开始，到例程的结束语句结束。这被称为私有变量。

• 如果变量是在例程外部声明的，则其作用域从声明处开始，到声明它的文件末尾结束。这称为模块变量。

• 没有作用域修饰符的常量的作用域从声明开始，到声明它的文件末尾结束。

• 没有范围修饰符的枚举的范围从声明开始，到声明它的文件末尾结束。

• 所有没有作用域修饰符的过程、函数和类型的作用域从源文件的开头开始，到声明它们的源文件的末尾结束。

没有作用域修饰符的常量、枚举、模块变量、过程、函数和类型被称为局部变量。但是，这些标识符可以在其声明之前有一个作用域修饰符，这会导致它们的作用域扩展到声明它们的文件之外。

• 如果关键字global位于声明之前，则这些标识符的范围将扩展到整个应用程序。可以通过应用程序文件中任何位置的代码访问它们。

• 如果关键字public在声明之前，则范围将扩展到任何显式包含声明标识符的文件的文件，或任何包含public包含包含公共声明的文件的文件的文件。

• 如果关键字export位于声明之前，则范围仅扩展到直接包含声明标识符的文件的任何文件。

当您在另一个文件中包含Euphoria 文件时，执行include 的文件只能访问使用范围修饰符声明的标识符。包含文件中的其他声明对于执行include的文件是不可见的。

欣快感 - 常量

常量也是被赋予初始值的变量，该初始值在程序的生命周期中永远不会改变。Euphoria 允许使用 Constant 关键字定义常量，如下所示 -

constant MAX = 100
constant Upper = MAX - 10, Lower = 5
constant name_list = {"Fred", "George", "Larry"}

任何表达式的结果都可以分配给常量，即使是涉及调用先前定义的函数的表达式，但一旦进行分配，常量变量的值就被“锁定”。

不能在子例程内声明常量。没有作用域修饰符的常量的作用域从声明开始，到声明它的文件末尾结束。

例子

#!/home/euphoria-4.0b2/bin/eui

constant MAX = 100
constant Upper = MAX - 10, Lower = 5

printf(1, "Value of MAX %d\n", MAX )
printf(1, "Value of Upper %d\n", Upper )
printf(1, "Value of Lower %d\n", Lower )

MAX = MAX + 1
printf(1, "Value of MAX %d\n", MAX )

这会产生以下错误 -

./test.ex:10
<0110>:: may not change the value of a constant
MAX = MAX + 1
   ^

Press Enter

如果从示例中删除最后两行，则会产生以下结果 -

Value of MAX 100
Value of Upper 90
Value of Lower 5

枚举_

枚举值是一种特殊类型的常量，其中第一个值默认为数字 1，之后的每一项都递增 1。枚举只能采用数字值。

枚举不能在子例程内声明。没有范围修饰符的枚举的范围从声明开始，到声明它的文件末尾结束。

例子

#!/home/euphoria-4.0b2/bin/eui

enum ONE, TWO, THREE, FOUR

printf(1, "Value of ONE %d\n", ONE )
printf(1, "Value of TWO %d\n", TWO )
printf(1, "Value of THREE %d\n", THREE )
printf(1, "Value of FOUR %d\n", FOUR )

这将产生以下结果 -

Value of ONE 1
Value of TWO 2
Value of THREE 3
Value of FOUR 4

您可以通过为其指定数值来更改任何一项的值。后续值始终是前一个值加一，除非它们也被分配了默认值。

#!/home/euphoria-4.0b2/bin/eui

enum ONE, TWO, THREE, ABC=10, XYZ

printf(1, "Value of ONE %d\n", ONE )
printf(1, "Value of TWO %d\n", TWO )
printf(1, "Value of THREE %d\n", THREE )
printf(1, "Value of ABC %d\n", ABC )
printf(1, "Value of XYZ %d\n", XYZ )

这会产生以下结果 -

Value of ONE 1
Value of TWO 2
Value of THREE 3
Value of ABC 10
Value of XYZ 11

序列使用整数索引，但使用枚举，您可以编写如下代码 -

enum X, Y
sequence point = { 0,0 }

point[X] = 3
point[Y] = 4

Euphoria - 数据类型

存储在内存中的数据可以有多种类型。例如，一个人的年龄存储为数值，而他或她的地址存储为字母数字字符。

Euphoria 有一些标准类型，用于定义它们可能进行的操作以及每种类型的存储方法。

Euphoria 有以下四种标准数据类型 -

• 整数
• Atomics
• 顺序
• 目的

对Atomics和序列的理解是理解 Euphoria 的关键。

整数

Euphoria 整数数据类型存储数值。它们的声明和定义如下 -

integer var1, var2

var1 = 1
var2 = 100

使用整数类型声明的变量必须是整数值从 -1073741824 到 +1073741823 之间的Atomics。您可以对较大的整数值（最多大约 15 位十进制数字）执行精确计算，但将它们声明为Atomics而不是整数。

Atomics

Euphoria 中的所有数据对象要么是Atomics，要么是序列。Atomics是单个数值。Atomics可以具有任何整数或双精度浮点值。Euphoria Atomics的声明和定义如下：

atom var1, var2, var3

var1 = 1000
var2 = 198.6121324234
var3 = 'E'       

Atomics的范围约为 -1e300 到 +1e300，精确到 15 位小数。单个字符是必须使用单引号输入的Atomics。例如，以下所有陈述都是合法的 -

-- Following is equivalent to the atom 66 - the ASCII code for B
char = 'B'

-- Following is equivalent to the sequence {66}
sentence = "B"

序列

序列是可以通过索引访问的数值的集合。Euphoria 中的所有数据对象要么是Atomics，要么是序列。

序列索引从 1 开始，与其他编程语言的数组索引从 0 开始不同。Euphoria 序列的声明和定义如下 -

sequence var1, var2, var3, var4

var1 = {2, 3, 5, 7, 11, 13, 17, 19}
var2 = {1, 2, {3, 3, 3}, 4, {5, {6}}}
var3 = {{"zara", "ali"}, 52389, 97.25}     
var4 = {} -- the 0 element sequence

字符串只是可以使用双引号输入的字符序列。例如，以下所有陈述都是合法的 -

word = 'word'
sentence = "ABCDEFG"

字符串可以像任何其他序列一样被操纵和操作。例如，上面的字符串完全等同于序列 -

sentence = {65, 66, 67, 68, 69, 70, 71}

您将在Euphoria - Sequences中了解有关序列的更多信息。

对象

这是 Euphoria 中的超级数据类型，可以采用任何值，包括Atomics、序列或整数。Euphoria 对象的声明和定义如下 -

object var1, var2, var3

var1 = {2, 3, 5, 7, 11, 13, 17, 19}
var2 = 100
var3 = 'E'     

对象可能具有以下值之一 -

• 一个序列

• 一个Atomics

• 一个整数

• 用作文件编号的整数

• 字符串序列或单字符Atomics

Euphoria - 操作员

Euphoria 提供了一组丰富的运算符来操作变量。我们可以将所有 Euphoria 运算符分为以下几组 -

• 算术运算符
• 关系运算符
• 逻辑运算符
• 赋值运算符
• 杂项运算符

算术运算符

算术运算符在数学表达式中的使用方式与在代数中的使用方式相同。下表列出了算术运算符。假设整数变量 A 为 10，变量 B 为 20，则 -

显示示例

关系运算符

Euphoria 语言支持以下关系运算符。假设变量 A 为 10，变量 B 为 20，则 -

显示示例

逻辑运算符

下表列出了逻辑运算符。假设布尔变量 A 为 1，变量 B 为 0，则 -

显示示例

您还可以将这些运算符应用于 1 或 0 以外的数字。约定是：零表示 false，非零表示true。

赋值运算符

Euphoria 语言支持以下赋值运算符 -

显示示例

注意- 赋值语句中使用的等号“=”不是运算符，它只是语法的一部分。

杂项运算符

Euphoria 语言支持的其他运算符很少。

运营商

任意两个对象可以使用“&”运算符连接。结果是一个长度等于连接对象长度之和的序列。

例如 -

#!/home/euphoria-4.0b2/bin/eui

sequence a, b, c
a = {1, 2, 3}
b = {4}
c = {1, 2, 3} & {4}

printf(1, "Value of c[1] %d\n", c[1] )
printf(1, "Value of c[2] %d\n", c[2] )
printf(1, "Value of c[3] %d\n", c[3] )
printf(1, "Value of c[4] %d\n", c[4] )

这会产生以下结果 -

Value of c[1] 1
Value of c[2] 2
Value of c[3] 3
Value of c[4] 4

Euphoria 运算符的优先级

运算符优先级决定表达式中术语的分组。这会影响表达式的计算方式。某些运算符的优先级高于其他运算符；例如，乘法运算符的优先级高于加法运算符。

例如，x = 7 + 3 * 2

此处，x 被分配为 13，而不是 20，因为运算符 * 的优先级高于 +。

因此它首先从 3*2 开始，然后添加到 7。

这里优先级最高的运算符出现在表的顶部，优先级最低的运算符出现在底部。在表达式中，首先计算优先级较高的运算符。

欣快感 - 分支

分支是任何编程语言最重要的方面。在编写程序时，您可能会遇到必须做出决定或必须从给定的多个选项中选择一个选项的情况。

下图显示了一个简单的场景，其中程序需要根据给定条件采用两条路径之一。

Euphoria 提供以下三种类型的决策（分支或条件）语句 -

• if 语句

• switch语句

• ifdef 语句

让我们详细看看这些陈述 -

Euphoria - 循环类型

循环是任何编程语言的另一个最重要的方面。在编写程序时，您可能会遇到必须多次执行同一条语句的情况，有时可能会执行无限次。

有多种方法可以指定该过程应该持续多长时间，以及如何停止或以其他方式改变它。迭代块可以非正式地称为循环，循环中代码的每次执行称为循环的迭代。

下图显示了循环的简单逻辑流程 -

Euphoria 提供以下三种类型的循环语句 -

• while 语句

• 循环直到语句

• 对于声明

以上所有说明为您提供了根据不SymPy况的灵活性和易用性。让我们一一详细看看它们 -

Euphoria - 流量控制

程序执行流程是指程序语句的执行顺序。默认情况下，语句会依次执行。

然而; 很多时候，需要更改默认顺序的执行顺序才能完成任务。

Euphoria 有许多流程控制语句，您可以使用它们来安排语句的执行顺序。

退出声明_

退出循环是通过关键字exit完成的。这会导致流程立即离开当前循环并在循环结束后重新开始第一个语句。

句法

exit 语句的语法如下 -

exit [ "Label Name" ] [Number]

exit语句终止最新且最内层的循环，直到指定可选标签名称或编号。

出口 N的一种特殊形式是出口 0。这会留下所有级别的循环，无论深度如何。控制在最外面的循环块之后继续。同样，exit -1 退出第二个最外面的循环，依此类推。

例子

#!/home/euphoria-4.0b2/bin/eui

integer b

for a = 1 to 16 do
   printf(1, "value of a %d\n", a)
   
   if a = 10 then
      b = a
      exit
   end if
end for

printf(1, "value of b %d\n", b)

这会产生以下结果 -

value of a 1
value of a 2
value of a 3
value of a 4
value of a 5
value of a 6
value of a 7
value of a 8
value of a 9
value of a 10
value of b 10

中断语句_

Break语句的工作方式与exit语句完全相同，但适用于 if 语句或 switch 语句，而不是任何类型的循环语句。

句法

Break 语句的语法如下 -

break [ "Label Name" ] [Number]

Break语句终止最新且最内层的 if 或 switch 块，直到指定可选标签名称或编号。

中断 N的一种特殊形式是中断 0。无论深度如何，这都会留下最外面的 if 或 switch 块。控制在最外面的块之后继续。同样，break -1 会中断第二个最外面的 if 或 switch 块，依此类推。

例子

#!/home/euphoria-4.0b2/bin/eui

integer a, b
sequence s = {'E','u', 'p'}

if s[1] = 'E' then
   a = 3
   
   if s[2] = 'u' then
      b = 1
      if s[3] = 'p' then
         break 0 -- leave topmost if block
      end if
      a = 2
   else
      b = 4
   end if
else
   a = 0
   b = 0
end if

printf(1, "value of a %d\n", a)
printf(1, "value of b %d\n", b)

这会产生以下结果 -

value of a 3
value of b 1

继续语句_

continue语句通过进入下一次迭代并跳过迭代的其余部分来继续执行它所应用的循环。

进入下一次迭代意味着测试条件变量索引并检查它是否仍在范围内。

句法

continue 语句的语法如下 -

continue [ "Label Name" ] [Number]

continue语句将重新迭代最新的和最内层的循环，直到指定可选的标签名称或编号。

continue N的特殊形式是continue 0。无论深度如何，这都会重复最外层的循环。同样， continue -1 从第二个最外面的循环开始，依此类推。

例子

#!/home/euphoria-4.0b2/bin/eui

for a = 3 to 6 do
   printf(1, "value of a %d\n", a)

   if a = 4 then
      puts(1,"(2)\n")
      continue
   end if

   printf(1, "value of a %d\n", a*a)
end for
This would produce following result:

value of a 3
value of a 9
value of a 4
(2)
value of a 5
value of a 25
value of a 6
value of a 36

重试语句

retry语句通过进入下一次迭代并跳过迭代的其余部分来继续执行它所应用的循环。

句法

重试语句的语法如下 -

retry [ "Label Name" ] [Number]

retry语句重试执行它所应用的循环的当前迭代。该语句分支到指定循环的第一个语句，既不测试任何内容也不增加 for 循环索引。

重试 N的一种特殊形式是重试 0。无论深度如何，都会重试执行最外层循环。同样，retry -1 会重试第二个最外面的循环，依此类推。

通常，包含重试语句的子块还包含另一个流程控制关键字，例如 exit、continue 或 break。否则，迭代将无休止地执行。

例子

#!/home/euphoria-4.0b2/bin/eui

integer errors = 0
integer files_to_open = 10

for i = 1 to length(files_to_open) do
   fh = open(files_to_open[i], "rb")
   
   if fh = -1 then
      if errors > 5 then
         exit
      else
         errors += 1
         retry
      end if
   end if
   file_handles[i] = fh
end for

由于重试不会更改 i 的值并尝试再次打开同一文件，因此必须有一种方法可以从退出语句提供的循环中中断。

goto 语句

goto语句指示计算机在标记位置恢复代码执行。

恢复执行的地方称为语句的目标。它被限制位于当前例程中，或者当前文件（如果在任何例程之外）。

句法

goto 语句的语法如下 -

goto "Label Name"

goto 语句的目标可以是任何可访问的标签语句 -

label "Label Name"

标签名称必须是双引号常量字符串。Euphoria 标识符中的非法字符可能会出现在标签名称中，因为它是常规字符串。

例子

#!/home/euphoria-4.0b2/bin/eui

integer a = 0

label "FIRST"
printf(1, "value of a %d\n", a)
a += 10

if a < 50 then
   goto "FIRST"
end if 
printf(1, "Final value of a %d\n", a)

这会产生以下结果 -

value of a 0
value of a 10
value of a 20
value of a 30
value of a 40
Final value of a 50

Euphoria - 短路评估

当使用and或or运算符通过if、elsif、until或测试条件时，将使用短路评估。例如 -

if a < 0 and b > 0 then
   -- block of code
end if

如果 a < 0 为 false，则 Euphoria 不会费心去测试 b 是否大于 0。它知道无论如何总体结果都是 false。同样 -

if a < 0 or b > 0 then
   -- block of code
end if

如果 a < 0 为 true，则 Euphoria 立即判定结果为 true，而不测试 b 的值，因为此测试的结果是无关紧要的。

一般来说，每当您出现以下形式的情况时 -

A and B

其中 A 和 B 可以是任意两个表达式，当 A 为假时，Euphoria 会采取捷径，立即使整体结果为假，甚至不看表达式 B。

同样，每当您有以下形式的条件时 -

A or  B

当 A 为 true 时，Euphoria 会跳过表达式 B 的求值，并声明结果为 true。

and 和 or 的短路计算仅针对 if、elsif、until 和 while 条件进行。它不用于其他上下文。例如 -

x = 1 or {1,2,3,4,5} -- x should be set to {1,1,1,1,1}

如果这里使用短路，则将 x 设置为 1，甚至不查看 {1,2,3,4,5}，这是错误的。

因此，短路可以用在 if、elsif、until 或 while 条件中，因为您只需要关心结果是 true 还是 false，并且需要条件来产生一个Atomics作为结果。

欣快感 - 序列

序列由大括号 { } 中的对象列表表示，并用逗号分隔。序列可以包含Atomics和其他序列。例如 -

{2, 3, 5, 7, 11, 13, 17, 19}
{1, 2, {3, 3, 3}, 4, {5, {6}}}
{{"Zara", "Ayan"}, 52389, 97.25}
{} -- the 0-element sequence

可以通过在方括号中给出元素编号来选择序列的单个元素。元素编号从 1 开始。

例如，如果 x 包含 {5, 7.2, 9, 0.5, 13}，则 x[2] 为 7.2。

假设 x[2] 包含 {11,22,33}，现在如果你要求 x[2]，你会得到 {11,22,33}，如果你要求 x[2][3]，你会得到Atomics 33 。

例子

#!/home/euphoria-4.0b2/bin/eui

sequence x
x = {1, 2, 3, 4}

for a = 1 to length(x) do
   printf(1, "value of x[%d] = %d\n", {a, x[a]})
end for

这里，length() 是返回序列长度的内置函数。上面的例子产生以下结果 -

value of x[1] = 1
value of x[2] = 2
value of x[3] = 3
value of x[4] = 4

字符串

字符串只是一个字符序列。可以通过两种方式之一输入 -

(a) 使用双引号 -

"ABCDEFG"

(b) 使用原始字符串表示法 -

-- Using back-quotes
`ABCDEFG`

or

-- Using three double-quotes
"""ABCDEFG"""

您可以尝试以下示例来理解这个概念 -

#!/home/euphoria-4.0b2/bin/eui

sequence x
x = "ABCD"

for a = 1 to length(x) do
   printf(1, "value of x[%d] = %s\n", {a, x[a]})
end for

这会产生以下结果 -

value of x[1] = A
value of x[2] = B
value of x[3] = C
value of x[4] = D

字符串数组

可以使用序列实现字符串数组，如下所示 -

#!/home/euphoria-4.0b2/bin/eui

sequence x = {"Hello", "World", "Euphoria", "", "Last One"}

for a = 1 to length(x) do
   printf(1, "value of x[%d] = %s\n", {a, x[a]})
end for

这会产生以下结果 -

value of x[1] = Hello
value of x[2] = World
value of x[3] = Euphoria
value of x[4] =
value of x[5] = Last One

欣快感结构

可以使用序列来实现结构，如下所示 -

#!/home/euphoria-4.0b2/bin/eui

sequence employee = {
   {"John","Smith"},
      45000,
      27,
      185.5
}
printf(1, "First Name = %s, Last Name = %s\n", {employee[1][1],employee[1][2]} )

这会产生以下结果 -

First Name = John, Last Name = Smith

有多种可以直接对序列执行的操作。让我们详细看看它们 -

泌尿手术

当应用于序列时，一元运算符实际上应用于序列中的每个元素，以产生相同长度的结果序列。

#!/home/euphoria-4.0b2/bin/eui

sequence x
x = -{1, 2, 3, 4}

for a = 1 to length(x) do
   printf(1, "value of x[%d] = %d\n", {a, x[a]})
end for

这会产生以下结果 -

value of x[1] = -1
value of x[2] = -2
value of x[3] = -3
value of x[4] = -4

算术运算

几乎所有算术运算都可以在序列上执行，如下所示 -

#!/home/euphoria-4.0b2/bin/eui

sequence x, y, a, b, c
x = {1, 2, 3}
y = {10, 20, 30}

a = x + y
puts(1, "Value of a = {")

for i = 1 to length(a) do
   printf(1, "%d,", a[i])
end for
puts(1, "}\n")

b = x - y
puts(1, "Value of b = {")
for i = 1 to length(a) do
   printf(1, "%d,", b[i])
end for
puts(1, "}\n")

c = x * 3
puts(1, "Value of c = {")

for i = 1 to length(c) do
   printf(1, "%d,", c[i])
end for
puts(1, "}\n")

这会产生以下结果 -

Value of a = {11,22,33,}
Value of b = {-9,-18,-27,}
Value of c = {3,6,9,}

命令行选项

用户可以将命令行选项传递给 Euphoria 脚本，并且可以使用command_line()函数将其作为序列进行访问，如下所示 -

#!/home/euphoria-4.0b2/bin/eui

sequence x

x = command_line()

printf(1, "Interpeter Name: %s\n", {x[1]} )
printf(1, "Script Name: %s\n", {x[2]} )
printf(1, "First Argument: %s\n", {x[3]})
printf(1, "Second Argument: %s\n", {x[4]})

这里printf()是 Euphoria 的内置函数。现在，如果您按如下方式运行此脚本 -

$eui test.ex "one" "two"

这会产生以下结果 -

Interpeter Name: /home/euphoria-4.0b2/bin/eui
Script Name: test.ex
First Argument: one
Second Argument: two

Euphoria - 日期和时间

Euphoria 有一个库例程，可以将日期和时间返回给您的程序。

date ()方法

date() 方法返回一个由八个Atomics元素组成的序列值。下面的例子详细解释了它 -

#!/home/euphoria-4.0b2/bin/eui
 
integer curr_year, curr_day, curr_day_of_year, curr_hour, curr_minute, curr_second
sequence system_date, word_week, word_month, notation, 
   curr_day_of_week, curr_month
   word_week = {"Sunday", 
      "Monday", 
      "Tuesday", 
      "Wednesday", 
      "Thursday", 
      "Friday", 
      "Saturday"}
   word_month = {"January", "February", 
      "March", 
      "April", 
      "May", 
      "June", 
      "July", 
      "August", 
      "September", 
      "October", 
      "November", 
      "December"}
-- Get current system date.
system_date = date()

-- Now take individual elements
curr_year = system_date[1] + 1900
curr_month = word_month[system_date[2]]
curr_day = system_date[3]
curr_hour = system_date[4]
curr_minute = system_date[5]
curr_second = system_date[6]
curr_day_of_week = word_week[system_date[7]]
curr_day_of_year = system_date[8]

if curr_hour >= 12 then 
   notation = "p.m."
else 
   notation = "a.m."
end if

if curr_hour > 12 then 
   curr_hour = curr_hour - 12
end if

if curr_hour = 0 then 
   curr_hour = 12
end if

puts(1, "\nHello Euphoria!\n\n")
printf(1, "Today is %s, %s %d, %d.\n", {curr_day_of_week, 
   curr_month, curr_day, curr_year})

printf(1, "The time is %.2d:%.2d:%.2d %s\n", {curr_hour, 
   curr_minute, curr_second, notation})

printf(1, "It is %3d days into the current year.\n", {curr_day_of_year})

这会在您的标准屏幕上产生以下结果 -

Hello Euphoria!

Today is Friday, January 22, 2010.
The time is 02:54:58 p.m.
It is  22 days into the current year.

time ()方法

time() 方法返回一个Atomics值，表示自固定时间点以来经过的秒数。下面的例子详细解释了它 -

#!/home/euphoria-4.0b2/bin/eui
 
constant ITERATIONS = 100000000
integer p
atom t0, t1, loop_overhead

t0 = time()
for i = 1 to ITERATIONS do
   -- time an empty loop
end for

loop_overhead = time() - t0

printf(1, "Loop overhead:%d\n", loop_overhead)

t0 = time()
for i = 1 to ITERATIONS do
    p = power(2, 20)
end for

t1 = (time() - (t0 + loop_overhead))/ITERATIONS

printf(1, "Time (in seconds) for one call to power:%d\n", t1)

这会产生以下结果 -

Loop overhead:1
Time (in seconds) for one call to power:0

日期和时间相关方法

Euphoria 提供了一系列方法来帮助您操作日期和时间。Euphoria 库例程中列出了这些方法。

欣快感 - 程序

过程是一组可重用代码，可以从程序中的任何位置调用。这消除了一次又一次编写相同代码的需要。这有助于程序员编写模块化代码。

与任何其他高级编程语言一样，Euphoria 还支持使用过程编写模块化代码所需的所有功能。

您一定在前面的章节中见过像printf()和length()这样的过程。我们一次又一次地使用这些过程，但它们只在核心 Euphoria 中编写过一次。

Euphoria 还允许您编写自己的程序。本节介绍如何在 Euphoria 中编写您自己的过程。

程序定义

在使用过程之前，您需要定义它。在 Euphoria 中定义过程的最常见方法是使用procedure关键字，后跟唯一的过程名称、参数列表（可能为空）以及以end procedure语句结尾的语句块。基本语法如下所示 -

procedure procedurename(parameter-list)

   statements
   ..........

end procedure

例子

这里定义了一个名为 sayHello 的简单过程，不带任何参数 -

procedure  sayHello()
   puts(1, "Hello there")
end procedure

调用过程

要在脚本中稍后的某个位置调用过程，您只需编写该过程的名称，如下所示 -

#!/home/euphoria-4.0b2/bin/eui

procedure  sayHello()
   puts(1, "Hello there")
end procedure 

-- Call above defined procedure.
sayHello()

这会产生以下结果 -

Hello there

程序参数

到目前为止，您已经看到了不带参数的过程。但是有一种方法可以在调用过程时传递不同的参数。这些传递的参数可以在过程中捕获，并且可以对这些参数进行任何操作。

一个过程可以采用多个参数，并用逗号分隔。

例子

让我们对sayHello过程做一些修改。这次需要两个参数 -

#!/home/euphoria-4.0b2/bin/eui

procedure sayHello(sequence name,atom  age)
   printf(1, "%s is %d years old.", {name, age})
end procedure

-- Call above defined procedure.
sayHello("zara", 8)

这会产生以下结果 -

zara is 8 years old.

Euphoria - 功能

Euphoria 函数就像过程一样，但它们返回一个值，并且可以在表达式中使用。本章介绍如何在 Euphoria 中编写自己的函数。

功能定义

在使用函数之前，我们需要定义它。在 Euphoria 中定义函数的最常见方法是使用function关键字，后跟唯一的函数名称、参数列表（可能为空）以及以end function语句结尾的语句块。基本语法如下所示 -

function functionname(parameter-list)

   statements
   ..........
   return [Euphoria Object]

end function

例子

这里定义了一个名为 sayHello 的简单函数，它不带任何参数 -

function sayHello()
   puts(1, "Hello there")
   return 1
end function

调用函数

要稍后在脚本中的某个位置调用函数，您只需编写该函数的名称，如下所示 -

#!/home/euphoria-4.0b2/bin/eui

function sayHello()
   puts(1, "Hello there")
   return 1
end function

-- Call above defined function.
sayHello()

这会产生以下结果 -

Hello there

功能参数

到目前为止我们已经看到了没有参数的函数。但是有一种方法可以在调用函数时传递不同的参数。这些传递的参数可以在函数内部捕获，并且可以对这些参数进行任何操作。

一个函数可以采用多个参数，并用逗号分隔。

例子

让我们对sayHello函数做一些修改。这次需要两个参数 -

#!/home/euphoria-4.0b2/bin/eui

function sayHello(sequence name,atom  age)
   printf(1, "%s is %d years old.", {name, age})
   return 1
end function

-- Call above defined function.
sayHello("zara", 8)

这会产生以下结果 -

zara is 8 years old.

退货声明_

Euphoria 函数在关闭语句end function之前必须有return语句。任何 Euphoria 对象都可以被返回。实际上，您可以通过返回对象序列来获得多个返回值。例如

return {x_pos, y_pos}

如果没有什么可返回的，那么只需返回1或0即可。返回值1表示成功，0表示失败

Euphoria - 文件 I/O

使用 Euphoria 编程语言，您可以编写程序来读取和更改软盘驱动器或硬盘驱动器上的文件数据，或者创建新文件作为输出形式。您甚至可以访问计算机上的设备，例如打印机和调制解调器。

本章描述了 Euphoria 中可用的所有基本 I/O 功能。有关更多功能的信息，请参阅标准 Euphoria 文档。

在屏幕上显示

生成输出的最简单方法是使用put()语句，您可以在其中传递要在屏幕上显示的任何字符串。还有另一种方法printf()也可以在您必须使用动态值格式化字符串的情况下使用。

这些方法将您传递给它们的表达式转换为字符串并将结果写入标准输出，如下所示 -

#!/home/euphoria-4.0b2/bin/eui
 
puts(1, "Euphoria is really a great language, isn't it?" )

这会在您的标准屏幕上产生以下结果 -

Euphoria is really a great language, isn't it?

打开和关闭文件

Euphoria 默认提供了操作文件所需的基本方法。您可以使用以下方法进行大部分文件操作 -

• 打开（）
• 关闭（）
• 打印（）
• 获取（）
• getc()

开放式方法

在读取或写入文件之前，您必须使用 Euphoria 的内置open()方法打开它。该函数创建一个文件描述符，用于调用与其关联的其他支持方法。

句法

integer file_num = open(file_name, access_mode)

如果打开给定文件名时出现错误，上述方法将返回 -1。这是参数 -

• file_name - file_name 参数是一个字符串值，其中包含要访问的文件的名称。

• access_mode - access_mode 确定打开文件的模式。例如，读取、写入追加等。下表给出了文件打开模式的可能值的完整列表 -