행복감-퀵 가이드

행복감은 End-User P로그 래밍 H계층 적 O에 대한 bjects R폭주하다 I해석 Applications. 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 (웹 기반) 프로그래밍에도 사용할 수 있습니다.

행복감 특징

다음은 Euphoria의 주요 기능 목록입니다.

배우고 사용하기 쉬운 간단하고 유연하며 강력한 언어 정의입니다.
프로그래머가 메모리 할당 및 해제에 대해 걱정할 필요없이 변수가 증가하거나 축소됨을 의미하는 동적 스토리지 할당을 지원합니다. 가비지 콜렉션을 자동으로 처리합니다.
Perl 및 Python과 같은 기존 인터프리터보다 매우 빠릅니다.
Euphoria 프로그램은 Linux, FreeBSD, 32 비트 Windows 및 모든 DOS 환경에서 실행됩니다.
유포리아 프로그램에는 640K 메모리 제한이 적용되지 않습니다.
Euphoria 프로그램을 C로 번역 한 다음 C 컴파일러로 컴파일하여 실행 파일 (.exe)을 얻는 데 사용할 수있는 최적화 된 Euphoria-To-C 변환기를 제공합니다. 이렇게하면 프로그램 속도가 2 ~ 5 배 향상됩니다.
기본 하드웨어는 완전히 숨겨져 있으므로 프로그램이 단어 길이, 기본 비트 수준의 값 표현, 바이트 순서 등을 인식하지 못합니다.
Euphoria 설치는 전체 화면 소스 디버거, 실행 프로파일 러 및 전체 화면 다중 파일 편집기와 함께 제공됩니다.
런타임 오류 처리, 아래 첨자 및 유형 검사를 지원합니다.
오픈 소스 언어이며 완전히 무료입니다.

플랫폼 요구 사항

Euphoria는 Windows, Linux, FreeBSD 및 OSX에서 사용할 수 있습니다. 다음은 다음 플랫폼에 필요한 최소 버전입니다.

WIN32 version− Windows 95 또는 이후 버전의 Windows가 필요합니다. XP와 Vista에서 잘 실행됩니다.
Linux version− libc6 이상이있는 합리적으로 최신 Linux 배포판이 필요합니다. 예를 들어 Red Hat 5.2 이상이 정상적으로 작동합니다.
FreeBSD version − 합리적으로 최신 FreeBSD 배포판이 필요합니다.
Mac OS X version − 합리적으로 최신 Intel 기반 Mac이 필요합니다.

행복감 제한

다음은 행복감의 몇 가지 두드러진 한계입니다.

비록 Euphoria는 프로그래머들에게 충분히 간단하고 빠르며 유연하지만; 많은 중요한 기능에 대한 통화 지원을 제공하지 않습니다. 예를 들어, 네트워크 프로그래밍.
유포리아는 1993 년에 발명되었지만 여전히이 언어로 작성된 책을 찾을 수 없습니다. 또한 해당 언어에 사용할 수있는 문서가 많지 않습니다.

그러나 요즘에는이 언어가 매우 빠르게 인기를 얻고 있으며 곧 언어에 대한 멋진 유틸리티와 책을 사용할 수 있기를 바랍니다.

Euphoria 라이선스

이 제품은 무료이며 오픈 소스이며 많은 사람들의 기여로 혜택을 받았습니다. 귀하는 귀하가 개발 한 모든 Euphoria 프로그램을 배포 할 수있는 완전한 로열티없는 권리가 있습니다.

euphoria.ico 및 euphoria \ bin에서 사용 가능한 바이너리와 같은 아이콘 파일은 변경 여부에 관계없이 배포 될 수 있습니다.

당신은 할 수 있습니다 shroud 또는 bind프로그램을 작성하고 결과 파일을 로열티없이 배포하십시오. 일부 추가 3 ^번째의 당신은 Euphoria-으로-C 변환기를 사용하는 경우 당사자의 법적 제한 사항이 적용될 수 있습니다.

관대 한 Open Source LicenseEuphoria가 개인적 및 상업적 목적으로 사용할 수 있도록 허용합니다. 다른 많은 오픈 소스 라이선스와 달리 변경 사항은 오픈 소스로 만들 필요가 없습니다.

