Euphoria 快速指南

---

---

Euphoria - 概述

Euphoria 代表 **E**nd-**U**ser **P**rogramming with **H**ierarchical **O**bjects for **R**obust **I**nterpreted **A**pplications。Euphoria 的第一個版本由 Robert Craig 在 Atari Mega-ST 上建立，並於 1993 年首次釋出。現在由 Rapid Deployment Software 維護。

它是一種免費、簡單、靈活、易於學習的解釋型語言，但速度極快，是一種用於 DOS、Windows、Linux、FreeBSD 等的 32 位高階程式語言。

Euphoria 用於開發 Windows GUI 程式、高速 DOS 遊戲和 Linux/FreeBSD X Windows 程式。Euphoria 也可以用於 CGI（基於 Web）程式設計。

Euphoria 特性

以下是 Euphoria 主要特性的列表：

• 它是一種簡單、靈活、強大的語言定義，易於學習和使用。

• 它支援動態儲存分配，這意味著變數可以增長或縮小，而程式設計師無需擔心分配和釋放記憶體。它會自動進行垃圾回收。

• 它比 Perl 和 Python 等傳統直譯器快得多。

• Euphoria 程式可在 Linux、FreeBSD、32 位 Windows 和任何 DOS 環境下執行。

• Euphoria 程式不受任何 640K 記憶體限制。

• 它提供一個最佳化的 Euphoria 到 C 翻譯器，您可以使用它將 Euphoria 程式轉換為 C，然後使用 C 編譯器編譯它以獲得可執行檔案（.exe）。這可以將程式速度提高 2 到 5 倍。

• 底層硬體完全隱藏，這意味著程式不知道字長、值的底層位級表示、位元組序等。

• Euphoria 安裝程式附帶全螢幕原始碼偵錯程式、執行分析器和全螢幕多檔案編輯器。

• 它支援執行時錯誤處理、下標和型別檢查。

• 它是一種開源語言，完全免費。

平臺要求

Euphoria 可在 Windows、Linux、FreeBSD 和 OSX 上使用。以下是各個平臺所需的最低版本：

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

• **Linux 版本** - 您需要任何相當新的 Linux 發行版，該發行版具有 libc6 或更高版本。例如，Red Hat 5.2 或更高版本可以正常工作。

• **FreeBSD 版本** - 您需要任何相當新的 FreeBSD 發行版。

• **Mac OS X 版本** - 您需要任何相當新的基於 Intel 的 Mac。

Euphoria 限制

以下是 Euphoria 的一些主要限制：

• 儘管 Euphoria 對程式設計師來說足夠簡單、快速和靈活；但它並不支援許多重要功能的呼叫。例如，網路程式設計。

• Euphoria 發明於 1993 年，至今仍然沒有關於這種語言的書籍。該語言的文件也不多。

但是現在，這門語言正在迅速流行起來，您可以希望很快就能獲得不錯的實用程式和書籍。

Euphoria 許可

本產品是免費且開源的，並受益於許多人的貢獻。您擁有完全免版稅的權利來分發您開發的任何 Euphoria 程式。

圖示檔案，例如 euphoria.ico 和 euphoria\bin 中提供的二進位制檔案，可以隨您的更改一起分發，也可以不隨您的更改一起分發。

您可以 **隱藏** 或 **繫結** 您的程式並免版稅地分發生成的 檔案。當您使用 Euphoria 到 C 翻譯器時，可能適用一些額外的第三方法律限制。

慷慨的 **開源許可證** 允許 Euphoria 用於個人和商業目的。與許多其他開源許可證不同，您的更改不必開源。

Euphoria - 環境

本章介紹如何在各種平臺上安裝 Euphoria。您可以按照步驟在 Linux、FreeBSD 和 32 位 Windows 上安裝 Euphoria。因此，您可以根據您的工作環境選擇步驟。

Linux、Free 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 直譯器

根據您使用的平臺，Euphoria 具有多個直譯器：

• 主直譯器是 **eui**。

• 在 Windows 平臺上，您有兩種選擇。如果您執行 **eui**，則會建立一個控制檯視窗。如果您執行 **euiw**，則不會建立控制檯，使其適合 GUI 應用程式。

• Euphoria 不關心您選擇的副檔名。但是按照約定；基於控制檯的應用程式帶有 **.ex** 副檔名。

• 基於 GUI 的應用程式具有 **.exw** 副檔名，包含檔案具有 **.e** 副檔名。

