यूफोरिया - त्वरित गाइड

यूफोरिया खड़ा है End-Uसेवा Pसाथ में घूमना Hierarchical Oके लिए विशेषण Robust Interpreted Applications। यूफोरिया का पहला अवतार रॉबर्ट क्रेग द्वारा एक अटारी मेगा-एसटी पर बनाया गया था और इसे पहली बार 1993 में जारी किया गया था। अब इसे रैपिड परिनियोजन सॉफ्टवेयर द्वारा बनाए रखा गया है।

यह डॉस, विंडोज, लिनक्स, फ्रीबीएसडी और बहुत कुछ के लिए एक नि: शुल्क, सरल, लचीला, सीखने में आसान और व्याख्या की गई लेकिन बेहद तेज 32-बिट उच्च स्तरीय प्रोग्रामिंग भाषा है।

यूफोरिया का उपयोग विंडोज जीयूआई प्रोग्राम, हाई-स्पीड डॉस गेम्स और लिनक्स / फ्रीबीएसडी एक्स विंडोज प्रोग्राम विकसित करने के लिए किया जा रहा है। यूफोरिया का उपयोग सीजीआई (वेबबेड) प्रोग्रामिंग के लिए भी किया जा सकता है।

व्यंजना की विशेषताएँ

यहां यूफोरिया की प्रमुख विशेषताओं की सूची दी गई है -

यह एक सरल, लचीली, शक्तिशाली भाषा परिभाषा है जिसे सीखना और उपयोग करना आसान है।
यह डायनेमिक स्टोरेज आवंटन का समर्थन करता है, जिसका अर्थ है कि प्रोग्रामर को बिना प्रोग्रामर के बढ़ने या सिकुड़ने, स्मृति को आवंटित करने और मुक्त करने की चिंता है। यह कचरा संग्रहण का स्वत: ध्यान रखता है।
यह पर्ल और पायथन जैसे पारंपरिक दुभाषियों की तुलना में बहुत तेज है।
यूफोरिया कार्यक्रम लिनक्स, फ्रीबीएसडी, 32-बिट विंडोज और किसी भी डॉस वातावरण में चलते हैं।
यूफोरिया कार्यक्रम किसी 640K मेमोरी सीमाओं के अधीन नहीं हैं।
यह एक अनुकूलन यूफोरिया-टू-सी अनुवादक प्रदान करता है जिसका उपयोग आप अपने यूफोरिया कार्यक्रम को सी में अनुवाद करने के लिए कर सकते हैं और फिर एक निष्पादन योग्य (.exe) फ़ाइल प्राप्त करने के लिए इसे सी कंपाइलर के साथ संकलित कर सकते हैं। यह आपके प्रोग्राम की गति को 2 से 5 गुना तक बढ़ा सकता है।
अंडररिंग हार्डवेयर पूरी तरह से छिपा हुआ है, जिसका अर्थ है कि प्रोग्राम शब्द-लंबाई के बारे में नहीं जानते हैं, मूल्यों के अंतर्निहित बिट-स्तर प्रतिनिधित्व, बाइट-ऑर्डर आदि।
यूफोरिया इंस्टॉलेशन एक पूर्ण-स्क्रीन स्रोत डीबगर, एक निष्पादन प्रोफाइलर और एक पूर्ण-स्क्रीन मल्टी-फ़ाइल संपादक के साथ आता है।
यह रन-टाइम एरर-हैंडलिंग, सबस्क्रिप्ट और टाइप चेकिंग को सपोर्ट करता है।
यह एक ओपन सोर्स भाषा है और यह पूरी तरह से मुफ्त है।

प्लेटफ़ॉर्म आवश्यकताएँ

यूफोरिया विंडोज, लिनक्स, फ्रीबीएसडी और ओएसएक्स पर उपलब्ध है। यहाँ निम्नलिखित प्लेटफार्मों के साथ नंगे न्यूनतम संस्करण की आवश्यकता है -

WIN32 version- आपको विंडोज 95 या विंडोज के किसी भी बाद के संस्करण की आवश्यकता है। यह XP और Vista पर ठीक चलता है।
Linux version- आपको किसी भी कारण से अप-टू-डेट लिनक्स वितरण की आवश्यकता है, जिसमें libc6 या बाद का संस्करण है। उदाहरण के लिए, Red Hat 5.2 या बाद में ठीक काम करता है।
FreeBSD version - आपको FreeBSD वितरण के लिए किसी भी तरह की आवश्यकता है।
Mac OS X version - आप किसी भी कारण से अप करने की तारीख इंटेल आधारित मैक की जरूरत है।

व्यंजना की सीमाएँ

यहाँ यूफोरिया की कुछ प्रमुख सीमाएँ दी गई हैं -

हालांकि यूफोरिया प्रोग्रामर के लिए सरल, तेज और लचीला है; यह कई महत्वपूर्ण कार्यात्मकताओं के लिए कॉल सहायता प्रदान नहीं करता है। उदाहरण के लिए, नेटवर्क प्रोग्रामिंग।
यूफोरिया का आविष्कार 1993 में किया गया था, और फिर भी आपको इस भाषा पर लिखी गई कोई पुस्तक नहीं मिलेगी। भाषा के लिए बहुत अधिक दस्तावेज उपलब्ध नहीं हैं।

लेकिन इन दिनों, भाषा बहुत तेजी से लोकप्रिय हो रही है और आप जल्द ही भाषा के लिए अच्छी उपयोगिताओं और किताबें उपलब्ध होने की उम्मीद कर सकते हैं।

यूफोरिया लाइसेंसिंग