이 장에서는 다양한 플랫폼에 Euphoria를 설치하는 방법에 대해 설명합니다. 다음 단계에 따라 Linux, FreeBSD 및 32 비트 Windows에 Euphoria를 설치할 수 있습니다. 따라서 작업 환경에 따라 단계를 선택할 수 있습니다.

Linux, 무료 BSD 설치

공식 웹 사이트는 제공합니다 .tar.gzLinux 또는 BSD OS에 Euphoria를 설치하기위한 파일. 공식 웹 사이트 인 Download Euphoria 에서 최신 버전의 Euphoria를 다운로드 할 수 있습니다 .

.tar.gz 파일이 있으면 Linux 또는 Free BSD 시스템에 Euphoria를 설치하기 위해 수행해야 할 세 가지 간단한 단계가 있습니다.

Step 1 − 파일 설치

다운로드 한 파일 압축 해제 euphoria-4.0b2.tar.gzEuphoria를 설치하려는 디렉토리에 있습니다. 다음과 같이 / 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를 설치 한 후 쉘이 필요한 Euphoria 바이너리 및 유틸리티를 찾을 수 있도록 적절한 경로를 설정해야합니다. 계속하기 전에 다음과 같은 세 가지 중요한 환경 변수를 설정해야합니다.

PATH 환경 변수를 /home/euphoria-4.0b2/bin 디렉터리로 설정합니다.
/home/euphoria-4.0b2를 가리 키도록 EUDIR 환경 변수를 설정합니다.
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 쉘을 사용 하여 변수를 설정했습니다.

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

공식 웹 사이트는 제공합니다 .exeWIN32 또는 DOS OS에 Euphoria를 설치하기위한 파일. 공식 웹 사이트 인 Download Euphoria 에서 최신 버전의 Euphoria를 다운로드 할 수 있습니다 .

.exe 파일이 있으면 WIN32 또는 DOS 시스템에 Euphoria 프로그래밍 언어를 설치하기 위해 따라야 할 간단한 세 단계가 있습니다.

Step 1 − 파일 설치

다운로드 한 파일을 두 번 클릭합니다. .exe모든 파일을 설치하는 설치 프로그램. 설치를 위해 euphoria-40b2.exe 파일을 다운로드했습니다.

파일 이름 euphoria-40b2.exe는 사용 가능한 최신 버전에 따라 다릅니다. 우리는 언어의 버전 4 베타 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에는 여러 통역사가 있습니다.

주요 통역사는 eui.
Windows 플랫폼에서는 두 가지 선택이 있습니다. 달리면eui then a console window is created. If you run euiw then no console is created, making it suitable for GUI applications.
Euphoria does not care about your choice of file extensions. By convention however; the console-based applications come with .ex extension.
GUI-based applications have .exw extension and the include files have .e extension.

The Euphoria language has many similarities to Perl, C, and Java. However, there are some definite differences between the languages. This chapter is designed to quickly get you up to speed on the syntax that is expected in Euphoria.

This tutorial assumes you are working with Linux and all the examples have been written on Linux platform. But it is observed that there is no any prominent difference in program syntax on Linux and WIN32. Hence you can follow the same steps on WIN32.

First Euphoria Program

Let us write a simple Euphoria program in a script. Type the following source code in test.ex file and save it.

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

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

Let us say, Euphoria interpreter is available in /home/euphoria-4.0b2/bin/ directory. Now run this program as follows −

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

This produces the following result −

Hello, Euphoria!

This script used a built-in function puts() which takes two arguments. First argument indicates file name or device number, and second argument indicates a string which you want to print. Here 1 indicates STDOUT device.

Euphoria Identifiers

A Euphoria identifier is a name used to identify a variable, function, class, module, or other object. An identifier starts with a letter A to Z or a to z and then followed by letters, digits, or underscores.

Euphoria does not allow punctuation characters such as @, $, and % within identifiers.

Euphoria is a case sensitive programming language. Thus Manpower and manpower are two different identifiers in Euphoria. For example, the valid identifiers are −

n
color26
ShellSort
quick_sort
a_very_long_indentifier

Reserved Words

The following list shows the reserved words in Euphoria. These reserved words may not be used as constant or variable or any other identifier names. Euphoria keywords contain lowercase letters only.

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 lets you calculate results by forming expressions. However, in Euphoria you can perform calculations on entire sequences of data with one expression.

