Euphoria - 快速指南

Euphoria - Overview

Euphoria代表E nd- U ser P rogramming with H ierarchical O bjects for R obustinnprepreted a pplications。 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特征

以下是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 version - 您需要Windows 95或更高版本的Windows。它在XP和Vista上运行良好。
Linux version - 您需要任何合理的最新Linux发行版，它具有libc6或更高版本。例如，Red Hat 5.2或更高版本可以正常工作。
FreeBSD version - 你需要任何合理的最新FreeBSD发行版。
Mac OS X version - 您需要任何合理的最新基于Intel的Mac。

Euphoria限制

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

尽管Euphoria对于程序员来说简单，快速且灵活; 它不为许多重要功能提供呼叫支持。例如，网络编程。
Euphoria是在1993年发明的，但你仍然找不到任何关于这种语言的书。该语言的文档也不多。

但是现在，这种语言变得越来越流行，你可以希望很快就可以获得很好的语言和书籍。

Euphoria Licensing

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

图标文件，例如euphoria.ico和euphoria\bin中可用的二进制文件，可以在您进行更改时进行分发。

您可以shroud或bind您的程序，并将生成的文件免费分发。当您使用Euphoria-To-C翻译器时，可能会有一些额外的第三方法律限制。

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

Euphoria - Environment

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

Linux，免费BSD安装

官方网站提供.tar.gz文件，用于在Linux或BSD OS上安装Euphoria。您可以从其官方网站下载最新版本的Euphoria - 下载Euphoria 。

一旦你有.tar.gz文件，这里有三个简单的步骤来安装你的Linux或Free BSD机器上的Euphoria -

Step 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

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

Step 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

NOTE - 用于设置环境变量的上述命令可能因Shell而异。我们使用bash shell来执行这些命令来设置变量。

Step 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 OS上安装Euphoria。您可以从其官方网站下载最新版本的Euphoria - 下载Euphoria 。

一旦你有.exe文件，这里有三个简单的步骤来在你的WIN32或DOS机器上安装Euphoria编程语言 -

Step 1 - 安装文件

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

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

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

Step 2 - 重新启动计算机

重新启动计算机以完成安装。

Step 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口译员

根据您使用的平台，Euphoria有多个口译员 -

主要翻译是eui 。
在Windows平台上，您有两种选择。如果运行eui则会创建一个控制台窗口。如果运行euiw则不会创建任何控制台，使其适用于GUI应用程序。
Euphoria并不关心您选择的文件扩展名。按照惯例; 基于控制台的应用程序附带.ex扩展名。
基于GUI的应用程序具有.exw扩展名，包含文件具有.e扩展名。

Euphoria - Basic Syntax

Euphoria语言与Perl，C和Java有许多相似之处。但是，语言之间存在一些明显的差异。本章旨在让您快速了解Euphoria中预期的语法。

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

第一个Euphoria计划

让我们在脚本中编写一个简单的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!

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

Euphoria标识符

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

Euphoria不允许标识符中的标点符号，如@，$和％。

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

n
color26
ShellSort
quick_sort
a_very_long_indentifier

保留字 (Reserved Words)

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

and	exit	override
as	export	procedure
break	fallthru	public
by	for	retry
case	function	return
constant	global	routine
continue	goto	switch
do	if	then
else	ifdef	to
elsedef	include	type
elsif	label	until
elsifdef	loop	while
end	namespace	with
entry	not	without
enum	or	xor

Expressions

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

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

{1,2,3} + 5

这是一个表达式，它添加序列{1,2,3}和原子5以得到结果序列{6,7,8}。您将在后续章节中学习序列。

代码块

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

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

if condition then
   code block comes here
end if

Multi-Line Statements

Euphoria中的陈述通常以新的行结束。然而，Euphoria允许在多行中写出单个语句。例如 -

total = item_one + 
   item_two + 
   item_three

逃脱角色

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

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

反斜杠表示法	描述
\n	Newline
\r	Carriage return
\t	Tab
\\	Backslash
\"	双引号
\'	单引号

在Euphoria中的评论

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

评论文本有三种形式 -

注释以两个破折号开始并延伸到当前行的末尾。
多行格式注释保留在/*...*/内，即使它出现在另一行上。
您只能在程序的第一行使用以两个字符序列“＃！”开头的特殊注释。

例子 (Examples)

#!/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!

Note - 您可以使用以“＃！”开头的特殊注释。这告诉Linux shell你的文件应该由Euphoria解释器执行。

Euphoria - Variables

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

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

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

变量声明 (Variable Declaration)

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

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