यह उत्पाद स्वतंत्र और खुला स्रोत है, और कई लोगों के योगदान से लाभान्वित हुआ है। आपके पास विकसित होने वाले किसी भी उत्साह कार्यक्रम को वितरित करने के लिए पूर्ण रॉयल्टी-मुक्त अधिकार हैं।

आइकन फ़ाइलें, जैसे कि euphoria.ico और बायनेरिज़, जो यूफोरिया \ bin में उपलब्ध हैं, को आपके परिवर्तनों के साथ या बिना वितरित किया जा सकता है।

आप ऐसा कर सकते हैं shroud या bindआपका प्रोग्राम और परिणामी फ़ाइलों को रॉयल्टी-फ्री वितरित करें। जब आप यूफोरिया- टू-सी अनुवादक का उपयोग करते हैं तो कुछ अतिरिक्त 3 ^आरडी पार्टी कानूनी प्रतिबंध लागू हो सकते हैं।

उदार Open Source Licenseव्यक्तिगत और व्यावसायिक दोनों उद्देश्यों के लिए यूफोरिया का उपयोग करने की अनुमति देता है। कई अन्य ओपन सोर्स लाइसेंस के विपरीत, आपके परिवर्तनों को ओपन सोर्स बनाने की आवश्यकता नहीं है।

इस अध्याय में विभिन्न प्लेटफार्मों पर यूफोरिया की स्थापना के बारे में वर्णन किया गया है। आप लिनक्स, फ्रीबीएसडी और 32-बिट विंडोज पर यूफोरिया स्थापित करने के लिए चरणों का पालन कर सकते हैं। तो आप अपने काम के माहौल के आधार पर कदम चुन सकते हैं।

लिनक्स, फ्री बीएसडी इंस्टालेशन

आधिकारिक वेबसाइट प्रदान करती है .tar.gzअपने लिनक्स या बीएसडी ओएस पर यूफोरिया स्थापित करने के लिए फ़ाइल। आप यूफोरिया के अपने नवीनतम संस्करण को इसकी आधिकारिक वेबसाइट से डाउनलोड कर सकते हैं - डाउनलोड यूफोरिया ।

एक बार जब आपके पास .tar.gz फ़ाइल होती है, तो यहां आपके लिनक्स पर या यूएफडीआई को स्थापित करने के लिए तीन सरल चरण किए जा सकते हैं -

Step 1 - फ़ाइलें स्थापित करना

डाउनलोड की गई फ़ाइल को अनटार करें euphoria-4.0b2.tar.gzएक निर्देशिका में जहाँ आप यूफोरिया स्थापित करना चाहते हैं। यदि आप इसे / होम डाइरेक्टरी में निम्नानुसार स्थापित करना चाहते हैं, तो -

$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 - पथ की स्थापना

यूफोरिया स्थापित करने के बाद, आपको उचित पथ निर्धारित करने की आवश्यकता है ताकि आपके शेल को आवश्यक यूफोरिया बायनेरिज़ और उपयोगिताओं मिल सकें। आगे बढ़ने से पहले, तीन महत्वपूर्ण पर्यावरण चर निम्नलिखित हैं जिन्हें आपको स्थापित करने की आवश्यकता है -

PATH पर्यावरण चर को बिंदु /home/euphoria-4.0b2/bin निर्देशिका पर सेट करें।
EUDIR पर्यावरण चर को /home/euphoria-4.0b2 पर इंगित करने के लिए सेट करें।
/Home/euphoria-4.0b2/include को इंगित करने के लिए EUINC पर्यावरण चर सेट करें।

ये चर निम्नानुसार सेट किए जा सकते हैं -

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

NOTE- पर्यावरण चर सेट करने के लिए उपयोग किए गए उपरोक्त आदेश आपके शेल के आधार पर भिन्न हो सकते हैं। हमने चर सेट करने के लिए इन कमांड को निष्पादित करने के लिए बैश शेल का उपयोग किया ।

Step 3 - पुष्टिकरण स्थापना

इस बात की पुष्टि करें कि आपने यूफोरिया को सफलतापूर्वक स्थापित किया है या नहीं।

निम्नलिखित आदेश निष्पादित करें -

$eui -version

यदि आपको निम्नलिखित परिणाम मिलते हैं, तो इसका मतलब है कि आपने यूफोरिया को सफलतापूर्वक स्थापित किया है; अन्यथा आपको वापस जाना होगा और सभी चरणों को फिर से जांचना होगा।

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

वह यह है कि, यूफोरिया प्रोग्रामिंग पर्यावरण आपके यूनिक्स मशीन पर तैयार है, और आप आसान चरणों में जटिल कार्यक्रम लिखना शुरू कर सकते हैं।

WIN32, और DOS स्थापना

आधिकारिक वेबसाइट प्रदान करती है .exeअपने Win32 या डॉस ओएस पर यूफोरिया स्थापित करने के लिए फ़ाइल। आप यूफोरिया के अपने नवीनतम संस्करण को इसकी आधिकारिक वेबसाइट से डाउनलोड कर सकते हैं - डाउनलोड यूफोरिया ।

आपके पास .exe फ़ाइल होने के बाद, यहां आपके Win32 या VOS मशीन पर यूफोरिया प्रोग्रामिंग लैंग्वेज स्थापित करने के लिए अनुसरण करने के तीन सरल चरण हैं -

Step 1 - फ़ाइलें स्थापित करना

डाउनलोड पर डबल क्लिक करें .exeसेटअप प्रोग्राम सभी फ़ाइलों को स्थापित करने के लिए। हमने स्थापना के लिए euphoria-40b2.exe फ़ाइल डाउनलोड की है।