You can handle a sequence much as you would handle a single number. It can be copied, passed to a subroutine, or calculated upon as a unit. For example −

{1,2,3} + 5

This is an expression that adds the sequence {1, 2, 3} and the atom 5 to get the resulting sequence {6, 7, 8}. You would learn sequences in subsequent chapters.

Blocks of code

One of the first caveats programmers encounter when learning Euphoria is the fact that there are no braces to indicate blocks of code for procedure and function definitions or flow control. Blocks of code are denoted by associated keywords.

The following example shows if...then...end if block −

if condition then
   code block comes here
end if

Multi-Line Statements

Statements in Euphoria typically end with a new line. Euphoria does however, allow to write a single statement in multiple lines. For example −

total = item_one + 
   item_two + 
   item_three

Escape Characters

Escape characters may be entered using a back-slash. For example −

The following table is a list of escape or non-printable characters that can be represented with backslash notation.

Backslash notation	Description
\n	Newline
\r	Carriage return
\t	Tab
\\	Backslash
\"	Double quote
\'	Single quote

Comments in Euphoria

Any comments are ignored by the compiler and have no effect on execution speed. It is advisable to use more comments in your program to make it more readable.

There are three forms of comment text −

Comments start by two dashes and extend to the end of the current line.
The multi-line format comment is kept inside /*...*/, even if that occurs on a different line.
You can use a special comment beginning with the two character sequence “#!” only on the first line of the program.

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

This produces the following result −

Hello, Euphoria!

Note − You can use a special comment beginning with “#!”. This informs the Linux shell that your file should be executed by the Euphoria interpreter.

Variables are nothing but reserved memory locations to store values. This means when you create a variable, you reserve some space in memory.

Based on the data type of a variable, the interpreter allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to variables, you can store integers, decimals, or characters in these variables. Euphoria data types are explained in different chapter.

These memory locations are called variables because their value can be changed during their life time.

Variable Declaration

Euphoria variables have to be explicitly declared to reserve memory space. Thus declaration of a variable is mandatory before you assign a value to a variable.

Variable declarations have a type name followed by a list of the variables being declared. For example −

integer x, y, z

sequence a, b, x

When you declare a variable, you name the variable and you define which sort of values may legally be assigned to the variable during execution of your program.

The simple act of declaring a variable does not assign any value to it. If you attempt to read it before assigning any value to it, Euphoria will issue a run-time error as "variable xyz has never been assigned a value".

Assigning Values

The equal sign (=) is used to assign values to variables. Variable can be assigned in the following manner −

Variable_Name = Variable_Value

For example −

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

Here 100, 1000.0 and "John" are the values assigned to counter, miles and name variables, respectively. This program produces the following result −

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

To guard against forgetting to initialize a variable, and also because it may make the code clearer to read, you can combine declaration and assignment −

integer n = 5

This is equivalent to the following −

integer n
n = 5

Identifier Scope

The scope of an identifier is a description of what code can access it. Code in the same scope of an identifier can access that identifier and code not in the same scope as identifier cannot access it.

The scope of a variable depends upon where and how it is declared.

If it is declared within a for, while, loop or switch, its scope starts at the declaration and ends at the respective end statement.
In an if statement, the scope starts at the declaration and ends either at the next else, elsif or end if statement.
If a variable is declared within a routine, the scope of the variable starts at the declaration and ends at the routine's end statement. This is knows as a private variable.
If a variable is declared outside of a routine, its scope starts at the declaration and ends and the end of the file it is declared in. This is known as a module variable.
The scope of a constant that does not have a scope modifier, starts at the declaration and ends and the end of the file it is declared in.
The scope of a enum that does not have a scope modifier, starts at the declaration and ends and the end of the file it is declared in.
The scope of all procedures, functions and types, which do not have a scope modifier, starts at the beginning of the source file and ends at the end of the source file in which they are declared.

Constants, enums, module variables, procedures, functions and types, which do not have a scope modifier are referred to as locals. However, these identifiers can have a scope modifier preceding their declaration, which causes their scope to extend beyond the file they are declared in.