integer x, y, z
sequence a, b, x

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

声明变量的简单行为不会为其赋值。如果在为其分配任何值之前尝试读取它，Euphoria将发出运行时错误，因为"variable xyz has never been assigned a value" 。

分配值

等号（=）用于为变量赋值。变量可以按以下方式分配 -

Variable_Name = Variable_Value

例如 -

#!/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声明，则其范围从声明开始，并在相应的end语句处end 。
在if语句中，作用域从声明开始，并在next else, elsif或end if语句处end if 。
如果在例程中声明了变量，则变量的范围从声明开始，并在例程的结束语句处结束。这被称为私有变量。
如果变量是在例程之外声明的，则它的作用域从声明开始，结束并声明它所声明的文件的结尾。这称为模块变量。
没有范围修饰符的constant的范围从声明和结尾开始，并在声明它的文件的末尾开始。
没有范围修饰符的enum的范围从声明和结尾开始，并在声明它的文件的末尾开始。
没有范围修饰符的所有procedures, functions和types的范围从源文件的开头开始，并在声明它们的源文件的末尾结束。

没有范围修饰符的常量，枚举，模块变量，过程，函数和类型称为locals 。但是，这些标识符在声明之前可以有一个范围修饰符，这会导致它们的范围超出它们声明的文件范围。

如果关键字global在声明之前，则这些标识符的范围将扩展到整个应用程序。可以通过应用程序文件中的任何位置访问它们。
如果关键字public在声明之前，则范围扩展到显式包含声明标识符的文件的任何文件，或扩展到包含文件的任何文件，而该文件又包含包含public声明的文件。
如果关键字export在声明之前，则范围仅扩展到直接包含声明标识符的文件的任何文件。

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

Euphoria - Constants

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

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

任何表达式的结果都可以赋值给常量，甚至包括对先前定义的函数的调用，但是一旦赋值，常量变量的值就会被“锁定”。

常量可能不会在子例程中声明。没有范围修饰符的constant的范围从声明和结尾开始，并在声明它的文件的末尾开始。

例子 (Examples)

#!/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

enums

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

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

例子 (Examples)

#!/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

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

#!/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 - Data Types

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

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

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

integer
atom
sequence
object

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

Integers

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

integer var1, var2
var1 = 1
var2 = 100

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

Atoms

Euphoria中的所有数据对象都是原子或序列。原子是单个数值。原子可以具有任何整数或双精度浮点值。 Euphoria原子的声明和定义如下 -

atom var1, var2, var3
var1 = 1000
var2 = 198.6121324234
var3 = 'E'

原子的范围可以从大约-1e300到+ 1e300，精度为15位十进制数。单个字符是必须使用单引号输入的atom 。例如，以下所有陈述都是合法的 -

-- Following is equivalent to the atom 66 - the ASCII code for B
char = 'B'
-- Following is equivalent to the sequence {66}
sentence = "B"

序列 Sequences

序列是可以通过索引访问的数值集合。 Euphoria中的所有数据对象都是原子或序列。

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

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

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

word = 'word'
sentence = "ABCDEFG"

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

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

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

Objects

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

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

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

一个序列
一个原子
整数
用作文件编号的整数
字符串序列或单字符原子

Euphoria - Operators

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

算术运算符
关系运算符
逻辑运算符
分配运算符
其它运算符

算术运算符 (The Arithmetic Operators)

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

显示示例

操作者	描述	例
+	添加 - 在运算符的任一侧添加值	A + B将给出30
-	减法 - 从左手操作数中减去右手操作数	A - B将给-10
*	乘法 - 将运算符两侧的值相乘	A * B将给出200
/	除法 - 用右手操作数除左手操作数	B/A会给2
+	一元加 - 这对变量值没有影响。	+ B给出20
-	一元减号 - 这会创建给定变量的负值。	-B gives -20

关系运算符

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

显示示例

操作者	描述	例
=	检查两个操作数的值是否相等，如果是，则条件变为真。	（A = B）不是真的。
!=	检查两个操作数的值是否相等，如果值不相等则条件变为true。	（A！= B）是真的。
>	检查左操作数的值是否大于右操作数的值，如果是，则条件变为真。	（A> B）不是真的。
<	检查左操作数的值是否小于右操作数的值，如果是，则条件变为真。	(A < B) 为真
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件变为真。	（A> = B）不是真的。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件变为真。	（A <= B）是真的。

逻辑运算符 (The Logical Operators)

下表列出了逻辑运算符。假设布尔变量A保持1而变量B保持0然后 -