फ़ाइल नाम euphoria-40b2.exe उपलब्ध नवीनतम संस्करण पर निर्भर करता है। हम भाषा के संस्करण 4 बीटा 2 का उपयोग करते हैं।

डिफ़ॉल्ट रूप से यूफोरिया को C: \ euphoria-40b2 डायरेक्टरी में स्थापित किया जाएगा, लेकिन आप एक वांछित स्थान का चयन भी कर सकते हैं।

Step 2 - मशीन को रिबूट करना

स्थापना को पूरा करने के लिए अपनी मशीन को फिर से बूट करें।

Step 3 - पुष्टिकरण स्थापना

निम्नलिखित आदेश निष्पादित करें -

c:\>eui -version

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

c:\>

वह यह है कि, आपके Win32 मशीन पर यूफोरिया प्रोग्रामिंग पर्यावरण तैयार है, और आप आसान चरणों में जटिल प्रोग्राम लिखना शुरू कर सकते हैं।

यूफोरिया इंटरप्रिटेटर

आपके द्वारा उपयोग किए जा रहे प्लेटफॉर्म के आधार पर, यूफोरिया के कई दुभाषिए हैं -

मुख्य दुभाषिया है eui।
खिड़कियों के प्लेटफार्मों पर, आपके पास दो विकल्प हैं। अगर तुम दौड़ते होeuiतब एक कंसोल विंडो बनाई जाती है। अगर तुम दौड़ते होeuiw फिर कोई कंसोल नहीं बनाया गया है, जिससे यह GUI अनुप्रयोगों के लिए उपयुक्त है।
यूफोरिया आपकी पसंद के फ़ाइल एक्सटेंशन की परवाह नहीं करता है। हालांकि सम्मेलन द्वारा; कंसोल-आधारित एप्लिकेशन के साथ आते हैं.ex विस्तार।
GUI- आधारित एप्लिकेशन हैं .exw एक्सटेंशन और शामिल फ़ाइलों में है .e विस्तार।

यूफोरिया भाषा में पर्ल, सी और जावा की कई समानताएं हैं। हालाँकि, भाषाओं के बीच कुछ निश्चित अंतर हैं। इस अध्याय को यूफोरिया में अपेक्षित सिंटैक्स पर गति करने के लिए जल्दी से तैयार किया गया है।

यह ट्यूटोरियल मानता है कि आप लिनक्स के साथ काम कर रहे हैं और सभी उदाहरण लिनक्स प्लेटफॉर्म पर लिखे गए हैं। लेकिन यह देखा गया है कि लिनक्स और WIN32 पर प्रोग्राम सिंटैक्स में कोई प्रमुख अंतर नहीं है। इसलिए आप Win32 पर समान चरणों का पालन कर सकते हैं।

पहला यूफोरिया कार्यक्रम

आइए हम एक स्क्रिप्ट में एक साधारण यूफोरिया प्रोग्राम लिखते हैं। 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 डिवाइस को इंगित करता है।

यूफोरिया आइडेंटिफ़ायर

यूफोरिया आइडेंटिफायर एक ऐसा नाम है जिसका इस्तेमाल वैरिएबल, फंक्शन, क्लास, मॉड्यूल या अन्य ऑब्जेक्ट को पहचानने के लिए किया जाता है। एक पहचानकर्ता अक्षर A से Z या z से शुरू होता है और उसके बाद अक्षर, अंक या अंडरस्कोर होता है।

यूफोरिया पहचान के भीतर @, $, और% जैसे विराम चिह्न वर्णों को अनुमति नहीं देता है।

यूफोरिया एक केस सेंसिटिव प्रोग्रामिंग लैंग्वेज है। इस प्रकारManpower तथा manpowerयूफोरिया में दो अलग-अलग पहचानकर्ता हैं। उदाहरण के लिए, मान्य पहचानकर्ता हैं -

n
color26
ShellSort
quick_sort
a_very_long_indentifier

सुरक्षित शब्द

निम्न सूची यूफोरिया में आरक्षित शब्दों को दर्शाती है। ये आरक्षित शब्द निरंतर या परिवर्तनशील या किसी अन्य पहचानकर्ता नाम के रूप में उपयोग नहीं किए जा सकते हैं। यूफोरिया कीवर्ड में केवल निचले अक्षर होते हैं।

तथा	बाहर जाएं	अवहेलना
जैसा	निर्यात	प्रक्रिया
टूटना	fallthru	जनता
द्वारा	के लिये	पुन: प्रयास करें
मामला	समारोह	वापसी
स्थिर	वैश्विक	सामान्य
जारी रखें	के लिए जाओ	स्विच
कर	अगर	फिर
अन्य	ifdef	सेवा
elsedef	शामिल	प्रकार
elsif	लेबल	जब तक
elsifdef	लूप	जबकि
समाप्त	नाम स्थान	साथ में
प्रवेश	नहीं	के बिना
enum	या	XOR

भाव

व्यंजना आपको भावों को आधार बनाकर परिणामों की गणना करती है। हालांकि, यूफोरिया में आप एक अभिव्यक्ति के साथ डेटा के संपूर्ण अनुक्रमों पर गणना कर सकते हैं।

आप एक क्रम को संभाल सकते हैं क्योंकि आप एक ही संख्या को संभालेंगे। इसे कॉपी किया जा सकता है, एक सबरूटीन में पारित किया जा सकता है, या एक इकाई के रूप में गणना की जा सकती है। उदाहरण के लिए -

{1,2,3} + 5

यह एक अभिव्यक्ति है जो अनुक्रम {1, 2, 3} और परमाणु 5 को जोड़ता है जिसके परिणामस्वरूप अनुक्रम {6, 7, 8} प्राप्त होता है। आप बाद के अध्यायों में अनुक्रम सीखेंगे।

