लोलकोड - क्विक गाइड

LOLCODE इंटरनेट पर अजीब बातों से प्रेरित एक गूढ़ प्रोग्रामिंग भाषा है। यह प्रोग्रामिंग भाषा डिजाइन की सीमाओं का परीक्षण करने के लिए डिज़ाइन किया गया है।

यह अध्याय आपको LOLCODE के लिए स्थानीय वातावरण की स्थापना, विंडोज पर इसे स्थापित करने और ट्यूटोरियल स्क्रिप्ट -कोडिंग ग्राउंड पर ऑनलाइन इसकी स्क्रिप्ट निष्पादित करने से परिचित करेगा।

स्थानीय पर्यावरण की स्थापना

LOLCODE दुभाषिया C भाषा में लिखा गया है। यह कई प्लेटफार्मों पर LOLCODE भाषा में लिखे गए कोड की व्याख्या करता है। LOLCODE दुभाषिया lci के रूप में जाना जाता है, जो LOLCODE दुभाषिया के लिए खड़ा है।

कृपया ध्यान दें कि LOLCODE केवल मैक ऑपरेटिंग सिस्टम के लिए इंटरप्रेटर की प्रत्यक्ष स्थापना का समर्थन करता है। अपने ऑपरेटिंग सिस्टम में LOLCODE इंस्टॉल करने के लिए, आपको नीचे दिए गए चरणों का पालन करना होगा -

  • प्रेस कमांड + स्पेस, और टाइप करें Terminal और दबाएँ enter/return चाभी
  • टर्मिनल ऐप में चलाएं
  • $ git क्लोन https://github.com/justinmeza/lci.git
  • $ cd lci
  • $ सेमी।
  • $ मे && मेक इनस्टॉल

विंडोज पर स्थापना

यदि आपको विंडोज ऑपरेटिंग सिस्टम पर LOLCODE स्थापित करने की आवश्यकता है, तो कृपया इन चरणों को अपनाएं -

  • सबसे पहले अपने पर्यावरण चर पथ में मिनगडब्ल्यू और पायथन जोड़ें। ऐसा करने के लिए, राइट क्लिक करेंMy Computer, चुनें Properties, फिर सेलेक्ट करें Advanced system settings. चुनते हैं Environment Variables। इस बॉक्स में, का चयन करेंPATH चर और फिर क्लिक करें Edit

  • अब, "; C: \ MinGW \ bin; C: \ Python32" को उस पथ के अंत में जोड़ें।

  • अगला, खोलें Command Prompt और उदाहरण के लिए, "cd" कमांड का उपयोग करके प्रोजेक्ट डायरेक्टरी पर जाएँ।

  • स्क्रिप्ट इंस्टॉल करें चलाएँ।

ट्यूटोरियल स्क्रिप्ट के साथ ऑनलाइन स्क्रिप्टिंग निष्पादित करना - कोडिंग ग्राउंड

अपनी स्क्रिप्ट को आसानी से और तेज़ी से निष्पादित करने के लिए, TutorialsPoint द्वारा उपलब्ध कोडिंगग्राउंड प्लेटफ़ॉर्म का उपयोग करें । इसके लिए, ऑनलाइन अपनी स्क्रिप्ट निष्पादित करने के लिए निम्न लिंक पर जाएं -

https://www.tutorialspoint.com/execute_lolcode_online.php

LOLCODE में अन्य प्रोग्रामिंग भाषाओं की तुलना में एक अलग वाक्यविन्यास है, हालांकि, यह याद रखना आसान है। यह अध्याय आपको LOLCODE का मूल सिंटैक्स देता है।

निर्माणों

LOLCODE कंस्ट्रक्शन शब्द गंदे हैं। निम्न तालिका अब तक लागू किए गए निर्माणों की वर्णमाला सूची से पता चलता है -

अनु क्रमांक। निर्माण और उपयोग
1

BTW

यह एक एकल पंक्ति टिप्पणी शुरू करता है।

2

DOWN <variable>!!<times>

यह चर = चर - समय से मेल खाती है। ध्यान दें कि "बार" एक वुट-ओनली भाषा एक्सटेंशन है।

3

GIMMEH <variable>

यह इनपुट स्टेटमेंट को दर्शाता है।

4

GTFO

इस के समान है break अन्य भाषाओं में और लूप से बाहर निकलने का एक तरीका प्रदान करता है।

5

HAI

इससे मेल खाती है main ()अन्य भाषाओं में कार्य करते हैं। यह LOLCODE में प्रोग्राम एंट्री पॉइंट है।

6

HEREZ <label>

यह एक और वॉट-ओनली भाषा एक्सटेंशन है और SHOO के साथ प्रयोग के लिए एक लेबल की घोषणा करता है

7

I HAS A <type> <variable>

यह उक्त प्रकार के एक चर को घोषित करता है।

LOLCODE में तीन अंतर्निहित प्रकार हैं -

  • NUMBAH (int)
  • DECINUMBAH (डबल)
  • WORDZ (std :: string)

ध्यान दें कि प्रकार एक वॉट-ओनली भाषा एक्सटेंशन हैं।

8

IM IN YR LOOP

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

9

IZ <expr1> <operator> <expr2>?: Conditional structure

यह अन्य भाषाओं में ऑपरेटर के समान है। ऑपरेटर में से एक है: बड़ा थान, छोटे थान, एसएएम के रूप में। ध्यान दें कि? अंत में वैकल्पिक है।

10

KTHX

यह एक ब्लॉक को समाप्त करता है। से मेल खाती है}

1 1

KTHXBAI

इससे एक कार्यक्रम समाप्त होता है

12

NOWAI

यह दूसरे से मेल खाती है

13

PURR <expr>

यह स्क्रीन पर तर्क देता है, उसके बाद एक नई पंक्ति। यह केवल भाषा का विस्तार है।

14

RELSE

इससे मेल खाती है else (if)

15

SHOO

यह एक और वैट-ओनली भाषा एक्सटेंशन है, जो इससे मेल खाती है goto (डर!)

16

UP <variable>!!<times>

यह चर = चर + समय से मेल खाती है। यहाँ "समय" एक केवल-भाषा का विस्तार है।

17

VISIBLE <expr>

यह स्क्रीन पर तर्क प्रिंट करता है। ध्यान दें कि यह एक नई रूपरेखा नहीं छापता है।

18

YARLY

यह "सही" सशर्त ब्लॉक की शुरुआत को दर्शाता है

LOLCODE में स्लंग शब्द के कुछ उदाहरण हैं -

  • HAI हाय है
  • KTHXBYE ठीक है, धन्यवाद, अलविदा
  • BTW रास्ते से है
  • OBTW ओह, वैसे है
  • TLDR बहुत लंबा है; नहीं पढ़ा

श्वेत रिक्ति