显示示例

操作者	描述	例
and	称为逻辑AND运算符。如果两个操作数都不为零，那么条件变为真。	（A和B）是假的。
or	称为逻辑OR运算符。如果两个操作数中的任何一个非零，则条件变为真。	（A或B）是真的。
xor	称为逻辑XOR运算符。如果其中一个为真，则条件为真，如果两个操作数都为真或假，则条件变为假。	（A xor B）是真的。
not	被称为逻辑NOT运算符否定结果。使用此运算符，true变为false，false变为true	not(B) is true.

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

分配运算符

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

显示示例

操作者	描述	例
=	简单赋值运算符，将右侧操作数的值分配给左侧操作数	C = A + B将A + B的值分配给C
+=	添加AND赋值运算符，它将右操作数添加到左操作数并将结果赋给左操作数	C + = A等于C = C + A.
-=	减去AND赋值运算符，它从左操作数中减去右操作数，并将结果赋给左操作数	C - = A相当于C = C - A.
*=	乘以AND赋值运算符，它将右操作数与左操作数相乘，并将结果赋值给左操作数	C * = A等于C = C * A.
/=	除法AND赋值运算符，它将左操作数除以右操作数，并将结果赋值给左操作数	C/= A相当于C = C/A.
&=	连接运算符	C＆= {2}与C = {C}＆{2}相同

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

混合操作符 (Miscellaneous Operators)

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

运算符

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

例如 -

#!/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

幸福操作者的优先权

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

例如，x = 7 + 3 * 2

这里，x被赋值为13，而不是20，因为operator *的优先级高于+。

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

此处具有最高优先级的运算符显示在表的顶部，具有最低优先级的运算符显示在底部。在表达式中，首先计算更高优先级的运算符。

类别	操作者	关联性
Postfix	function/type calls
Unary	+ - ！不	右到左
Multiplicative	*/	左到右
Additive	+ -	左到右
Concatenation	&	左到右
Relational	>> = << =	左到右
Equality	=！=	左到右
Logical AND	and	左到右
Logical OR	or	左到右
Logical XOR	xor	左到右
Comma	,	左到右

Euphoria - Branching

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

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

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

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

Euphoria - Loop Types

循环是任何编程语言的另一个最重要的方面。编写程序时，您可能会遇到多次执行相同语句而某些时候可能无限次执行的情况。

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

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

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

以上所有陈述均可根据不同情况为您提供灵活性和易用性。让我们逐一详细地看到它们 -

Euphoria - Flow Control

程序执行流程是指程序语句执行的顺序。默认情况下，语句会一个接一个地执行。

然而; 很多时候，执行顺序需要从默认顺序改变，以完成任务。

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

exit声明

使用关键字exit退出循环。这会导致流程立即离开当前循环，并在循环结束后重新开始第一个语句。

语法 (Syntax)

exit语句的语法如下 -

exit [ "Label Name" ] [Number]

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

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

例子 (Example)

#!/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声明

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

语法 (Syntax)

break语句的语法如下 -

break [ "Label Name" ] [Number]

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

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

例子 (Example)

#!/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语句继续执行它应用的循环，方法是进入下一次迭代并跳过迭代的其余部分。

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

语法 (Syntax)

continue语句的语法如下 -

continue [ "Label Name" ] [Number]

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

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

例子 (Example)

#!/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语句继续执行它应用的循环，方法是进入下一次迭代并跳过迭代的其余部分。

语法 (Syntax)

重试语句的语法如下 -

retry [ "Label Name" ] [Number]

retry语句重试执行它适用的循环的当前迭代。该语句分支到指定循环的第一个语句既不测试任何东西也不递增for循环索引。

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

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

例子 (Example)

#!/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语句指示计算机在标记的位置恢复代码执行。

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

语法 (Syntax)

goto语句的语法如下 -

goto "Label Name"

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

label "Label Name"

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

例子 (Example)

#!/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 - Short Circuit Evaluation

当使用if, elsif, until或者使用and或or运算符测试条件while使用短路评估。例如 -

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

如果<0为假，那么Euphoria并不打算测试b是否大于0.它知道总体结果是假的，无论如何。同样 -

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

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

一般而言，只要您有以下表格的条件 -

A and B

在A和B可以是任何两个表达式的情况下，当A为假时，Euphoria会采用捷径，并且在没有查看表达式B的情况下立即使整体结果为假。

同样，只要您有以下表格的条件 -

A or  B

如果A为真，Euphoria会跳过表达式B的评估，并声明结果为真。