कोड के ब्लॉक

यूफोरिया सीखने के दौरान पहले कैविट्स प्रोग्रामर में से एक का सामना करना पड़ता है, यह तथ्य है कि प्रक्रिया और फ़ंक्शन परिभाषाओं या प्रवाह नियंत्रण के लिए कोड के ब्लॉक को इंगित करने के लिए कोई ब्रेसिज़ नहीं हैं। संबंधित कीवर्ड द्वारा कोड के ब्लॉक निरूपित किए जाते हैं।

निम्न उदाहरण दिखाता है if...then...end if ब्लॉक -

if condition then
   code block comes here
end if

मल्टी-लाइन स्टेटमेंट

यूफोरिया में बयान आम तौर पर एक नई लाइन के साथ समाप्त होते हैं। यूफोरिया हालांकि, कई लाइनों में एक ही बयान लिखने की अनुमति देता है। उदाहरण के लिए -

total = item_one + 
   item_two + 
   item_three

वर्ण से बचो

एस्केप पात्रों को बैक-स्लैश का उपयोग करके दर्ज किया जा सकता है। उदाहरण के लिए -

निम्न तालिका भागने या गैर-मुद्रण योग्य वर्णों की एक सूची है जिसे बैकलैश नोटेशन के साथ दर्शाया जा सकता है।

बैकस्लैश नोटेशन	विवरण
\ n	नई पंक्ति
\ r	कैरिज रिटर्न
\ t	टैब
\\	बैकस्लैश
\ "	दोहरे उद्धरण
\ '	एकल बोली

यूफोरिया में टिप्पणियाँ

किसी भी टिप्पणी को संकलक द्वारा अनदेखा किया जाता है और निष्पादन की गति पर कोई प्रभाव नहीं पड़ता है। अपने कार्यक्रम में अधिक टिप्पणियों का उपयोग करने के लिए इसे अधिक पठनीय बनाने की सलाह दी जाती है।

टिप्पणी पाठ के तीन रूप हैं -

टिप्पणियाँ दो डैश से शुरू होती हैं और वर्तमान लाइन के अंत तक विस्तारित होती हैं।
मल्टी-लाइन प्रारूप टिप्पणी को /*..*/ के अंदर रखा जाता है, भले ही वह एक अलग लाइन पर हो।
आप दो वर्ण अनुक्रम "#!" के साथ विशेष टिप्पणी का उपयोग कर सकते हैं। केवल कार्यक्रम की पहली पंक्ति पर।

उदाहरण

#!/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- आप "#!" के साथ विशेष टिप्पणी का उपयोग कर सकते हैं। यह लिनक्स शेल को सूचित करता है कि आपकी फ़ाइल यूफोरिया दुभाषिया द्वारा निष्पादित की जानी चाहिए।

वेरिएबल्स मूल्यों को संग्रहीत करने के लिए आरक्षित मेमोरी स्थानों के अलावा कुछ भी नहीं हैं। इसका मतलब है जब आप एक वैरिएबल बनाते हैं, तो आप मेमोरी में कुछ जगह आरक्षित करते हैं।

एक चर के डेटा प्रकार के आधार पर, दुभाषिया मेमोरी आवंटित करता है और यह तय करता है कि आरक्षित मेमोरी में क्या संग्रहीत किया जा सकता है। इसलिए, भिन्न प्रकार के डेटा को चर के लिए असाइन करके, आप इन चर में पूर्णांक, दशमलव या वर्ण संग्रहीत कर सकते हैं। अलग-अलग अध्याय में यूफोरिया डेटा प्रकारों की व्याख्या की गई है।

इन मेमोरी स्थानों को चर कहा जाता है क्योंकि उनके मूल्य को उनके जीवन काल के दौरान बदला जा सकता है।

परिवर्तनीय घोषणा

यूफोरिया चर को स्पष्ट रूप से मेमोरी स्पेस आरक्षित करने के लिए घोषित किया जाना चाहिए। इस प्रकार एक वैरिएबल की घोषणा अनिवार्य है, इससे पहले कि आप एक वैरिएबल को एक मूल्य प्रदान करें।

परिवर्तनीय घोषणाओं में एक प्रकार का नाम होता है जिसके बाद चरों की सूची घोषित की जाती है। उदाहरण के लिए -

integer x, y, z

sequence a, b, x

जब आप एक चर घोषित करते हैं, तो आप चर का नाम देते हैं और आप परिभाषित करते हैं कि आपके प्रोग्राम के निष्पादन के दौरान वैधानिक रूप से किस प्रकार के मान निर्दिष्ट किए जा सकते हैं।

चर घोषित करने का सरल कार्य इसके लिए कोई मूल्य प्रदान नहीं करता है। यदि आप इसे किसी भी मूल्य को निर्दिष्ट करने से पहले पढ़ने का प्रयास करते हैं, तो यूफोरिया एक रन-टाइम त्रुटि जारी करेगा क्योंकि "चर xyz को कभी भी एक मान नहीं सौंपा गया है" ।

मान देना