अधिकांश प्रोग्रामिंग भाषाओं में, कीवर्ड या टोकन उनके बीच रिक्त स्थान नहीं हो सकते हैं। हालांकि, कुछ भाषाओं में, उन्हें अलग करने के लिए टोकन में रिक्त स्थान का उपयोग किया जाता है।

अल्पविराम

अल्पविराम ज्यादातर भाषाओं में एक नए कीवर्ड की तरह व्यवहार करता है, उदाहरण के लिए, \n Java और C. में आप LOLCODE में एक ही लाइन में कई कमांड लिख सकते हैं, बशर्ते कि आप उन्हें अल्पविराम (,) का उपयोग करके अलग करें।

तीन अवधि (…)

तीन अवधियों (…) आपको लाइन के अंत में (...) शामिल करके (या) एक ही पंक्ति में कोड की कई पंक्तियों को संयोजित करने में सक्षम बनाता है। यह अगली पंक्ति की सामग्री को केवल पिछली पंक्ति की सामग्री के रूप में मानने के लिए संकलक बनाता है। कोड की अनंत पंक्तियों को एक साथ एक कमांड के रूप में लिखा जा सकता है, जब तक कि प्रत्येक पंक्ति तीन अवधियों के साथ समाप्त नहीं हो जाती।

एक टिप्पणी एक नई लाइन द्वारा समाप्त की जाती है। कृपया ध्यान दें कि टिप्पणी (BTW) के बाद लाइन निरंतरता (...) और () को lci द्वारा अनदेखा किया जाता है।

टिप्पणियाँ

BTW कीवर्ड के बाद सिंगल लाइन टिप्पणियां लिखी जाती हैं। वे प्रोग्राम बॉडी के अंदर कहीं भी हो सकते हैं: यह प्रोग्राम की पहली पंक्ति में, प्रोग्राम के बीच में, कुछ लाइन के बीच या प्रोग्राम के अंत में हो सकता है।

ये सभी मान्य एकल पंक्ति टिप्पणियाँ हैं

I HAS A VAL ITZ 19      BTW VAL = 19
I HAS A VAL ITZ 19,   BTW VAL = 19
I HAS A VAL ITZ 14
BTW VAR = 14

LOLCODE में, OBTW द्वारा कई लाइन टिप्पणियां लिखी जाती हैं और उन्हें TLDR के साथ समाप्त किया जाता है।

यह एक मान्य बहु-पंक्ति टिप्पणी है -

I HAS A VAL ITZ 51
   OBTW this is a comment
      No it’s a two line comment
      Oops no.. it has many lines here
   TLDR

फ़ाइल निर्माण

एक LOLCODE प्रोग्राम HAI कीवर्ड से शुरू होता है और इसे KTHXBYE के साथ समाप्त होना चाहिए। जैसा कि LOLCODE शॉर्टहैंड भाषा का उपयोग करता है HAI मूल रूप से Hi के लिए खड़ा है और KTHXBYE को याद किया जा सकता है“Ok, thanks, bye ”

उदाहरण

HAI 1.2
I HAS A NAME
VISIBLE "NAME::"!
GIMMEH NAME
VISIBLE "tutorialsPoint " NAME "!"
KTHXBYE

किसी भी अन्य प्रोग्रामिंग भाषा की तरह, LOLCODE आपको विभिन्न प्रकार के चर को परिभाषित करने की अनुमति देता है। यह अध्याय आपको LOLCODE में चर के साथ काम करने से परिचित करेगा।

चर का दायरा

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

कृपया ध्यान दें कि LOLCODE में वैरिएबल की कोई वैश्विक गुंजाइश नहीं है।

नामकरण की परंपरा

परिवर्तनीय नामों को आमतौर पर पहचानकर्ता कहा जाता है। यहाँ LOLCODE में नामकरण चर के लिए कुछ सम्मेलन हैं -

  • चर पहचानकर्ता सभी बड़े अक्षरों या निचले अक्षरों (या दोनों का मिश्रण) में हो सकते हैं।

  • वे केवल एक पत्र के साथ शुरू कर सकते हैं और फिर अन्य अक्षरों, संख्याओं और अंडरस्कोर द्वारा पीछा किया जा सकता है।

  • LOLCODE किसी वैरिएबल का नामकरण करते समय रिक्त स्थान, डैश या अन्य प्रतीकों के उपयोग की अनुमति नहीं देता है।

  • परिवर्तनीय पहचानकर्ता संवेदनशील होते हैं।

LOLCODE rules में चर के वैध और अमान्य नामों के कुछ नियम यहां दिए गए हैं

  • नाम हमेशा एक वर्णमाला से शुरू होना चाहिए। उदाहरण के लिए,name, Name वैध हैं।

  • एक चर का नाम एक अंक से शुरू नहीं हो सकता है। उदाहरण के लिए,2var अमान्य है।

  • एक चर का नाम एक विशेष वर्ण से शुरू नहीं हो सकता है।

  • एक चर में अपने नाम के अंदर कहीं भी _ या एक अंक हो सकता है, शुरुआती सूचकांक को छोड़कर। उदाहरण के लिए,name2_m एक वैध नाम है।

LOLCODE में मान्य नामों के कुछ उदाहरण नीचे दिखाए गए हैं -

HAI 1.2
I HAS A food ITZ "111.00033"
I HAS A food2 ITZ "111"
I HAS A fo_od ITZ "1"
VISIBLE food
VISIBLE food2
VISIBLE fo_od
KTHXBYE

उपरोक्त कोड में सभी घोषणा बयान मान्य हैं और निष्पादित होने पर निम्नलिखित आउटपुट का उत्पादन करेंगे -

sh-4.3$ lci main.lo
111.00033
111
1

अमान्य बयान और उनके आउटपुट के कुछ उदाहरण नीचे दिए गए हैं -

उदाहरण 1

HAI 1.2
I HAS A 2food ITZ "111.00033"
KTHXBYE

जब आप इसे निष्पादित करेंगे तो उपरोक्त कोड निम्नलिखित आउटपुट देगा -

sh-
4.3$ lci main.lo
Line 2: Expected: identifier; Got: int(2).

उदाहरण 2

HAI 1.2
I HAS A _food ITZ "111.00033"
KTHXBYE

जब आप इसे निष्पादित करेंगे तो उपरोक्त कोड निम्नलिखित आउटपुट देगा -

sh-
4.3$ lci main.lo
Line 2: Unrecognized sequence at: _food ITZ "111.00033".

उदाहरण 3

HAI 1.2
I HAS A f$ood ITZ "111.00033"
KTHXBYE

जब आप इसे निष्पादित करेंगे तो उपरोक्त कोड निम्नलिखित आउटपुट देगा -

sh-
4.3$ lci main.lo
Line 2: Unrecognized sequence at: $ood ITZ "111.00033".

विविधता की घोषणा और असाइनमेंट