对if，elsif，until和while条件Short-circuit评估和/或发生。它不用于其他环境。例如 -

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条件，因为你只需要关心结果是真还是假，并且结果需要条件来产生原子。

Euphoria - Sequences

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

{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]，你得到原子33 。

例子 (Example)

#!/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

字符串

字符串只是sequence字符。它可以以两种方式之一进入 -

(a) Using Double Quotes −

"ABCDEFG"

(b) Using Raw String Notation −

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

字符串数组

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

#!/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

Euphoria结构

可以使用Sequences实现结构，如下所示 -

#!/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,}

Command Line Options

用户可以将命令行选项传递给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 - Date & Time

Euphoria有一个库例程，它返回程序的日期和时间。

The date() Method

date（）方法返回由8个atom元素组成的序列值。以下示例详细说明了 -

#!/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.

The time() Method

time（）方法返回一个atom值，表示自固定时间点以来经过的秒数。以下示例详细说明了 -

#!/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 Library Routines中。

Euphoria - Procedures

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

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

您必须在前面的章节中看到过printf()和length()等过程。我们一次又一次地使用这些程序，但它们只用了一次核心Euphoria。

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

程序定义

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

procedure procedurename(parameter-list)
   statements
   ..........
end procedure

例子 (Example)

这里定义了一个名为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

程序参数

直到现在你已经看到没有参数的程序。但是在调用过程时有一个传递不同参数的工具。可以在过程内捕获这些传递的参数，并且可以对这些参数进行任何操作。

过程可以使用逗号分隔多个参数。

例子 (Example)

让我们在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中编写自己的函数。

函数定义 (Function Definition)

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

function functionname(parameter-list)
   statements
   ..........
   return [Euphoria Object]
end function

例子 (Example)

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

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

调用一个函数 (Calling a Function)

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

#!/home/euphoria-4.0b2/bin/eui
function sayHello()
   puts(1, "Hello there")
   return 1
end function
-- Call above defined function.
sayHello()

这会产生以下结果 -

Hello there

功能参数

直到现在我们已经看到没有参数的功能。但是在调用函数时有一个传递不同参数的工具。可以在函数内捕获这些传递的参数，并且可以对这些参数进行任何操作。

函数可以采用逗号分隔的多个参数。

例子 (Example)

让我们在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.

return声明

Euphoria函数在关闭语句end function之前必须具有return语句。可以返回任何Euphoria对象。实际上，通过返回一系列对象，您可以拥有多个返回值。例如

return {x_pos, y_pos}

如果没有任何要返回的内容，则只返回1或0.返回值1表示成功，0表示失败

Euphoria - Files I/O

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

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

在屏幕上显示

生成输出的最简单方法是使用puts()语句，您可以在其中传递要在屏幕上显示的任何字符串。还有另一种方法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?

打开和关闭文件 (Opening and Closing Files)

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

open()
close()
printf()
gets()
getc()

open方法

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

语法 (Syntax)

integer file_num = open(file_name, access_mode)

如果打开给定文件名时出错，则上面的方法返回-1。这是参数 -

file_name - file_name参数是一个字符串值，其中包含要访问的文件的名称。
access_mode - access_mode确定必须打开文件的模式。例如，读取，写入附加等。文件打开模式的可能值的完整列表如下表所示 -

S.No	模式和描述
1	r 打开文本文件以供阅读。文件指针位于文件的开头。
2	rb 打开文件以仅以二进制格式读取。文件指针位于文件的开头。
3	w 打开文本文件以进行写入。如果文件存在，则覆盖文件。如果该文件不存在，则创建一个用于写入的新文件。
4	wb 打开文件以仅以二进制格式写入。如果文件存在，则覆盖文件。如果该文件不存在，则创建一个用于写入的新文件。
5	u 打开文件进行读写。文件指针设置在文件的开头。
6	ub 打开二进制格式的读写文件。文件指针位于文件的开头。
7	a 打开要附加的文件。如果文件存在，则文件指针位于文件的末尾（追加模式）。如果该文件不存在，则会创建一个用于写入的新文件。
8	ab 打开文件以二进制格式附加。如果文件存在，则文件指针位于文件的末尾（追加模式）。如果该文件不存在，则会创建一个用于写入的新文件。

例子 (Example)

以下示例在Linux系统的当前目录中创建一个新的文本文件 -

#!/home/euphoria-4.0b2/bin/eui
integer file_num
constant ERROR = 2
constant STDOUT = 1
file_num = open("myfile,txt", "w")
if file_num = -1 then
   puts(ERROR, "couldn't open myfile\n")