समान चिह्न (=) का उपयोग चर को मान निर्दिष्ट करने के लिए किया जाता है। चर निम्नलिखित तरीके से सौंपा जा सकता है -

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 और "जॉन" क्रमशः काउंटर , मील और नाम चर के लिए निर्दिष्ट मान हैं। यह कार्यक्रम निम्नलिखित परिणाम उत्पन्न करता है -

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 बयान।
में एक if बयान, गुंजाइश घोषणा पर शुरू होता है और या तो अगले पर समाप्त होता है else, elsif या end if बयान।
यदि किसी रूटीन के भीतर एक वेरिएबल घोषित किया जाता है, तो वेरिएबल का दायरा डिक्लेरेशन पर शुरू होता है और रूटीन के अंतिम स्टेटमेंट पर समाप्त होता है। यह एक निजी चर के रूप में जाना जाता है।
यदि किसी रूटीन के बाहर वैरिएबल घोषित किया जाता है, तो इसका दायरा डिक्लेरेशन पर शुरू होता है और समाप्त हो जाता है और फाइल के अंत में इसे घोषित किया जाता है। इसे एक मॉड्यूल वेरिएबल के रूप में जाना जाता है।
एक का दायरा constant इसमें स्कोप मोडिफायर नहीं है, घोषणा पर शुरू होता है और समाप्त होता है और फाइल के अंत में इसे घोषित किया जाता है।
एक का दायरा enum इसमें स्कोप मोडिफायर नहीं है, घोषणा पर शुरू होता है और समाप्त होता है और फाइल के अंत में इसे घोषित किया जाता है।
सभी का दायरा procedures, functions तथा types, जिसमें स्कोप मोडिफायर नहीं है, स्रोत फ़ाइल की शुरुआत में शुरू होता है और स्रोत फ़ाइल के अंत में समाप्त होता है जिसमें वे घोषित किए जाते हैं।

स्थिरांक, एनम, मॉड्यूल चर, प्रक्रियाएं, कार्य और प्रकार, जिनमें गुंजाइश संशोधक नहीं है, को संदर्भित किया जाता है locals। हालांकि, इन पहचानकर्ताओं के पास अपनी घोषणा से पहले एक गुंजाइश संशोधक हो सकता है, जो उनके दायरे को उस फ़ाइल से परे विस्तारित करने का कारण बनता है जिसे वे घोषित किए जाते हैं।

यदि कीवर्ड globalघोषणा से पहले, इन पहचानकर्ताओं का दायरा पूरे आवेदन तक फैला हुआ है। उन्हें एप्लिकेशन फ़ाइलों में कहीं भी कोड द्वारा एक्सेस किया जा सकता है।
यदि कीवर्ड publicपछाड़ घोषणा, गुंजाइश है कि स्पष्ट रूप से, फ़ाइल जिसमें पहचानकर्ता घोषित किया जाता है शामिल हैं या जो किसी फ़ाइल शामिल है कि बदले में किसी भी फाइल को किसी भी फाइल तक फैली सार्वजनिक युक्त फ़ाइल शामिल सार्वजनिक घोषणा।
यदि कीवर्ड export घोषणा से पहले, गुंजाइश केवल किसी भी फ़ाइल तक फैली होती है जिसमें सीधे उस फ़ाइल को शामिल किया जाता है जिसमें पहचानकर्ता घोषित होता है।

जब आप includeएक अन्य फ़ाइल में एक यूफोरिया फ़ाइल, केवल एक गुंजाइश संशोधक का उपयोग करके घोषित किए गए पहचानकर्ता शामिल करने वाली फ़ाइल के लिए सुलभ हैं । शामिल फ़ाइल में अन्य घोषणाएँ शामिल फ़ाइल करने के लिए अदृश्य हैं ।

कॉन्स्टेंट भी वैरिएबल होते हैं जिन्हें एक प्रारंभिक मूल्य दिया जाता है जो प्रोग्राम के जीवन में कभी नहीं बदल सकते हैं। यूफोरिया निरंतर कीवर्ड का उपयोग करके स्थिरांक को परिभाषित करने की अनुमति देता है -

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

किसी भी अभिव्यक्ति का परिणाम एक निरंतर को सौंपा जा सकता है, यहां तक कि पहले से परिभाषित कार्यों के लिए कॉल भी शामिल है, लेकिन असाइनमेंट किए जाने के बाद, स्थिर चर का मान "लॉक इन" है।

हो सकता है कि एक सबरूटीन के अंदर स्थिरांक घोषित नहीं किए गए हों। एक का दायराconstant इसमें स्कोप मोडिफायर नहीं है, घोषणा पर शुरू होता है और समाप्त होता है और फाइल के अंत में इसे घोषित किया जाता है।

उदाहरण

#!/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 इसमें स्कोप मोडिफायर नहीं है, घोषणा पर शुरू होता है और समाप्त होता है और फाइल के अंत में इसे घोषित किया जाता है।

उदाहरण

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

मेमोरी में संग्रहीत डेटा कई प्रकार के हो सकते हैं। उदाहरण के लिए, किसी व्यक्ति की आयु को संख्यात्मक मान के रूप में संग्रहीत किया जाता है और उसके पते को अल्फ़ान्यूमेरिक वर्णों के रूप में संग्रहीत किया जाता है।

यूफोरिया के कुछ मानक प्रकार हैं जो उन पर संभव संचालन और उनमें से प्रत्येक के लिए भंडारण विधि को परिभाषित करने के लिए उपयोग किए जाते हैं।

यूफोरिया में चार मानक डेटा प्रकार हैं -

integer
atom
sequence
object

परमाणुओं और अनुक्रमों की समझ, यूफोरिया को समझने की कुंजी है।

पूर्णांकों

यूफोरिया पूर्णांक डेटा प्रकार संख्यात्मक मानों को संग्रहीत करता है। इन्हें निम्नानुसार घोषित और परिभाषित किया गया है -

integer var1, var2

var1 = 1
var2 = 100

प्रकार पूर्णांक के साथ घोषित चर के साथ परमाणु होना चाहिए integerमान -1073741824 से +1073741823 समावेशी। आप लगभग 15 दशमलव अंकों तक बड़े पूर्णांक मानों पर सटीक गणना कर सकते हैं, लेकिन पूर्णांक के बजाय उन्हें परमाणु घोषित कर सकते हैं।