Euphoria - 基本語法

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

保留字

以下列表顯示了 Euphoria 中的保留字。這些保留字不能用作常量或變數或任何其他識別符號名稱。Euphoria 關鍵字僅包含小寫字母。

表示式

Euphoria 允許您透過形成表示式來計算結果。但是，在 Euphoria 中，您可以使用一個表示式對整個資料序列執行計算。

您可以像處理單個數字一樣處理序列。它可以被複制、傳遞給子例程或作為單元進行計算。例如：

{1,2,3} + 5

這是一個表示式，它將序列 {1, 2, 3} 和原子 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

跳脫字元

可以使用反斜槓輸入跳脫字元。例如：

下表列出了可以使用反斜槓表示法表示的跳脫字元或不可列印字元。

Euphoria中的註釋

所有註釋都被編譯器忽略，不會影響執行速度。建議在程式中使用更多註釋以提高可讀性。

註釋有三種形式：

• 註釋以兩個連字元開始，一直延續到當前行的結尾。

• 多行格式註釋包含在/*...*/內，即使跨行。

• 您可以在程式的第一行使用以“#! ”開頭的特殊註釋。

示例

#!/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資料型別在不同的章節中解釋。

這些記憶體位置稱為變數，因為它們的值在其生命週期內可以更改。

變數宣告

Euphoria變數必須顯式宣告以保留記憶體空間。因此，在為變數賦值之前，必須宣告變數。

變數宣告包含一個型別名稱，後跟要宣告的變數列表。例如：

integer x, y, z

sequence a, b, x

當您宣告變數時，您會命名變數，並定義在程式執行期間可以合法地分配給變數的值的型別。

僅僅宣告變數不會為其分配任何值。如果您在為其分配任何值之前嘗試讀取它，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 迴圈** 或 **switch** 中宣告，則其作用域從宣告開始，到相應的 **end** 語句結束。

• 在 **if** 語句中，作用域從宣告開始，到下一個 **else、elsif** 或 **end if** 語句結束。

• 如果變數在例程內宣告，則變數的作用域從宣告開始，到例程的 end 語句結束。這稱為私有變數。

• 如果變數在例程外部宣告，則其作用域從宣告開始，到其宣告所在檔案的結尾。這稱為模組變數。

• 沒有作用域修飾符的 **常量** 的作用域從宣告開始，到其宣告所在檔案的結尾。

• 沒有作用域修飾符的 **列舉** 的作用域從宣告開始，到其宣告所在檔案的結尾。

• 所有沒有作用域修飾符的 **過程、函式** 和 **型別** 的作用域從其宣告的原始檔開頭開始，到原始檔結尾結束。

沒有作用域修飾符的常量、列舉、模組變數、過程、函式和型別被稱為 **區域性變數**。但是，這些識別符號可以在其宣告之前具有作用域修飾符，這會導致它們的作用域擴充套件到其宣告的檔案之外。

• 如果關鍵字 **global** 在宣告之前，則這些識別符號的作用域擴充套件到整個應用程式。應用程式檔案中的任何程式碼都可以訪問它們。

• 如果關鍵字 **public** 在宣告之前，則作用域擴充套件到顯式包含宣告識別符號的檔案的任何檔案，或包含反過來 *public* 包含包含 *public* 宣告的檔案的任何檔案。

• 如果關鍵字 **export** 在宣告之前，則作用域僅擴充套件到直接包含宣告識別符號的檔案的任何檔案。

當您在另一個檔案中 **include** Euphoria 檔案時，只有使用作用域修飾符宣告的識別符號才能被進行 *include* 操作的檔案訪問。包含檔案中的其他宣告對進行 *include* 操作的檔案不可見。

Euphoria - 常量

常量也是變數，它們被賦予一個初始值，在程式的生命週期中永遠不會改變。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 有以下四種標準資料型別：

• 整數
• 原子
• 序列
• 物件

理解原子和序列是理解 Euphoria 的關鍵。

整數

Euphoria 整數資料型別儲存數值。它們宣告和定義如下：

integer var1, var2

var1 = 1
var2 = 100

用 integer 型別宣告的變數必須是具有從 -1073741824 到 +1073741823（含）的 **整數** 值的原子。您可以對更大的整數（最多約 15 位十進位制數字）執行精確計算，但將其宣告為原子，而不是整數。

原子

Euphoria 中的所有資料物件都是原子或序列。原子是單個數值。原子可以具有任何整數或雙精度浮點數。Euphoria 原子宣告和定義如下：