If the keyword global precedes the declaration, the scope of these identifiers extends to the whole application. They can be accessed by code anywhere in the application files.
If the keyword public precedes the declaration, the scope extends to any file that explicitly includes the file in which the identifier is declared, or to any file that includes a file that in turn public includes the file containing the public declaration.
If the keyword export precedes the declaration, the scope only extends to any file that directly includes the file in which the identifier is declared.

When you include a Euphoria file in another file, only the identifiers declared using a scope modifier are accessible to the file doing the include. The other declarations in the included file are invisible to the file doing the include.

Constants are also variables that are assigned an initial value that can never change in the program’s life. Euphoria allows to define constants using constant keyword as follows −

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

The result of any expression can be assigned to a constant, even one involving calls to previously defined functions, but once the assignment is made, the value of the constant variable is "locked in".

Constants may not be declared inside a subroutine. The scope of a constant that does not have a scope modifier, starts at the declaration and ends and the end of the file it is declared in.

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 )

This produces the following error −

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

Press Enter

If you delete last two lines from the example, then it produces the following result −

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

The enums

An enumerated value is a special type of constant where the first value defaults to the number 1 and each item after that is incremented by 1. Enums can only take numeric values.

Enums may not be declared inside a subroutine. The scope of an enum that does not have a scope modifier, starts at the declaration and ends and the end of the file it is declared in.

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 )

This will produce following result −

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

You can change the value of any one item by assigning it a numeric value. Subsequent values are always the previous value plus one, unless they too are assigned a default value.

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

This produce the following result −

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

Sequences use integer indices, but with enum you may write code like this −

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

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

The data stored in memory can be of many types. For example, a person's age is stored as a numeric value and his or her address is stored as alphanumeric characters.

Euphoria has some standard types that are used to define the operations possible on them and the storage method for each of them.

Euphoria has following four standard data types −

integer
atom
sequence
object

The understanding of atoms and sequences is the key to understanding Euphoria.

Integers

Euphoria integer data types store numeric values. They are declared and defined as follows −

integer var1, var2

var1 = 1
var2 = 100

The variables declared with type integer must be atoms with integer values from -1073741824 to +1073741823 inclusive. You can perform exact calculations on larger integer values, up to about 15 decimal digits, but declare them as atom, rather than integer.

Atoms

All data objects in Euphoria are either atoms or sequences. An atom is a single numeric value. Atoms can have any integer or double-precision floating point value. Euphoria atoms are declared and defined as follows−

atom var1, var2, var3

var1 = 1000
var2 = 198.6121324234
var3 = 'E'

The atoms can range from approximately -1e300 to +1e300 with 15 decimal digits of accuracy. An individual character is an atom which must may be entered using single quotes. For example, all the following statements are legal −

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

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

Sequences

A sequence is a collection of numeric values which can be accessed through their index. All data objects in Euphoria are either atoms or sequences.

Sequence index starts from 1 unlike other programming languages where array index starts from 0. Euphoria sequences are declared and defined as follows −

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

A character string is just a sequence of characters which may be entered using double quotes. For example, all the following statements are legal −

word = 'word'
sentence = "ABCDEFG"

Character strings may be manipulated and operated upon just like any other sequences. For example, the above string is entirely equivalent to the sequence −

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

You will learn more about sequence in Euphoria − Sequences.

Objects

This is a super data type in Euphoria which may take on any value including atoms, sequences, or integers. Euphoria objects are declared and defined as follows −

object var1, var2, var3

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

An object may have one of the following values −

a sequence
an atom
an integer
an integer used as a file number
a string sequence, or single-character atom

Euphoria provides a rich set of operators to manipulate variables. We can divide all the Euphoria operators into the following groups −

Arithmetic Operators
Relational Operators
Logical Operators
Assignment Operators
Misc Operators

The Arithmetic Operators

Arithmetic operators are used in mathematical expressions in the same way that they are used in Algebra. The following table lists the arithmetic operators. Assume integer variable A holds 10 and variable B holds 20 then −

Show Examples

Operator	Description	Example
+	Addition - Adds values on either side of the operator	A + B will give 30
-	Subtraction - Subtracts right hand operand from left hand operand	A - B will give -10
*	Multiplication - Multiplies values on either side of the operator	A * B will give 200
/	Division - Divides left hand operand by right hand operand	B / A will give 2
+	Unary plus - This has no impact on the variable value.	+B gives 20
-	Unary minus - This creates a negative value of the given variable.	-B gives -20