परमाणुओं

यूफोरिया में सभी डेटा ऑब्जेक्ट या तो परमाणु या अनुक्रम हैं। एक परमाणु एक एकल संख्यात्मक मान है। परमाणुओं में कोई पूर्णांक या डबल-सटीक फ़्लोटिंग पॉइंट मान हो सकता है। यूफोरिया परमाणुओं को घोषित किया जाता है और निम्नानुसार परिभाषित किया जाता है

atom var1, var2, var3

var1 = 1000
var2 = 198.6121324234
var3 = 'E'

परमाणु सटीकता के 15 दशमलव अंकों के साथ लगभग -1e300 से + 1e300 तक हो सकते हैं। एक व्यक्तिगत चरित्र एक हैatomजो एकल उद्धरण का उपयोग करके दर्ज किया जाना चाहिए। उदाहरण के लिए, निम्नलिखित सभी कथन कानूनी हैं -

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

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

दृश्यों

एक अनुक्रम संख्यात्मक मानों का एक संग्रह है जो उनके सूचकांक के माध्यम से पहुँचा जा सकता है। यूफोरिया में सभी डेटा ऑब्जेक्ट या तो परमाणु या अनुक्रम हैं।

अनुक्रम सूचकांक अन्य प्रोग्रामिंग भाषाओं के विपरीत 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}

आप यूफोरिया - अनुक्रम में अनुक्रम के बारे में अधिक जानेंगे ।

वस्तुओं

यह यूफोरिया में एक सुपर डेटा प्रकार है जो परमाणुओं, अनुक्रमों या पूर्णांकों सहित किसी भी मूल्य पर ले सकता है। यूफोरिया वस्तुओं को घोषित और परिभाषित किया जाता है -

object var1, var2, var3

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

ऑब्जेक्ट में निम्न मान हो सकते हैं -

एक क्रम
एक परमाणु
पूर्णांक
पूर्णांक एक फ़ाइल संख्या के रूप में उपयोग किया जाता है
एक स्ट्रिंग अनुक्रम, या एकल-वर्ण परमाणु

यूफोरिया वैरिएबल में हेरफेर करने के लिए ऑपरेटरों का एक समृद्ध सेट प्रदान करता है। हम सभी यूफोरिया ऑपरेटरों को निम्नलिखित समूहों में विभाजित कर सकते हैं -

अंकगणितीय आपरेटर
संबंधपरक संकारक
लॉजिकल ऑपरेटर्स
असाइनमेंट ऑपरेटर्स
विविध संचालक

अरिथमेटिक ऑपरेटर्स

अंकगणितीय संचालकों का उपयोग गणितीय अभिव्यक्तियों में उसी तरह किया जाता है जैसे कि वे बीजगणित में उपयोग किए जाते हैं। निम्न तालिका अंकगणितीय ऑपरेटरों को सूचीबद्ध करती है। पूर्णांक चर मान लें 10 और चर B 20 धारण करता है -

उदाहरण दिखाएं

ऑपरेटर	विवरण	उदाहरण
+	परिवर्धन - ऑपरेटर के दोनों ओर मान जोड़ता है	A + B 30 देगा
-	घटाव - बाएं हाथ के ऑपरेंड से दाहिने हाथ के ऑपरेंड को घटाते हैं	A - B देगा -10
*	गुणन - ऑपरेटर के दोनों ओर मूल्यों को गुणा करता है	A * B 200 देगा
/	डिवीजन - दाएं हाथ के ऑपरेंड द्वारा बाएं हाथ के ऑपरेशन को विभाजित किया जाता है	B / A 2 देगा
+	यूनीरी प्लस - इसका वेरिएबल वैल्यू पर कोई प्रभाव नहीं पड़ता है।	+ B 20 देता है
-	अनार्य माइनस - यह दिए गए चर का एक नकारात्मक मान बनाता है।	-बी देता है -20

रिलेशनल ऑपरेटर्स

यूफोरिया भाषा द्वारा समर्थित संबंधपरक ऑपरेटर निम्नलिखित हैं। चर A मानें 10 और चर B 20 धारण करता है -

उदाहरण दिखाएं

ऑपरेटर	विवरण	उदाहरण
=	जाँच करता है कि दो ऑपरेंड का मूल्य बराबर है या नहीं, यदि हाँ तो स्थिति सच हो जाती है।	(ए = बी) सच नहीं है।
! =	जाँच करता है कि दो ऑपरेंड का मान बराबर है या नहीं, यदि मान बराबर नहीं हैं तो स्थिति सत्य हो जाती है।	(ए! = बी) सच है।
>	यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से अधिक है, यदि हाँ, तो स्थिति सत्य है।	(ए> बी) सच नहीं है।
<	यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम है, यदि हाँ, तो स्थिति सही है।	(ए <बी) सच है।
> =	जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से अधिक या उसके बराबर है, यदि हाँ तो स्थिति सच हो जाती है।	(ए> = बी) सच नहीं है।
<=	जाँच करता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम या उसके बराबर है, यदि हाँ तो स्थिति सत्य हो जाती है।	(ए <= बी) सच है।

लॉजिकल ऑपरेटर्स

निम्न तालिका तार्किक ऑपरेटरों को सूचीबद्ध करती है। बूलियन वेरिएबल्स A धारण 1 और चर B धारण 0 तो -

उदाहरण दिखाएं