atom var1, var2, var3

var1 = 1000
var2 = 198.6121324234
var3 = 'E'       

原子的範圍大約從 -1e300 到 +1e300，精度為 15 位十進位制數字。單個字元是一個 **原子**，必須使用單引號輸入。例如，以下所有語句都是合法的：

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

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

序列

序列是可以透過其索引訪問的數值集合。Euphoria 中的所有資料物件都是原子或序列。

序列索引從 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 - 序列 中學習更多關於序列的知識。

物件

這是 Euphoria 中的一種超級資料型別，它可以採用任何值，包括原子、序列或整數。Euphoria 物件宣告和定義如下：

object var1, var2, var3

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

物件可以具有以下值之一：

• 序列

• 原子

• 整數

• 用作檔案號的整數

• 字串序列或單字元原子

Euphoria - 運算子

Euphoria 提供了一套豐富的運算子來操作變數。我們可以將所有 Euphoria 運算子分為以下幾組：

• 算術運算子
• 關係運算符
• 邏輯運算子
• 賦值運算子
• 其他運算子

算術運算子

算術運算子在數學表示式中的使用方法與在代數中相同。下表列出了算術運算子。假設整數變數 A 為 10，變數 B 為 20，則：

顯示示例

關係運算符

Euphoria 語言支援以下關係運算符。假設變數 A 為 10，變數 B 為 20，則：

顯示示例

邏輯運算子

下表列出了邏輯運算子。假設布林變數 A 為 1，變數 B 為 0，則：

顯示示例

您還可以將這些運算子應用於 1 或 0 之外的數字。約定是：零表示假，非零表示真。

賦值運算子

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

分支是任何程式語言最重要的方面之一。編寫程式時，您可能會遇到需要做出決策或從給定的多個選項中選擇一個選項的情況。

下圖顯示了一個簡單的場景，其中程式需要根據給定的條件選擇兩條路徑之一。

Euphoria 提供以下三種類型的決策（分支或條件）語句：

• if 語句

• switch 語句

• ifdef 語句

讓我們詳細瞭解這些語句：

Euphoria - 迴圈型別

迴圈是任何程式語言的另一個最重要的方面。編寫程式時，您可能會遇到需要多次執行相同語句的情況，有時甚至可能是無限次。

有多種方法可以指定程序應持續多長時間，以及如何停止或更改它。迭代塊可以非正式地稱為迴圈，迴圈中程式碼的每次執行都稱為迴圈的一次迭代。

下圖顯示了迴圈的簡單邏輯流程：

Euphoria 提供以下三種類型的迴圈語句：

• while 語句

• loop until 語句

• for 語句

以上所有語句都根據不同的情況為您提供靈活性和易用性。讓我們逐一詳細瞭解它們：

Euphoria - 流程控制

程式執行流程是指程式語句執行的順序。預設情況下，語句一個接一個地執行。

但是，很多時候需要更改執行順序以完成任務。

Euphoria 有許多流程控制語句，您可以使用它們來安排語句的執行順序。

exit 語句

使用關鍵字exit退出迴圈。這會導致流程立即離開當前迴圈，並在迴圈結束後的第一條語句處重新開始。

語法

exit 語句的語法如下：

exit [ "Label Name" ] [Number]

exit語句終止最新的和最內層的迴圈，除非指定了可選的標籤名稱或編號。

exit N的一種特殊形式是exit 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 語句

break語句的工作方式與exit語句完全相同，但適用於if語句或switch語句，而不是任何型別的迴圈語句。

語法

break 語句的語法如下：

break [ "Label Name" ] [Number]

break語句終止最新的和最內層的if或switch塊，除非指定了可選的標籤名稱或編號。

break N的一種特殊形式是break 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 語句的語法如下：

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語句透過轉到下一次迭代並跳過其餘迭代來繼續執行它所應用的迴圈。

語法

retry 語句的語法如下：

retry [ "Label Name" ] [Number]

retry語句重試執行它所應用的迴圈的當前迭代。該語句跳轉到指定迴圈的第一條語句，既不測試任何內容也不遞增for迴圈索引。

retry N的一種特殊形式是retry 0。這將重試執行最外層的迴圈，無論深度如何。同樣，retry -1 重試第二個最外層的迴圈，以此類推。

通常，包含retry語句的子塊還包含另一個流程控制關鍵字，如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