The Relational Operators

There are following relational operators supported by Euphoria language. Assume variable A holds 10 and variable B holds 20 then −

Show Examples

Operator	Description	Example
=	Checks if the value of two operands are equal or not, if yes then condition becomes true.	(A = B) is not true.
!=	Checks if the value of two operands are equal or not, if values are not equal then condition becomes true.	(A != B) is true.
>	Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.	(A > B) is not true.
<	Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true.	(A < B) is true.
>=	Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.	(A >= B) is not true.
<=	Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.	(A <= B) is true.

The Logical Operators

The following table lists the logical operators. Assume boolean variables A holds 1 and variable B holds 0 then −

Show Examples

Operator	Description	Example
and	Called Logical AND operator. If both the operands are non zero then then condition becomes true.	(A and B) is false.
or	Called Logical OR Operator. If any of the two operands are non zero then then condition becomes true.	(A or B) is true.
xor	Called Logical XOR Operator. Condition is true if one of them is true, if both operands are true or false then condition becomes false.	(A xor B) is true.
not	Called Logical NOT Operator which negates the result. Using this operator, true becomes false and false becomes true	not(B) is true.

You can also apply these operators to numbers other than 1 or 0. The convention is: zero means false and non-zero means true.

The Assignment Operators

There are following assignment operators supported by Euphoria language −

Show Examples

Operator	Description	Example
=	Simple assignment operator, Assigns values from right side operands to left side operand	C = A + B will assigne value of A + B into C
+=	Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand	C += A is equivalent to C = C + A
-=	Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand	C -= A is equivalent to C = C - A
*=	Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand	C = A is equivalent to C = C A
/=	Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand	C /= A is equivalent to C = C / A
&=	Concatenation operator	C &= {2} is same as C = {C} & {2}

Note − The equals symbol '=' used in an assignment statement is not an operator, it is just a part of the syntax.

Miscellaneous Operators

There are few other operators supported by Euphoria Language.

The '&' Operator

Any two objects may be concatenated using “&” operator. The result is a sequence with a length equal to the sum of the lengths of the concatenated objects.

For example −

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

This produces the following result −

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

Precedence of Euphoria Operators

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example, x = 7 + 3 * 2

Here, x is assigned 13, not 20 because operator * has higher precedence than +.

Hence it first starts with 3*2 and then adds into 7.

Here operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators is evaluated first.

Category	Operator	Associativity
Postfix	function/type calls
Unary	+ - ! not	Right to left
Multiplicative	* /	Left to right
Additive	+ -	Left to right
Concatenation	&	Left to right
Relational	> >= < <=	Left to right
Equality	= !=	Left to right
Logical AND	and	Left to right
Logical OR	or	Left to right
Logical XOR	xor	Left to right
Comma	,	Left to right

Branching is the most important aspect of any programming language. While writing your program, you may encounter a situation when you have to take a decision or you have to select one option out of the given many options.

Following diagram shows a simple scenario where a program needs to take one of the two paths based on the given condition.

Euphoria provides following three types of decision making (branching or conditional) statements −

if statement
switch statement
ifdef statement

Let us see the statements in detail −

Looping is yet another most important aspect of any programming language. While writing your program, you may encounter a situation when you have to execute same statement many times and sometime may be infinite number of times.

There are several ways to specify for how long the process should go on, and how to stop or otherwise alter it. An iterative block may be informally called a loop, and each execution of code in a loop is called an iteration of the loop.

The following diagram shows a simple logical flow of a loop −

Euphoria provides following three types of loop statements −

while statement
loop until statement
for statement

All the above statements provide you flexibility and ease of use based on different situations. Let us see them in detail one by one −

Program execution flow refers to the order in which program statements get executed. By default the statements get executed one after another.

However; many times the order of execution needs to be altered from the default order, to get the task done.

Euphoria has a number of flow control statements that you can use to arrange the execution order of statements.

The exit statement

Exiting a loop is done with the keyword exit. This causes flow to immediately leave the current loop and recommence with the first statement after the end of the loop.

Syntax

The syntax of an exit statement is as follows −

exit [ "Label Name" ] [Number]

The exit statement terminates the latest and innermost loop until an optional label name or number is specified.