ऑपरेटर	विवरण	उदाहरण
तथा	जिसे लॉजिकल एंड ऑपरेटर कहा जाता है। अगर दोनों ऑपरेशंस नॉन जीरो हैं तो फिर हालत सच हो जाती है।	(ए और बी) गलत है।
या	जिसे लॉजिकल या ऑपरेटर कहा जाता है। यदि दोनों संचालकों में से कोई भी गैर शून्य है तो स्थिति सत्य हो जाती है।	(ए या बी) सच है।
XOR	जिसे लॉजिकल XOR ऑपरेटर कहा जाता है। हालत सच है अगर उनमें से एक सच है, अगर दोनों ऑपरेंड सच्चे या झूठे हैं तो हालत झूठी हो जाती है।	(एक एक्सोर बी) सच है।
नहीं	जिसे लॉजिकल नॉट ऑपरेटर कहा जाता है, जो परिणाम को नकारता है। इस संचालक के प्रयोग से सत्य असत्य हो जाता है और असत्य सत्य हो जाता है	नहीं (बी) सच है।

आप इन ऑपरेटरों को 1 या 0. के अलावा अन्य नंबरों पर भी लागू कर सकते हैं। सम्मेलन है: शून्य का अर्थ है असत्य और गैर-शून्य का अर्थ है सत्य ।

असाइनमेंट ऑपरेटर्स

यूफोरिया भाषा द्वारा समर्थित असाइनमेंट ऑपरेटर निम्नलिखित हैं -

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

कमांड लाइन विकल्प

एक उपयोगकर्ता एक यूफोरिया स्क्रिप्ट को कमांड लाइन विकल्प पास कर सकता है और इसे एक अनुक्रम का उपयोग करके एक्सेस किया जा सकता है 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()यूफोरिया का अंतर्निहित कार्य है। अब यदि आप इस लिपि को निम्न प्रकार से चलाते हैं -

$eui test.ex "one" "two"

यह निम्न परिणाम उत्पन्न करता है -

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

यूफोरिया में एक पुस्तकालय दिनचर्या है जो आपके कार्यक्रम की तारीख और समय लौटाती है।

तिथि () विधि

दिनांक () विधि एक अनुक्रम मान देता है जो आठ परमाणु तत्वों से बना होता है। निम्नलिखित उदाहरण इसे विस्तार से बताते हैं -

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

समय () विधि

समय () विधि एक परमाणु मान लौटाता है, जो एक निश्चित समय के बाद बीते हुए सेकंड की संख्या का प्रतिनिधित्व करता है। निम्नलिखित उदाहरण इसे विस्तार से बताते हैं -

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

दिनांक और समय संबंधित तरीके

यूफोरिया तरीकों की एक सूची प्रदान करता है जो आपको तारीख और समय में हेरफेर करने में मदद करता है। इन विधियों को यूफोरिया लाइब्रेरी रूटीन में सूचीबद्ध किया गया है ।

एक प्रक्रिया पुन: प्रयोज्य कोड का एक समूह है जिसे आपके कार्यक्रम में कहीं से भी बुलाया जा सकता है। यह एक ही कोड को बार-बार लिखने की आवश्यकता को समाप्त करता है। यह प्रोग्रामर को मॉड्यूलर कोड लिखने में मदद करता है।

किसी अन्य अग्रिम प्रोग्रामिंग भाषा की तरह, यूफोरिया भी प्रक्रियाओं का उपयोग करके मॉड्यूलर कोड लिखने के लिए आवश्यक सभी सुविधाओं का समर्थन करता है।

आपने पिछले अध्यायों में प्रिंटफ () और लंबाई () जैसी प्रक्रियाओं को देखा होगा । हम बार-बार इन प्रक्रियाओं का उपयोग कर रहे हैं लेकिन वे केवल एक बार कोर यूफोरिया में लिखे गए हैं।

यूफोरिया आपको अपनी प्रक्रियाओं को भी लिखने की अनुमति देता है। यह खंड बताता है कि यूफोरिया में अपनी प्रक्रिया कैसे लिखें।

प्रक्रिया परिभाषा

इससे पहले कि आप एक प्रक्रिया का उपयोग करें, आपको इसे परिभाषित करने की आवश्यकता है। यूफोरिया में एक प्रक्रिया को परिभाषित करने का सबसे आम तरीका हैprocedure कीवर्ड, उसके बाद एक अद्वितीय प्रक्रिया नाम, मापदंडों की एक सूची (जो खाली हो सकती है), और एक स्टेटमेंट ब्लॉक के साथ समाप्त होता है end procedureबयान। मूल सिंटैक्स नीचे दिखाया गया है -

procedure procedurename(parameter-list)

   statements
   ..........

end procedure

उदाहरण

एक सरल प्रक्रिया जिसे हेलो कहा जाता है जो कोई पैरामीटर नहीं लेती है उसे यहां परिभाषित किया गया है -

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.

यूफोरिया फ़ंक्शन केवल प्रक्रियाओं की तरह हैं, लेकिन वे एक मूल्य लौटाते हैं, और एक अभिव्यक्ति में उपयोग किया जा सकता है। यह अध्याय बताता है कि यूफोरिया में अपने स्वयं के कार्यों को कैसे लिखना है।

कार्य की परिभाषा

किसी फ़ंक्शन का उपयोग करने से पहले हमें इसे परिभाषित करने की आवश्यकता होती है। यूफोरिया में किसी फ़ंक्शन को परिभाषित करने का सबसे आम तरीका हैfunction कीवर्ड, उसके बाद एक अद्वितीय फ़ंक्शन नाम, मापदंडों की एक सूची (जो खाली हो सकती है), और एक स्टेटमेंट ब्लॉक जिसके साथ समाप्त होता है end functionबयान। मूल सिंटैक्स यहाँ दिखाया गया है -

function functionname(parameter-list)

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

end function

उदाहरण