由於retry不會更改i的值並嘗試再次開啟同一個檔案，因此必須有一種方法可以從迴圈中跳出，exit語句提供了這種方法。

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或while測試條件時，將使用短路求值。例如：

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

如果 a < 0 為假，則 Euphoria 不理會測試 b 是否大於 0。它知道無論如何整體結果都是假的。同樣：

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

如果 a < 0 為真，則 Euphoria 立即決定結果為真，而不測試 b 的值，因為此測試的結果無關緊要。

一般來說，當您有以下形式的條件時：

A and B

其中 A 和 B 可以是任意兩個表示式，當 A 為假時，Euphoria 會走捷徑並立即將整體結果設為假，甚至不查看錶達式 B。

同樣，當您有以下形式的條件時：

A or  B

其中 A 為真，Euphoria 將跳過表示式 B 的求值，並宣告結果為真。

短路求值僅適用於 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 條件，因為您只需要關心結果是真還是假，並且需要條件產生原子作為結果。

Euphoria - 序列

序列由大括號 { } 中用逗號分隔的物件列表表示。序列可以包含原子和其他序列。例如：

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

示例

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

Euphoria 結構

可以使用序列實現結構，如下所示：

#!/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() 方法返回一個由八個原子元素組成的序列值。以下示例詳細解釋了它：

#!/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() 方法返回一個原子值，表示自某個固定時間點以來經過的秒數。以下示例詳細解釋了它：

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

過程是一組可重用的程式碼，可以從程式中的任何位置呼叫。這消除了重複編寫相同程式碼的需要。這有助於程式設計師編寫模組化程式碼。

與任何其他高階程式語言一樣，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.

return 語句

Euphoria 函式必須在結束語句end function之前包含return語句。可以返回任何 Euphoria 物件。實際上，您可以透過返回物件的序列來擁有多個返回值。例如：

return {x_pos, y_pos}

如果沒有要返回的內容，則只需返回 1 或 0。返回值 1 表示成功，0 表示失敗。

Euphoria - 檔案 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?

開啟和關閉檔案

Euphoria 預設情況下提供操作檔案所需的基本方法。您可以使用以下方法執行大部分檔案操作：

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

open 方法

在讀取或寫入檔案之前，必須使用 Euphoria 的內建open()方法開啟它。此函式建立一個檔案描述符，用於呼叫與其關聯的其他支援方法。

語法

integer file_num = open(file_name, access_mode)

如果開啟給定檔名時出錯，則上述方法返回 -1。以下是引數：

• file_name - file_name 引數是一個字串值，其中包含要訪問的檔案的名稱。

• access_mode - access_mode 確定開啟檔案的模式。例如，讀取、寫入追加等。下表列出了檔案開啟模式的完整可能的取值列表：

示例

以下示例在 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

close() 方法

close() 方法重新整理任何未寫入的資訊並關閉檔案，之後不能再對檔案進行讀取或寫入。

當檔案的引用物件重新分配給另一個檔案時，Euphoria 會自動關閉該檔案。最好使用 close() 方法關閉檔案。

語法

close( file_num );

此處將開啟檔案時接收到的檔案描述符作為引數傳遞。

示例

以下示例建立檔案（如上所示），然後在程式退出之前關閉它：

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

讀取和寫入檔案

Euphoria 提供了一組訪問方法，使我們在讀取或寫入文字模式或二進位制模式下的檔案時更容易。讓我們看看如何使用printf()和gets()方法讀取和寫入檔案。

printf() 方法

printf()方法將任何字串寫入開啟的檔案。

語法

printf(fn, st, x) 

以下是引數：

• fn - 從 open() 方法接收到的檔案描述符。

• st - 格式字串，其中十進位制或原子使用 %d 格式化，字串或序列使用 %s 格式化。

• x - 如果 x 是一個序列，則 st 中的格式說明符與 x 的相應元素匹配。如果 x 是一個原子，則 st 通常只包含一個格式說明符，並將其應用於 x。但是；如果 st 包含多個格式說明符，則每個說明符都應用於相同的值 x。

示例

以下示例開啟一個檔案，並將一個人的姓名和年齡寫入此檔案中：

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

gets() 方法

gets()方法從開啟的檔案中讀取字串。

語法

gets(file_num)

此處傳遞的引數是opend()方法返回的檔案描述符。此方法從檔案的開頭開始逐行讀取。字元的值範圍為 0 到 255。在檔案末尾返回原子 -1。

示例

讓我們以一個已經建立的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 庫例程中。