A special form of exit N is exit 0. This leaves all levels of loop, regardless of the depth. Control continues after the outermost loop block. Likewise, exit -1 exits the second outermost loop, and so on.

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)

This produces the following result −

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

The break statement

The break statement works exactly like the exit statement, but applies to if statements or switch statements rather than to loop statements of any kind.

Syntax

The syntax of break statement is as follows −

break [ "Label Name" ] [Number]

The break statement terminates the latest and innermost if or switch block until an optional label name or number is specified.

A special form of break N is break 0. This leaves the outer most if or switch block, regardless of the depth. Control continues after the outermost block. Likewise, break -1 breaks the second outermost if or switch block, and so on.

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)

This produces the following result −

value of a 3
value of b 1

The continue statement

The continue statement continues execution of the loop it applies to by going to the next iteration and skipping the rest of an iteration.

Going to the next iteration means testing a condition variable index and checking whether it is still within bounds.

Syntax

The syntax of continue statement is as follows −

continue [ "Label Name" ] [Number]

The continue statement would re-iterate the latest and inner most loop until an optional label name or number is specified.

A special form of continue N is continue 0. This re-iterate the outer most loop, regardless of the depth. Likewise, continue -1 starts from the second outermost loop, and so on.

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

The retry statement

The retry statement continues execution of the loop it applies to by going to the next iteration and skipping the rest of an iteration.

Syntax

The syntax of retry statement is as follows −

retry [ "Label Name" ] [Number]

The retry statement retries executing the current iteration of the loop it applies to. The statement branches to the first statement of the designated loop neither testing anything nor incrementing the for loop index.

A special form of retry N is retry 0. This retries executing the outer most loop, regardless of the depth. Likewise, retry -1 retries the second outermost loop, and so on.

Normally, a sub-block which contains a retry statement also contains another flow control keyword like exit, continue, or break. Otherwise, the iteration would be endlessly executed.

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

Since retry does not change the value of i and tries again opening the same file, there has to be a way to break from the loop, which the exit statement provides.

The goto statement

The goto statement instructs the computer to resume code execution at a labeled place.

The place to resume execution is called the target of the statement. It is restricted to lie in the current routine, or the current file if outside any routine.

Syntax

The syntax of goto statement is as follows −

goto "Label Name"

The target of a goto statement can be any accessible label statement −

label "Label Name"

Label names must be double quoted constant strings. Characters that are illegal in Euphoria identifiers may appear in a label name, since it is a regular string.

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)

This produces the following result −

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

When a condition is tested by if, elsif, until, or while using and or or operators, a short-circuit evaluation is used. For example −

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

If a < 0 is false, then Euphoria does not bother to test if b is greater than 0. It knows that the overall result is false regardless. Similarly −

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

if a < 0 is true, then Euphoria immediately decides that the result true, without testing the value of b, since the result of this test is irrelevant.

In General, whenever you have a condition of the following form −

A and B

Where A and B can be any two expressions, Euphoria takes a short-cut when A is false and immediately makes the overall result false, without even looking at expression B.

Similarly, whenever you have a condition of the following form −

A or  B

Where A is true, Euphoria skips the evaluation of expression B, and declares the result to be true.

Short-circuit evaluation of and and or takes place for if, elsif, until, and while conditions only. It is not used in other contexts. For example −

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

If short-circuiting were used here, you would set x to 1, and not even look at {1,2,3,4,5}, which would be wrong.

Thus, short-circuiting can be used in if, elsif, until, or while conditions, because you need to only care if the result is true or false, and conditions are required to produce an atom as a result.

A sequence is represented by a list of objects in brace brackets { }, separated by commas. A sequence can contain both atoms and other sequences. For example −