एक साधारण फ़ंक्शन कहलाता है जो कोई पैरामीटर नहीं लेता है, यहाँ परिभाषित किया गया है -

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.

वापसी वक्तव्य

एक यूफोरिया फ़ंक्शन को स्टेटमेंट बंद करने से पहले रिटर्न स्टेटमेंट होना चाहिएend function। किसी भी यूफोरिया वस्तु को वापस किया जा सकता है। आप वास्तव में, वस्तुओं के अनुक्रम को वापस करके, कई रिटर्न मान रख सकते हैं। उदाहरण के लिए

return {x_pos, y_pos}

यदि आपके पास लौटने के लिए कुछ भी नहीं है, तो बस 1 या 0. लौटाएं। वापसी मान 1 सफलता को इंगित करता है और 0 विफलता दर्शाता है

यूफोरिया प्रोग्रामिंग भाषा का उपयोग करते हुए, आप अपने फ्लॉपी ड्राइव या हार्ड ड्राइव पर फ़ाइल डेटा को पढ़ने और बदलने वाले प्रोग्राम लिख सकते हैं या आउटपुट के रूप में नई फाइलें बना सकते हैं। आप अपने कंप्यूटर पर प्रिंटर और मॉडेम जैसे उपकरणों का उपयोग कर सकते हैं।

इस अध्याय में यूफोरिया में उपलब्ध सभी बुनियादी I / O कार्यों का वर्णन किया गया है। अधिक कार्यों की जानकारी के लिए, कृपया मानक यूफोरिया प्रलेखन देखें।

स्क्रीन पर प्रदर्शित करना

आउटपुट उत्पन्न करने का सबसे सरल तरीका पुट () स्टेटमेंट का उपयोग करना है जहां आप स्क्रीन पर प्रदर्शित होने के लिए किसी भी स्ट्रिंग को पास कर सकते हैं। एक अन्य विधि प्रिंटफ () है जिसका उपयोग आप गतिशील मानों का उपयोग करके स्ट्रिंग को प्रारूपित करने के लिए भी कर सकते हैं।

ये विधियाँ उन भावों को परिवर्तित करती हैं जिन्हें आप उन्हें एक स्ट्रिंग में बदल देते हैं और परिणाम को मानक आउटपुट पर लिखते हैं -

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

फ़ाइलें खोलना और बंद करना

यूफोरिया मूलभूत रूप से फाइलों को मैनिपुलेट करने के लिए आवश्यक बुनियादी तरीके प्रदान करता है। आप निम्न विधियों का उपयोग करके अपनी अधिकांश फ़ाइल हेरफेर कर सकते हैं -

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

खुला विधि

किसी फ़ाइल को पढ़ने या लिखने से पहले, आपको इसे यूफोरिया की अंतर्निहित खुली () विधि का उपयोग करके खोलना होगा । यह फ़ंक्शन एक फाइल डिस्क्रिप्टर बनाता है जो इसके साथ जुड़े अन्य सहायक तरीकों को कॉल करने के लिए उपयोग किया जाता है।

वाक्य - विन्यास

integer file_num = open(file_name, access_mode)

उपरोक्त विधि -1 -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 द्विआधारी प्रारूप में लागू करने के लिए एक फ़ाइल खोलता है। यदि फ़ाइल मौजूद है तो फ़ाइल पॉइंटर फ़ाइल के अंत में है (एपेंड मोड)। यदि फ़ाइल मौजूद नहीं है, तो यह लिखने के लिए एक नई फ़ाइल बनाता है।

उदाहरण

निम्न उदाहरण आपके लिनक्स सिस्टम पर वर्तमान निर्देशिका में एक नई पाठ फ़ाइल बनाता है -

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

फाइल पढ़ना और लिखना

पाठ मोड या बाइनरी मोड में फ़ाइल पढ़ते या लिखते समय हमारे जीवन को आसान बनाने के लिए यूफ़ोरिया एक्सेस विधियों का एक सेट प्रदान करता है। आइए देखते हैं कि फाइल को पढ़ने और लिखने के लिए प्रिंटफ () और हो जाता है () तरीकों का उपयोग कैसे करें।

Printf () विधि

Printf () विधि एक खुली फाइल करने के लिए किसी भी स्ट्रिंग लिखता है।

वाक्य - विन्यास

printf(fn, st, x)

यहाँ पैरामीटर हैं -

fn - फाइल डिस्क्रिप्टर ओपन () विधि से प्राप्त हुआ।
st - प्रारूप स्ट्रिंग जहाँ दशमलव या परमाणु को% d का उपयोग करके स्वरूपित किया जाता है और स्ट्रिंग या अनुक्रम को% s का उपयोग करके स्वरूपित किया जाता है।
x- यदि x एक अनुक्रम है, तो सेंट से प्रारूप विनिर्देशक x के संगत तत्वों के साथ मेल खाते हैं। यदि x एक परमाणु है, तो सामान्य रूप से सेंट में केवल एक प्रारूप निर्दिष्ट होता है और इसे x पर लागू किया जाता है। तथापि; यदि सेंट में कई प्रारूप विनिर्देशक हैं, तो प्रत्येक को एक ही मान 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)

यहाँ पारित पैरामीटर फ़ाइल विवरण विवरण () विधि द्वारा रिटर्न है । यह विधि फ़ाइल लाइन की शुरुआत से लाइन द्वारा पढ़ना शुरू कर देती है। वर्णों का मान 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

यूफोरिया कई तरीकों की एक सूची प्रदान करता है जो आपको फाइलों में हेरफेर करने में मदद करता है। इन विधियों को यूफोरिया लाइब्रेरी रूटीन में सूचीबद्ध किया गया है ।