सेवा declareएक चर, LOLCODE एक कीवर्ड प्रदान करता है "I HAS A" जो कि चर नाम से आता है। आप एक चर घोषित करने के लिए सिंटैक्स के नीचे पा सकते हैं।

I HAS A VAR BTW VAR is empty now, You can use any name instead of var

सेवा assignचर एक ही बयान में एक मूल्य है, तो आप "ITZ" के साथ चर नाम का पालन कर सकते हैं और फिर उस मूल्य को दे सकते हैं जिसे आप असाइन करना चाहते हैं। किसी वैरिएबल पर मान निर्दिष्ट करने के लिए निम्न सिंटैक्स का उपयोग करें -

<variable> R <expression>

उदाहरण

VAR R "Green"         BTW VAR is now a YARN and equals "Green"
VAR R 30              BTW VAR is now a NUMBR and equals 30

आप भी कर सकते हैं declare तथा assign निम्नलिखित सिंटैक्स का उपयोग करके एक ही समय में चर -

I HAS A VAR ITZ VALUE

उदाहरण

I HAS A NAME ITS “TUTORIALS POINT”

उदाहरण

HAI 1.2
BTW this is how we declare variables
I HAS A food
I HAS A bird

BTW this is how we assign variables
food R 1
bird R 5

BTW this is how initialize variables
I HAS A biz ITZ "OMG!"
VISIBLE food
VISIBLE biz
VISIBLE bird
KTHXBYE

उपरोक्त कार्यक्रम चर की घोषणा दर्शाता है और उन्हें प्रिंट करता है। आउटपुट है -

sh-
4.3$ lci main.lo
1
OMG!
5

कास्टिंग टाइप करें

एक प्रकार के मूल्य को दूसरे प्रकार में बदलने के लिए, हम टाइप कास्टिंग का उपयोग करते हैं। NUMBAR को NUMBR में कास्टिंग करना अस्थायी बिंदु संख्या के दशमलव भाग को काटता है। एक YARN (उदाहरण के लिए इसे प्रिंट करके) के लिए एक NUMBAR कास्टिंग, एक डिफ़ॉल्ट 2 दशमलव स्थानों के लिए उत्पादन truncates।

उदाहरण

HAI 1.2
I HAS A food ITZ "111.00033"
VISIBLE food

BTW this is how we do type casting
MAEK food A NUMBAR
VISIBLE food
KTHXBYE

कोड की उपरोक्त लाइन निम्नलिखित आउटपुट का उत्पादन करेगी -

sh-4.3$ lci main.lo
111.00033
111.00033

LOLCODE कार्यक्रम में घोषित सभी चर स्थानीय चर हैं और किसी भी चर के लिए इस भाषा में कोई वैश्विक गुंजाइश नहीं है।

LOLCODE को प्रोग्रामिंग लैंग्वेज डिज़ाइन की सीमाओं का परीक्षण करने के लिए डिज़ाइन किया गया है। यह एक गूढ़ प्रोग्रामिंग भाषा है जो इंटरनेट पर मजेदार चीजों से प्रेरित है। यह अध्याय आपको LOLCODE प्रकारों की समझ देता है।

प्रकार

वर्तमान में, LOLCODE में परिवर्तनशील प्रकार हैं -

  • तार (YARN)
  • पूर्णांक (NUMBR)
  • फ्लोट्स (NUMBAR)
  • और बुलियन (TROOF)
  • ऐरे (BUKKIT)

LOLCODE में चर प्रकार को संकलक द्वारा गतिशील रूप से नियंत्रित किया जाता है। यदि किसी चर का आरंभिक मान नहीं है, तो उसे अप्राप्त (LOLCODE में NOOB के रूप में जाना जाता है) कहा जाता है।

LOLCODE में विभिन्न प्रकारों को घोषित करने और उनका उपयोग करने का सिंटैक्स नीचे दिखाया गया है -

किसी भी डेटा प्रकार का एक चर बनाने के लिए

I HAS A <VARIABLE> ITZ A <DATA TYPE>

एक वैरिएबल बनाने और उसके लिए एक मान निर्दिष्ट करने के लिए

I HAS A <VARIABLE> ITZ <EXPRESSION<

पहले से निर्मित डेटा प्रकार के लिए एक मान निर्दिष्ट करने के लिए

<VARIABLE> R <EXPRESSION>

अनटाइप्ड (NOOB)

अप्रकाशित डेटा प्रकार (NOOB के रूप में जाना जाता है) को TROOF डेटा प्रकार को छोड़कर किसी अन्य प्रकार में परिवर्तित नहीं किया जा सकता है। TROOF में NOOB की निहित ढलाई चर को विफल बना देती है। उसके बाद NOOB पर किसी भी ऑपरेशन में त्रुटि होती है।

एक एनओबी डेटा प्रकार (यानी प्रकार जो असिंचित हैं और जिनका कोई प्रारंभिक मूल्य नहीं है) के स्पष्ट परिणाम सभी अन्य प्रकारों के लिए शून्य मानों में परिवर्तनशील होते हैं।

एक अनुपलब्ध चर को परिभाषित करने के लिए, बस एक चर घोषित करें और इस उदाहरण में दिखाए गए मान को असाइन करें -

HAI 1.2
I HAS A VAR3
VAR3 R "ANYVALUE"
VISIBLE VAR3

BTW Or declare in same line
I HAS A VAR4 ITZ 44
VISIBLE VAR4
KTHXBYE

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आपको निम्नलिखित परिणाम मिलेंगे -

sh-
4.3$ lci main.lo 
ANYVALUE
44

बुलियन (TROOFS)

LOLCODE में, बूलियन मान दो प्रकार के होते हैं। BOOLEAN के सामान्यतः दो मूल्य होते हैं- सत्य और असत्य। लेकिन, LOLCODE में, बूलियन को TROOF के रूप में जाना जाता है, और सच्चे / झूठे मूल्यों को क्रमशः जीत / असफल के रूप में जाना जाता है। एक खाली स्ट्रिंग (""), या एक खाली सरणी की तरह सभी असंवैधानिक मूल्य सभी विफल हो जाएंगे। अन्य सभी आरंभिक मान जीत के लिए मूल्यांकन करते हैं।

उदाहरण

HAI 1.2
I HAS A VAR3 ITZ A TROOF
VAR3 R "FAIL"
   VISIBLE VAR3
KTHXBYE

उपरोक्त कोड निष्पादित करने पर आप निम्न आउटपुट देख सकते हैं -

sh-4.3$ lci main.lo
FAIL

संख्यात्मक प्रकार (NUMBR)

LOLCODE में, एक NUMBR पूर्णांक के लिए खड़ा है। अंकों के किसी भी क्रम को NUMBR माना जाता है, जब तक कि अनुक्रम के बीच में कहीं भी एक दशमलव दिखाई न दे। किसी भी संख्या को नकारात्मक बनाने के लिए, यह एक हाइफ़न (-) से पहले हो सकता है जो एक नकारात्मक संख्या को दर्शाता है।