{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

A single element of a sequence may be selected by giving the element number in square brackets. Element numbers start at 1.

For example, if x contains {5, 7.2, 9, 0.5, 13} then x[2] is 7.2.

Suppose x[2] contains {11,22,33}, Now if you ask for x[2] you get {11,22,33} and if you ask for x[2][3], you get the atom 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

Here, length() is the built-in function which returns length of the sequence. The above example produces the following result −

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

Character String

A character string is just a sequence of characters. It may be entered in one of the two ways −

(a) Using Double Quotes −

"ABCDEFG"

(b) Using Raw String Notation −

-- Using back-quotes
`ABCDEFG`

or

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

You can try the following example to understand the concept −

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

This produces the following result −

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

String Arrays

An array of strings can be implemented using Sequences as follows −

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

This produces the following result −

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 Structures

A structure can be implemented using Sequences as follows −

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

This produces the following result −

First Name = John, Last Name = Smith

There are various operations which can be performed directly on sequences. Let us see them in detail −

비뇨기 수술

시퀀스에 적용될 때, 단항 연산자는 실제로 시퀀스의 각 요소에 적용되어 동일한 길이의 결과 시퀀스를 생성합니다.

#!/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에는 프로그램에 날짜와 시간을 반환하는 라이브러리 루틴이 있습니다.

날짜 () 메소드

date () 메서드는 8 개의 원자 요소로 구성된 시퀀스 값을 반환합니다. 다음 예는 자세히 설명합니다.

#!/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 () 메서드는 고정 된 시점 이후 경과 된 초 수를 나타내는 원자 값을 반환합니다. 다음 예는 자세히 설명합니다.

#!/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는 절차를 사용하여 모듈 식 코드를 작성하는 데 필요한 모든 기능을 지원합니다.

이전 장에서 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에서 함수를 정의하는 가장 일반적인 방법은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 함수는 문을 닫기 전에 return 문이 있어야합니다 .end function. 모든 유포리아 개체를 반환 할 수 있습니다. 실제로 일련의 개체를 반환하여 여러 반환 값을 가질 수 있습니다. 예를 들면

return {x_pos, y_pos}

반환 할 항목이 없으면 1 또는 0을 반환합니다. 반환 값 1은 성공을 나타내고 0은 실패를 나타냅니다.

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

공개 방법

파일을 읽거나 쓰기 전에 Euphoria의 내장 open () 메서드를 사용하여 파일을 열어야합니다 . 이 함수는 관련된 다른 지원 메서드를 호출하는 데 사용되는 파일 설명자를 만듭니다.

통사론

integer file_num = open(file_name, access_mode)

위의 메서드는 주어진 파일 이름을 여는 데 오류가있는 경우 -1을 반환합니다. 다음은 매개 변수입니다.

file_name − file_name 인수는 액세스하려는 파일의 이름을 포함하는 문자열 값입니다.
access_mode− access_mode는 파일을 열어야하는 모드를 결정합니다. 예를 들어, 읽기, 쓰기 추가 등이 있습니다. 파일 열기 모드에 대해 가능한 값의 전체 목록은 다음 표에 나와 있습니다.

S. 아니	모드 및 설명
1	r 읽기 전용으로 텍스트 파일을 엽니 다. 파일 포인터는 파일 시작 부분에 위치합니다.
2	rb 바이너리 형식으로 만 읽기 위해 파일을 엽니 다. 파일 포인터는 파일 시작 부분에 위치합니다.
삼	w 쓰기 전용으로 텍스트 파일을 엽니 다. 파일이있는 경우 파일을 덮어 씁니다. 파일이 존재하지 않으면 쓰기를위한 새 파일을 만듭니다.
4	wb 바이너리 형식으로 만 쓰기 위해 파일을 엽니 다. 파일이있는 경우 파일을 덮어 씁니다. 파일이 존재하지 않으면 쓰기를위한 새 파일을 만듭니다.
5	u 읽기와 쓰기를 위해 파일을 엽니 다. 파일 포인터는 파일 시작 부분에 설정됩니다.
6	ub 이진 형식으로 읽고 쓰기 위해 파일을 엽니 다. 파일 포인터는 파일 시작 부분에 위치합니다.
7	a 추가 할 파일을 엽니 다. 파일이있는 경우 파일 포인터는 파일의 끝에 있습니다 (추가 모드). 파일이 존재하지 않으면 쓰기를 위해 새 파일을 생성합니다.
8	ab 바이너리 형식으로 추가 할 파일을 엽니 다. 파일이있는 경우 파일 포인터는 파일의 끝에 있습니다 (추가 모드). 파일이 존재하지 않으면 쓰기를 위해 새 파일을 생성합니다.

예

다음 예제는 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 () 메서드는 기록되지 않은 정보를 플러시하고 파일을 닫습니다. 그 후에는 더 이상 파일을 읽거나 쓸 수 없습니다.

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(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 Library Routines에 나열되어 있습니다.