else
   puts(STDOUT, "File opend successfully\n")
end if

如果文件成功打开，则在当前目录中创建“myfile.txt”并生成以下结果 -

File opend successfully

The close() Method

close（）方法刷新任何未写入的信息并关闭文件，之后不再对文件进行读写操作。

当文件的引用对象被重新分配给另一个文件时，Euphoria会自动关闭文件。使用close（）方法关闭文件是一种很好的做法。

语法 (Syntax)

close( file_num );

这里打开文件时收到的文件描述符作为参数传递。

例子 (Example)

以下示例如上所述创建文件，然后在存在程序之前将其关闭 -

#!/home/euphoria-4.0b2/bin/eui
integer file_num
constant ERROR = 2
constant STDOUT = 1
file_num = open("myfile.txt", "w")
if file_num = -1 then
   puts(ERROR, "couldn't open myfile\n")
else
   puts(STDOUT, "File opend successfully\n")
end if
if file_num = -1 then
   puts(ERROR, "No need to close the file\n")
else
   close( file_num )
   puts(STDOUT, "File closed successfully\n")
end if

这会产生以下结果 -

File opend successfully
File closed successfully

读写文件 (Reading and Writing Files)

Euphoria提供了一组访问方法，可以在文本模式或二进制模式下读取或写入文件时使我们的生活更轻松。让我们看看如何使用printf()和gets()方法来读写文件。

The printf() Method

printf()方法将任何字符串写入打开的文件。

语法 (Syntax)

printf(fn, st, x)

这是参数 -

fn - 从open（）方法接收的文件描述符。
st - 格式字符串，其中使用％d格式化十进制或原子，字符串或序列使用％s格式化。
x - 如果x是一个序列，则st中的格式说明符与x的相应元素匹配。如果x是一个原子，那么通常st只包含一个格式说明符，它应用于x。然而; 如果st包含多个格式说明符，则每个格式说明符都应用于相同的值x。

例子 (Example)

以下示例打开一个文件，并在此文件中写入人员的姓名和年龄 -

#!/home/euphoria-4.0b2/bin/eui
integer file_num
constant ERROR = 2
constant STDOUT = 1
file_num = open("myfile.txt", "w")
if file_num = -1 then
   puts(ERROR, "couldn't open myfile\n")
else
   puts(STDOUT, "File opend successfully\n")
end if
printf(file_num, "My name is %s and age is %d\n", {"Zara", 8})
if file_num = -1 then
   puts(ERROR, "No need to close the file\n")
else
   close( file_num )
   puts(STDOUT, "File closed successfully\n")
end if

上面的示例创建了myfile.txt文件。是否在该文件中写入内容并最终关闭。如果您打开此文件，它将具有以下内容 -

My name is Zara and age is 8

The gets() Method

gets()方法从打开的文件中读取字符串。

语法 (Syntax)

gets(file_num)

这里传递的参数是opend()方法返回的文件描述。此方法逐行开始从文件的开头读取。字符的值从0到255.原子-1在文件末尾返回。

例子 (Example)

我们来一个已创建的文件myfile.txt 。

#!/home/euphoria-4.0b2/bin/eui
integer file_num
object line
constant ERROR = 2
constant STDOUT = 1
file_num = open("myfile.txt", "r")
if file_num = -1 then
   puts(ERROR, "couldn't open myfile\n")
else
   puts(STDOUT, "File opend successfully\n")
end if
line = gets(file_num)
printf( STDOUT, "Read content : %s\n", {line})
if file_num = -1 then
   puts(ERROR, "No need to close the file\n")
else
   close( file_num )
   puts(STDOUT, "File closed successfully\n")
end if

这会产生以下结果 -

File opend successfully
Read content : My name is Zara and age is 8
File closed successfully

Euphoria提供了许多方法的列表，可以帮助您操作文件。这些方法列在Euphoria Library Routines中。

<上一篇.Euphoria - Files I/O

euphoria - 图书馆例程( Library Routines).下一篇>

Euphoria - 教程

Euphoria - 概述

Euphoria - 环境

Euphoria - Basic 语法

Euphoria - 变量

Euphoria - 常量

Euphoria - 数据类型

Euphoria - 运算符

euphoria - 分支( Branching)

euphoria - 循环类型( Loop Types)

euphoria - 流量控制( Flow Control)

euphoria - 短路( Short Circuit)

euphoria - 序列( Sequences)

euphoria - 日期和时间( Date & Time)

euphoria - 程序( Procedures)

euphoria - 功能( Functions)

Euphoria - Files I/O