उदाहरण

HAI 1.2
I HAS A VAR3 ITZ A NUMBR
   VISIBLE VAR3
KTHXBYE

जब आप इसे चलाते हैं तो उपरोक्त कोड आपको निम्न परिणाम दिखाता है

sh- 
4.3$ lci main.lo
0

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

स्ट्रिंग्स (YARN)

LOLCODE में, स्ट्रिंग वाले अर्थात स्ट्रिंग शाब्दिक शब्द (YARN) को दोहरे उद्धरण चिह्नों ("") के साथ शुरू और समाप्त होना चाहिए।

कुछ भी स्ट्रिंग के अंदर लिखा जा सकता है, जैसे अंतरिक्ष, अल्पविराम, पूर्ण विराम, विस्मयादिबोधक या कोई अन्य प्रतीक। एक स्ट्रिंग जहां कोई एकल उद्धरण गायब है, त्रुटि का कारण हो सकता है। Colons को LOLCODE में एस्केप कैरेक्टर के रूप में उपयोग किया जाता है, और कोलन के बाद किसी भी मूल्य का एक विशेष अर्थ होता है।

  • :) - एक बृहदान्त्र के बाद एक समापन ब्रैकेट एक नई रेखा (\ n) का प्रतिनिधित्व करता है

  • :> - एक बृहदान्त्र के बाद एक समापन कोण ब्रैकेट एक टैब (\ t) का प्रतिनिधित्व करता है

  • :o - ए ‘o’ बृहदान्त्र के बाद का वर्ण एक बेल (बीप) (\ g) को दर्शाता है

  • :" - "एक बृहदान्त्र निम्नलिखित एक शाब्दिक दोहरे उद्धरण का प्रतिनिधित्व करता है (")

  • :: - एक बृहदान्त्र के बाद एक बृहदान्त्र एकल शाब्दिक बृहदान्त्र का प्रतिनिधित्व करता है (:)

उदाहरण

HAI 1.2
I HAS A VAR3 ITZ A YARN
VAR3 R "XYZ"
   VISIBLE VAR3
KTHXBYE

ऊपर दिया गया कोड निष्पादन पर निम्नलिखित आउटपुट का उत्पादन करता है -

sh-
4.3$ lci main.lo 
XYZ

Bukkit

यह प्रकार एक सरणी का प्रतिनिधित्व करता है। इसका नाम स्लॉट है, जिसमें चर या फ़ंक्शंस हो सकते हैं। BUKKIT को निम्नलिखित तरीके से घोषित किया जा सकता है -

BTW declaration of the BUKKIT
I HAS A [object] ITZ A BUKKIT BTW creating a variable in a slots
[object] HAS A [var] ITZ [value] BTW creating a function inside the BUKKIT

HOW IZ [object] [function name] (YR [argument1] (AN YR [argument2] (AN YR [argument3] ...)))
[function code]
IF U SAY SO

BUKKIT के अंदर एक फ़ंक्शन ME'Z [var] या ME IZ [फ़ंक्शन नाम] (YR [बहस 1] (AN YR [तर्क 2] (AN YR / तर्क 3) ... का उपयोग करके BUKKIT के अन्य कार्यों और अन्य कार्यों तक पहुंच सकता है। ))) एमकेए।

उदाहरण

HAI 1.2
   I HAS A VAR6 ITZ A BUKKIT
   BTW DECLARING AN ARRAY
   VAR6 HAS A VAR7 ITZ "DOGE"
   
   BTW VAR7 IS A STRING VARIABLE THAT IS INSERTED  INTO ARRAY VAR6
   VISIBLE VAR6'Z VAR7
   BTW GET THE ELEMENT OF ARRAY
KTHXBYE

जब आप ऊपर दिए गए कोड को चलाते हैं तो यह आउटपुट आपको मिल जाएगा -

sh-
4.3$ lci main.lo 
DOGE

चरों पर विभिन्न संचालन करने के लिए ऑपरेटर एक महत्वपूर्ण भूमिका निभाते हैं। यह अध्याय आपको LOLCODE में विभिन्न ऑपरेटरों और उनके उपयोग में लाता है।

ऑपरेटर्स

गणितीय संचालक एक उपसर्ग संकेतन पर निर्भर करते हैं अर्थात संक्रिया से पहले जो संकेतन आता है। जब सभी ऑपरेटरों को तर्कों या परिचालनों की संख्या ज्ञात होती है, तो कोई समूहन मार्कर आवश्यक नहीं होते हैं। ऐसे मामलों में जहां ऑपरेटरों के पास निश्चित तर्क या ऑपरेशंस नहीं हैं, ऑपरेशन MKAY के साथ बंद है।

यदि कथन के अंत के साथ मेल खाता है तो MKAY का उपयोग नहीं किया जा सकता है। ऐसे मामलों में, ईओएल कीवर्ड का उपयोग किया जाना चाहिए। गणित के गणितीय संचालकों का उपयोग करने के लिए, निम्नलिखित सिंटैक्स का उपयोग करें -

<operator> <expression>

AN कीवर्ड का उपयोग वैकल्पिक रूप से तर्कों को अलग करने के लिए किया जा सकता है, और एक से अधिक ऑपरेंड पर एक ही ऑपरेशन को लागू कर सकता है, इसलिए एक बाइनरी ऑपरेटर अभिव्यक्ति में निम्नलिखित सिंटैक्स है -

<operator> <expression1> AN <expression2>

किसी भी अभिव्यक्ति वाले ऑपरेटर जिसमें अनंत संख्या में तर्क दिए गए हैं, उन्हें निम्नलिखित सिंटैक्स के साथ व्यक्त किया जा सकता है -

<operator> <expression1> [[AN <expression2>] AN <expression3> ...] MKAY

गणित

LOLCODE में मूल गणितीय कार्य निम्नलिखित हैं -

SUM OF <a> AN <b>      BTW This is a plus + operator
DIFF OF <a> AN <n>     BTW This is a minus - operator
PRODUKT OF <a> AN <n>  BTW This is a multiply operator *
QUOSHUNT OF <a> AN <n> BTW This is a divide operator
MOD OF <a> AN <n>      BTW This is a modulo operator
BIGGR OF <a> AN <n>    BTW This is a max operator
SMALLR OF <a> AN <n>   BTW This is a min operator

<a> और <b> प्रत्येक उपरोक्त में अद्वितीय अभिव्यक्तियाँ हो सकती हैं, इसलिए गणितीय संचालकों को अनिश्चित काल के लिए नस्ट और समूहित किया जा सकता है।

गणित दो NUMBRs की उपस्थिति में पूर्णांक गणित के रूप में तर्कों को देखते हुए किया जाता है, लेकिन यदि अभिव्यक्ति में से कोई भी NUMBAR है, तो संचालन को फ़्लोटिंग पॉइंट ऑपरेशन माना जाता है।

उदाहरण

HAI 1.2
   I HAS A m ITZ 4
   I HAS A n ITZ 2
VISIBLE SUM OF m AN n      BTW +
VISIBLE DIFF OF m AN n     BTW -
VISIBLE PRODUKT OF m AN n  BTW *
VISIBLE QUOSHUNT OF m AN n BTW /
VISIBLE MOD OF m AN n      BTW modulo
VISIBLE BIGGR OF m AN n    BTW max
VISIBLE SMALLR OF m AN n   BTW min
KTHXBYE

जब आप इसे चलाते हैं तो उपरोक्त कोड निम्नलिखित आउटपुट का उत्पादन करेगा -

sh-
4.3$ lci main.lo
6
2
8
2
0
4
2

महत्वपूर्ण बिंदु -

LOLCODE related में गणितीय ऑपरेटरों के साथ काम करने से संबंधित निम्नलिखित महत्वपूर्ण बिंदुओं पर विचार करें

  • यदि अभिव्यक्ति में एक या दोनों तर्क YARN हैं, तो उन्हें NUMBAR के रूप में माना जाता है।

  • यदि किसी भी तर्क को आंतरिक रूप से संख्यात्मक प्रकार से सुरक्षित रूप से नहीं डाला जा सकता है, तो यह एक त्रुटि के साथ विफल हो जाता है

बूलियन

बूलियन ऑपरेटरों को उन मूल्यों पर लागू किया जाता है जो सही या गलत हो सकते हैं। ट्रॉफ्स पर काम करने वाले बूलियन ऑपरेटर निम्नानुसार हैं -

BOTH OF <m> AN <n>             BTW its and operation: WIN if m = WIN and n = WIN
EITHER OF <m> AN <n>           BTW its or operation: FAIL iff m = FAIL, n = FAIL
WON OF <m> AN <n>              BTW its xor operation: FAIL if m = n
NOT <m>                        BTW its an unary negation: WIN if m = FAIL
ALL OF <m> AN <n> ... MKAY     BTW it will take infinite arguments and apply AND
ANY OF <m> AN <n> ... MKAY     BTW it will take infinite arguments and apply OR.

कृपया ध्यान दें कि उपरोक्त वाक्य विन्यास में <m> और <n> स्वचालित रूप से TROOF मान के रूप में डाले जाते हैं यदि वे पहले से ही TROOF मान नहीं हैं।

तुलना

जब आप LOLCODE में दो या अधिक ऑपरेंड की तुलना करना चाहते हैं, तो आप निम्न में से किसी भी तरीके से कर सकते हैं -

विधि 1

आप समानता ऑपरेटरों का उपयोग करके दो बाइनरी ऑपरेंड्स की तुलना कर सकते हैं। वाक्य रचना नीचे दिखाया गया है -

BOTH SAEM <m> AN <n>   BTW this will return WIN if m is equal to n
DIFFRINT <m> AN <n>    BTW this will return WIN if m is not equal to n

विधि 2

आप तुलना कर सकते हैं कि दोनों मान NUMBRs प्रकार के हैं। याद रखें कि यदि दोनों में से कोई भी मूल्य NUMBARs हैं, तो उनकी तुलना फ़्लोटिंग पॉइंट मानों से की जाती है।

विधि 3

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

BOTH SAEM <m>   AN BIGGR OF <m> AN <n>

BOTH SAEM <m>  AN SMALLR OF <m> AN <n>
DIFFRINT <m>  AN SMALLR OF <m> AN <n>
DIFFRINT <m> AN BIGGR OF <m> AN <n>

Example

HAI 1.2
I HAS A VAR11 ITZ 7
BOTH SAEM VAR11 SMALLR OF VAR11 AN 8, O RLY?
YA RLY
VISIBLE "TRUE"
NO WAI
VISIBLE "FALSE"
OIC
KTHXBYE

जब आप दिए गए कोड को निष्पादित करते हैं तो आप निम्न आउटपुट देख सकते हैं -

sh-
4.3$ lci main.lo

TRUE

मूल्यों का संघटन

LOLCODE आपको SMOOSH… MKAY ऑपरेटर का उपयोग करके स्पष्ट रूप से अनंत संख्या में YARN की अनुमति देता है। संघ के लिए, कई तर्कों के साथ अलग किया जा सकता हैAN ऑपरेटर।

उदाहरण

HAI 1.2
I HAS A VAR1 ITZ A YARN
VAR1 R "TRUE"

I HAS A VAR2 ITZ A YARN
VAR2 R "ANOTHER TRUE"

I HAS A VAR3 ITZ A YARN
VAR3 R "ONE MORE TRUE"
VISIBLE SMOOSH VAR1 " " VAR3 " " VAR2 MKAY
KTHXBYE

ऊपर दिए गए कोड निष्पादन पर निम्नलिखित परिणाम का उत्पादन करेंगे -

sh-
4.3$ lci main.lo

TRUE ONE MORE TRUE ANOTHER TRUE

कास्टिंग टाइप करें

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

बाइनरी MAEK ऑपरेटर के साथ एक अभिव्यक्ति का मूल्य स्पष्ट रूप से डाला या किसी अन्य प्रकार में परिवर्तित किया जा सकता है। MAEK ऑपरेटर का सिंटैक्स है -

MAEK <expression> A <type>

जहाँ, <type> TROOF, YARN, NUMBR, NUMBAR, या NOOB में से एक हो सकता है।

किसी अन्य प्रकार के लिए एक चर को स्पष्ट रूप से डालने के लिए, MAEK ऑपरेटर के साथ एक सामान्य असाइनमेंट स्टेटमेंट का उपयोग किया जा सकता है, या एक कास्टिंग असाइनमेंट स्टेटमेंट का उपयोग निम्नानुसार किया जा सकता है -

<Any_variable> IS NOW A <type>  BTW this code will be equal to
<Any_variable> R MAEK <variable> A <type>

उदाहरण

HAI 1.2
I HAS A food ITZ "111.00033"
VISIBLE food

BTW this is how we do type casting
MAEK food A NUMBAR
VISIBLE food
KTHXBYE

उपरोक्त कोड निम्नलिखित आउटपुट का उत्पादन करेगा

sh-4.3$ lci main.lo
111.00033
111.00033

यह अध्याय आपको बताएगा कि LOLCODE टर्मिनल के माध्यम से एक वैल्यू का इनपुट कैसे किया जाता है और इसे टर्मिनल पर कैसे आउटपुट किया जाता है।

I / O टर्मिनल से

आप LOLCODE में कुछ प्रिंट करने के लिए कीवर्ड VISIBLE का उपयोग कर सकते हैं। VISIBLE एक ऐसा फंक्शन है जो अनंत अक्षरों को इनपुट के रूप में ले सकता है, और उन सभी को एक साथ आंतरिक रूप से गुप्त करके, और उन्हें स्ट्रिंग्स या YARN में परिवर्तित करता है।

VISIBLE फ़ंक्शन एक सीमांकक द्वारा समाप्त या समाप्त होता है, जो या तो एक पंक्ति अंत या अल्पविराम होता है।

संकलक द्वारा गाड़ी वापसी के साथ आउटपुट को स्वचालित रूप से समाप्त कर दिया जाता है। यदि अंतिम टोकन को विस्मयादिबोधक चिह्न (!) के साथ समाप्त किया जाता है, तो वापस लौटी गाड़ी को इस प्रतीक द्वारा ओवर-राइड किया जाता है।

VISIBLE <any_expression> [<any_expression> ...][!]

कृपया ध्यान दें कि LOLCODE में, वर्तमान में किसी डेटा को किसी फ़ाइल में प्रिंट करने के लिए कोई निर्धारित मानक नहीं है।

उपयोगकर्ता से कुछ इनपुट लेने के लिए, प्रयुक्त कीवर्ड GIMMEH है। यह एक फ़ंक्शन है जो इनपुट के रूप में किसी भी संख्या में चर ले सकता है। यह यार्न को इनपुट के रूप में लेता है और किसी भी चर में मूल्य संग्रहीत करता है।

GIMMEH <any_variable>

उदाहरण

HAI 1.2
   I HAS A VAR ITZ A YARN BTW DECLARE A VARIABLE FOR LATER USE
   VISIBLE "TYPE SOMETHING AND ENTER"
   GIMMEH VAR BTW GET INPUT (STRING) INTO VARIABLE
   VISIBLE VAR
KTHXBYE

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

sh-
4.3$ lci main.lo

TYPE SOMETHING AND ENTER
67

67

LOLCODE आपको विभिन्न कथनों के माध्यम से कार्यक्रम के प्रवाह को नियंत्रित करने की अनुमति देता है। यह अध्याय LOLCODE में उपलब्ध विभिन्न प्रकार के कथनों की व्याख्या करता है।

अभिव्यक्ति कथन

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

असाइनमेंट स्टेटमेंट्स

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

<any_variable> <assignment operator> <any expression>

कृपया ध्यान दें कि, आप असाइन किए जाने से पहले ही अभिव्यक्ति में एक चर का उपयोग कर सकते हैं।

सशर्त बयान

यदि-तब विवरण

अगर-तब स्टेटमेंट आईटी वेरिएबल पर काम करने वाला एक बहुत ही सरल ऑपरेशन है। यह अन्य प्रोग्रामिंग भाषाओं जैसे C और Java में स्टेटमेंट्स के समान है।

If-then स्टेटमेंट्स को लागू करने के लिए चार कीवर्ड हैं।

  • ओ केवल?
  • YA RLY
  • कोई WAI
  • OIC

सामान्य रूप है -

<any_expression>
O RLY?
   YA RLY
      <code to execute if above condition is true>
   NO WAI
      <code to execute in this block>
OIC

उपरोक्त सभी कथन एक ही पंक्ति में अल्पविराम द्वारा अलग किए जा सकते हैं जैसे -

BOTH SAEM NAMES AN "Name", O RLY?
   YA RLY, VISIBLE "My name is ABCD"
   NO WAI, VISIBLE "Your name is ABCD"
 OIC

यदि तत्कालीन वक्तव्यों का उपयोग करते समय, एक वैकल्पिक MEBBE <किसी भी अभिव्यक्ति> का उपयोग YA RLY और NO WAI ब्लॉक के बीच किया जा सकता है।

यदि MEBBE के बाद <कोई भी अभिव्यक्ति सत्य (जीत) है, तो उस ब्लॉक को निष्पादित किया जाता है। अन्यथा, यदि वह अभिव्यक्ति गलत है, तो ब्लॉक को अगले MEBBE, NO WAI, या OIC स्टेटमेंट तक छोड़ दिया जाता है।

उदाहरण

<any expression>
O RLY?
   YA RLY
      <code to be executed if true>
   MEBBE <expression>
      <code to be executed mebbe is true>
   MEBBE <expression>
      <code to be executed mebbe is true>
   NO WAI
      <code to be executed if above are false>
OIC

उदाहरण

BOTH SAEM NAMES AN "NAME"
O RLY?
   YA RLY, VISIBLE "YOUR NAME IS ABCD"
   MEBBE BOTH SAEM ANIMAL AN "OUR NAME IS ABCD"
   VISIBLE "NO ABCD"
OIC

केस स्टेटमेंट

LOLCODE में, कीवर्ड 'WTF?' कई अन्य भाषाओं में स्विच करने के समान है। कीवर्ड डब्ल्यूटीएफ? तुलना के लिए अभिव्यक्ति मूल्य के रूप में आईटी लेता है। डब्ल्यूटीएफ का उपयोग करने के लिए, ओएमजी द्वारा एक तुलना ब्लॉक खोला जाता है जो एक शाब्दिक होना चाहिए, न कि एक अभिव्यक्ति।

कृपया याद रखें कि प्रत्येक शाब्दिक अद्वितीय होना चाहिए, अन्य भाषाओं के मामले के समान।

OMG ब्लॉक को GTFO स्टेटमेंट द्वारा समाप्त किया जाना चाहिए। यदि किसी OMG ब्लॉक को GTFO द्वारा समाप्त नहीं किया जाता है, तो अगले OMG ब्लॉक को GTFO तक पहुंचने तक निष्पादित किया जाता है।

यदि कोई भी शाब्दिक सच के रूप में मूल्यांकन नहीं करता है, तो डिफ़ॉल्ट मामले को OMGWTF द्वारा हस्ताक्षरित किया जाता है।

WTF?
   OMG <any value to compare>
      <code block to execute if expression is satisfied>
   OMG <any value to compare>
      <code block to execute if expression is satisfied>
   OMGWTF
      <code block to execute as a default case>
OIC
NAME, WTF?
   OMG "A"
      VISIBLE "ABCD"
   GTFO
   OMG "E"
      VISIBLE "EFGH"
   GTFO
   OMGWTF
      VISIBLE "ZYXW"
   OIC

उपरोक्त कोड के आउटपुट परिणाम होंगे -

"इ":

EFGH

लूप का उपयोग प्रोग्रामिंग भाषाओं में कई बार कथनों के सेट को निष्पादित करने के लिए किया जाता है। उदाहरण के लिए, यदि आप अंक 5 को पांच बार प्रिंट करना चाहते हैं, तो लिखने के बजायVISIBLE “5” पांच बार बयान, आप एकल के साथ एक लूप चला सकते हैं VISIBLE “5” पाँच बार बयान।

सरल छोरों को IM IN YR <लेबल> और IM OUTTA YR <लेबल> के साथ दर्शाया गया है। इस तरह से परिभाषित लूप अनंत लूप हैं और उन्हें GTFO ब्रेक स्टेटमेंट के साथ समाप्त किया जाना चाहिए।

Iteration छोरों की संरचना निम्नलिखित है -

IM IN YR <label> <any_operation> YR <any_variable> [TIL|WILE <expression>]
   <code block to execute inside the loop multiple times>
IM OUTTA YR <label>

कृपया ध्यान दें कि फ़ंक्शन बॉडी के अंदर, UPPIN (एक से वृद्धि), NERFIN (एक से घटा), या किसी भी अनियोजित फ़ंक्शन का उपयोग किया जा सकता है।

TIL कीवर्ड अभिव्यक्ति की गणना TROOF के रूप में करता है: यदि यह FAIL के रूप में मूल्यांकन करता है, तो लूप एक बार फिर जारी रहता है, यदि यह WIN के रूप में मूल्यांकन करता है, तो लूप निष्पादन बंद हो जाता है, और IM OUTTA YR कथन के मिलान के बाद भी जारी रहता है।

WILE कीवर्ड TIL कीवर्ड के विपरीत है, यदि अभिव्यक्ति जीत है, तो निष्पादन जारी रहता है, अन्यथा लूप बाहर निकलता है।

उदाहरण

HAI 1.2
I HAS A VAR ITZ 0
IM IN YR LOOPY UPPIN YR VAR TIL BOTH SAEM VAR AN 10
   VISIBLE SUM OF VAR AN 1
IM OUTTA YR LOOPY
KTHXBYE

जब उपरोक्त कोड किसी भी LOLCODE संकलक पर या हमारे ऑनलाइन कोडिंग ग्राउंड पर संकलित किया जाता है, तो यह निम्न आउटपुट का उत्पादन करेगा।

sh-
4.3$ lci main.lo
1
2
3
4
5
6
7
8
9
10

प्रोग्रामिंग में कार्य उपयोगी होते हैं क्योंकि वे बार-बार कोड लिखने के लिए समय और प्रयास कम करते हैं। एक अच्छी तरह से लिखा फ़ंक्शन कोड उच्च पुन: प्रयोज्य प्रदान करता है। यह अध्याय आपको बताता है कि LOLCODE में कार्यों के साथ कैसे लिखना और काम करना है।

एक समारोह की परिभाषा

फ़ंक्शन एक फ़ंक्शन का एक सेट है जिसे उस फ़ंक्शन को कॉल करके एक बार में सभी निष्पादित किया जाता है। LOLCODE में, एक फ़ंक्शन की परिभाषा "HOW IZ I" कीवर्ड से शुरू होती है और समापन कीवर्ड "IF U SAY SO" है।

LOLCODE is synt में एक फ़ंक्शन लिखने का सिंटैक्स

HOW IZ I <function name> [YR <parameter/argument> [AN YR <other _arguments..> …]]
   <code block to execute / Set of statements to execute>
IF U SAY SO

महत्वपूर्ण बिंदु

जब आप किसी LOLCODE फ़ंक्शन को परिभाषित कर रहे हों तो निम्नलिखित महत्वपूर्ण बिंदुओं पर विचार करें -

  • LOLCODE में, फ़ंक्शन इनपुट के रूप में केवल कुछ निश्चित तर्कों को स्वीकार कर सकता है।

  • तर्क या पैरामीटर, पहचानकर्ता हैं जो फ़ंक्शन के लिए एक चर बन जाते हैं।

  • LOLCODE में कार्य तर्क के रूप में उनके पास दिए गए मानों के अलावा किसी भी अन्य मान तक नहीं पहुँच सकते।

एक फंक्शन से रिटर्निंग वैल्यू

कोडिंग में वापसी का मतलब कुछ ऐसा है जो वापस दिया जाता है। प्रोग्रामिंग में, एक फ़ंक्शन प्रोग्राम का कुछ मूल्य वापस कर सकता है जब उसका निष्पादन पूरा हो जाता है। LOLCODE में, नीचे दिए गए अनुसार कार्य भिन्न मान लौटाते हैं -

  • FOUND YR <any_expression> जब फ़ंक्शन ब्लॉक को पूरी तरह से निष्पादित किया जाता है, तो अभिव्यक्ति का मूल्य लौटाता है।

  • GTFO कोई मान नहीं (NOOB), जो के समान है return 0 सी और जावा जैसी अन्य प्रोग्रामिंग भाषाओं में।

  • यदि कोई अन्य रिटर्न स्टेटमेंट नहीं मिलता है, तो IF U SAY SO निष्पादित किया गया है और IT चर में मान लौटाया गया है।

कॉलिंग फ़ंक्शंस

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

I IZ <function_name> [YR <expression_One> [AN YR <expression_Two> 
   [AN YR <expression_Three> ...]]] MKAY

किसी फ़ंक्शन को कॉल करते समय, फ़ंक्शन नाम से अभिव्यक्ति बनती है, उसके बाद फ़ंक्शन द्वारा स्वीकार किए जाने वाले तर्कों की संख्या होगी। ये तर्क सरल चर या कोई भी भाव हो सकते हैं। यदि कोई फ़ंक्शन सरल मान के बजाय किसी भी अभिव्यक्ति को स्वीकार करता है, तो फ़ंक्शन के मानों की गणना फ़ंक्शन को कॉल करने से पहले की जाती है।

कृपया याद रखें कि एक फ़ंक्शन द्वारा स्वीकार किए जाने वाले तर्कों की संख्या फ़ंक्शन की परिभाषा में परिभाषित की जानी चाहिए।

उदाहरण

HAI

HOW DUZ I MAINUMBA
   I HAS A NUMBA
   GIMMEH NUMBA
   FOUND YR NUMBA
IF U SAY SO

VISIBLE MAINUMBA

KTHXBYE

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

उदाहरण

HAI 1.2
HOW IZ I MULTIPLY YR FIRSTOPERANT AN YR SECONDOPERANT
   FOUND YR PRODUKT OF FIRSTOPERANT AN SECONDOPERANT
   IF U SAY SO
   VISIBLE I IZ MULTIPLY YR 2 AN YR 3
KTHXBYE

उपरोक्त फ़ंक्शन जो इनपुट ऑपरेंड का गुणन करता है, जब आप इसे चलाते हैं तो निम्न आउटपुट प्रिंट करेगा

sh-
4.3$ lci main.lo

6

उदाहरण

HAI 1.2
I HAS A STRINGARRAY ITZ A BUKKIT
   STRINGARRAY HAS A VAR17 ITZ "OBJECT1"
   STRINGARRAY HAS A VAR18 ITZ "OBJECT2"
   HOW IZ STRINGARRAY ACCESS YR VARIABLE
      FOUND YR STRINGARRAY'Z SRS VARIABLE
   IF U SAY SO
   I HAS A STRING ITZ "VAR17"
   VISIBLE STRINGARRAY IZ ACCESS YR STRING MKAY
KTHXBYE

उपरोक्त कोड का उत्पादन किस प्रकार होगा -

sh-
4.3$ lci main.lo 
OBJECT1

अपवाद हैंडलिंग रनटाइम त्रुटियों को संभालने के लिए शक्तिशाली तंत्रों में से एक है ताकि आवेदन के सामान्य प्रवाह को बनाए रखा जा सके। अन्य प्रोग्रामिंग भाषाओं की तरह अपवाद से निपटने के लिए LOLCODE के पास बहुत अधिक समर्थन नहीं है। अन्य भाषाओं में ट्राय-कैच ब्लॉक के समान, LOLCODE में PLZ-block है।

उदाहरण के लिए, यदि आप ऐसी फ़ाइल खोलना चाहते हैं जो मौजूद हो या न हो, तो उपयोग करें -

PLZ OPEN FILE "filename.TXT"?
   AWSUM THX
      VISIBLE FILE
      O NOES
   INVISIBLE "ERROR!"
KTHX

अपवाद का कारण बनने वाला कोड PLZ ब्लॉक में लिखा जाता है, और अपवाद O NOES ब्लॉक में संभाला जाता है। यहाँ, INVISIBLE कीवर्ड डीबगर को एक आंतरिक संदेश भेजता है।

कृपया ध्यान दें कि चूंकि LOLCODE का रखरखाव नियमित रूप से नहीं किया जाता है, LOLCODE अपवाद हैंडलिंग और कई अन्य सुविधाओं के लिए अधिक अपडेट उपलब्ध नहीं हैं।

पिछले अध्यायों ने आपको LOLCODE में प्रोग्रामिंग की व्याख्या की। इस अध्याय में, आप कुछ उदाहरणों को जानेंगे जो आपको LOLCODE में एक उन्नत स्तर पर कोड बनाने की सुविधा देता है।

उदाहरण 1: किसी संख्या की शक्ति की गणना करने का कार्यक्रम

इस उदाहरण में, आपको एक इनपुट नंबर की शक्ति की गणना करने के लिए कोड मिलेगा। उदाहरण के लिए, शक्ति 4 के लिए उठाया गया 2 16 के बराबर है।

HAI 1.2
HOW IZ I POWERTWO YR NUM
   BTW RETURN 1 IF 2 TO POWER OF 0
   BOTH SAEM NUM AN 0, O RLY?
   YA RLY, FOUND YR 1
   OIC
  
   BTW CALCULATE 2 TO POWER OF NUM
   I HAS A INDEX ITZ 0
   I HAS A TOTAL ITZ 1
   IM IN YR LOOP UPPIN YR INDEX TIL BOTH SAEM INDEX AN NUM
   TOTAL R PRODUKT OF TOTAL AN 2
   IM OUTTA YR LOOP
  
   FOUND YR TOTAL
   IF U SAY SO
   BTW OUTPUT: 8
   VISIBLE I IZ POWERTWO YR 4 MKAY
KTHXBYE

उपरोक्त कोड सफलतापूर्वक चलने के बाद निम्न आउटपुट प्रिंट करेगा -

sh-
4.3$ lci main.lo
16

उदाहरण 2: एक ऐरे बनाने का कार्यक्रम

यह उदाहरण पाँच तत्वों के साथ एक सरणी बनाने के लिए कोड दिखाता है और प्रत्येक तत्व मान 10 के साथ।

HAI 1.3
   OBTW
      CREATES A ONE DIMENSIONAL ARRAY WITH N ELEMENTS, EACH IS A 0
   TLDR
	HOW IZ I MAKEMATRIX YR N
      I HAS A MATRIX ITZ A BUKKIT
      IM IN YR LOOP UPPIN YR INDEX TIL BOTH SAEM INDEX N
         MATRIX HAS A SRS INDEX ITZ 10
      IM OUTTA YR LOOP
  
      FOUND YR MATRIX
   IF U SAY SO

      I HAS A N ITZ 5
      I HAS A MATRIX ITZ A BUKKIT
      MATRIX R I IZ MAKEMATRIX YR N MKAY

	   BTW PRINTS THE CONTENTS OF THE ARRAY
      IM IN YR LOOP UPPIN YR INDEX TIL BOTH SAEM INDEX N
         VISIBLE MATRIX'Z SRS INDEX
   IM OUTTA YR LOOP
KTHXBYE

उपरोक्त कोड निष्पादित करने पर आप निम्न आउटपुट देख सकते हैं -

sh-4.3$ lci main.lo
10
10
10
10
10

उदाहरण 3: किसी संख्या के गुणनखंड की गणना करने का कार्यक्रम

यह प्रोग्राम एक इनपुट नंबर के भाज्य की गणना करने के लिए कोड दिखाता है।

HAI 1.3
   HOW IZ I FACTORIAL YR N
   BOTH SAEM N AN 0
   O RLY?
	   YA RLY, FOUND YR 1
   NO WAI
      FOUND YR PRODUKT OF N AN I IZ FACTORIAL YR DIFF OF N AN 1 
      MKAY
   OIC
   IF U SAY SO

   VISIBLE I IZ FACTORIAL YR 6 MKAY
KTHXBYE

उपरोक्त कार्यक्रम संख्या 6 के भाज्य को प्रिंट करता है और आप नीचे दिखाए अनुसार आउटपुट देख सकते हैं -

sh-
4.3$ lci main.lo

720

उदाहरण 4: एक कैलकुलेटर डिजाइन करने का कार्यक्रम

आप LOLCODE प्रोग्रामिंग का उपयोग करके बुनियादी गणित संचालन करने के लिए एक कैलकुलेटर डिज़ाइन कर सकते हैं। नीचे दिए गए कोड को देखें -

HAI 1.2

   I HAS A V1
   I HAS A V2
   I HAS A CHOICE
   
   VISIBLE "VALUE1"
   GIMMEH V1
   VISIBLE "VALUE2"
   GIMMEH V2VISIBLE "Choose Operation? + - * /"
   GIMMEH CHOICE CHOICE, WTF?
   OMG "+"
      VISIBLE SUM OF V1 AN V2
      
      GTFO

   OMG "-"
      VISIBLE DIFF OF V1 AN V2

      GTFO
   OMG "*"
      VISIBLE PRODUKT OF V1 AN V2
      
      GTFO

   OMG "/"
      VISIBLE QUOSHUNT OF V1 AN V2

      GTFO
   OMGWTF
      VISIBLE "CHOOSE SOME OPERATION"
   OIC

KTHXBYE

जब हम निम्नलिखित कार्यक्रम को निम्नलिखित इनपुट के साथ निष्पादित करते हैं -

3
4
+

निष्पादन के बाद, उपरोक्त कार्यक्रम निम्नलिखित आउटपुट उत्पन्न करेगा -

VALUE1
VALUE2
Choose Operation? + - * /
7