ലുവാ ഭാഷയിലെ സ്ക്രിപ്റ്റുകൾ
ലുവായിൽ എഴുതിയ ഒരു സ്ക്രിപ്റ്റിന് അതിൻ്റെ നിർവ്വഹണം ആരംഭിക്കുന്നതിന് പ്രത്യേക പ്രവർത്തനങ്ങളൊന്നുമില്ല. ഒരു സ്ക്രിപ്റ്റ് എന്നത് ആദ്യത്തെ നിർദ്ദേശത്തിൽ നിന്ന് ആരംഭിക്കുന്ന ഒരു കൂട്ടം കമാൻഡുകൾ (നിർദ്ദേശങ്ങൾ) ആയി കണക്കാക്കാം.
ഒരു സ്ക്രിപ്റ്റ് വളരെ ലളിതമാണ്, ഒരു കമാൻഡ് മാത്രം ഉൾക്കൊള്ളുന്നതോ അല്ലെങ്കിൽ വളരെ സങ്കീർണ്ണമായതോ ആയ, പതിനായിരക്കണക്കിന്, നൂറുകണക്കിന്, ആയിരക്കണക്കിന് നിർദ്ദേശങ്ങൾ അടങ്ങിയിരിക്കുന്നു. തുടർച്ചയായ പ്രസ്താവനകൾ ഒരു അർദ്ധവിരാമം (;) ഉപയോഗിച്ച് വേർതിരിക്കാം. എന്നിരുന്നാലും, ഈ ആവശ്യകത നിർബന്ധമല്ല, അതിനാൽ ചുവടെയുള്ള എല്ലാ കോഡുകളും വാക്യഘടനാപരമായി ശരിയാണ്:
ലുവയിലെ വേരിയബിളുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു
സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയത്ത് മൂല്യങ്ങൾ സംഭരിക്കാൻ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു.
ലുവയിലെ വേരിയബിൾ പേരുകൾ
ലുവയിലെ വേരിയബിൾ പേരുകൾ (ഐഡൻ്റിഫയറുകൾ) അക്ഷരങ്ങൾ, അക്കങ്ങൾ, ഒരു അക്കത്തിൽ ആരംഭിക്കാത്ത ഒരു അടിവരയോടുകൂടിയ ഏത് ശ്രേണിയും ആകാം.
ദയവായി ശ്രദ്ധിക്കുക
Lua ഭാഷ കേസ് സെൻസിറ്റീവ് ആണ്, അതിനാൽ abc, Abc, ABC എന്നിവ വ്യത്യസ്ത പേരുകളാണ്.
ലുവാ ഭാഷയിൽ സംവരണം ചെയ്തിട്ടുള്ളതും വേരിയബിൾ നാമങ്ങളിൽ ഉപയോഗിക്കാൻ കഴിയാത്തതുമായ വാക്കുകൾ ചുവടെയുള്ള പട്ടിക കാണിക്കുന്നു:
പിന്നെ ബ്രേക്ക് ഡു അല്ലാതെ വേറെ
ഫംഗ്‌ഷനായി അവസാനിക്കുകയാണെങ്കിൽ തെറ്റായി
പ്രാദേശികമായി ഇല്ല അല്ലെങ്കിൽ
റിട്ടേൺ ആവർത്തിക്കുക, അത് വരെ സത്യമാണ്
കൂടാതെ, അണ്ടർ സ്കോറിൽ ആരംഭിക്കുന്ന എല്ലാ പേരുകളും വലിയ അക്ഷരങ്ങൾ (ഉദാഹരണത്തിന്, _VERSION) എന്നിവയും റിസർവ് ചെയ്തിരിക്കുന്നു.
ലുവായിൽ എന്തൊക്കെ വേരിയബിളുകൾ ഉണ്ട്?
ലുവയിലെ വേരിയബിളുകൾ ആഗോളമോ പ്രാദേശികമോ ആകാം. ഒരു വേരിയബിൾ പ്രാദേശികമായി വ്യക്തമായി പ്രഖ്യാപിച്ചിട്ടില്ലെങ്കിൽ, അത് ആഗോളമായി കണക്കാക്കപ്പെടുന്നു.
ലുവാ ഗ്ലോബൽ വേരിയബിൾസ്
ആദ്യത്തെ മൂല്യം നൽകുമ്പോൾ ഒരു ആഗോള വേരിയബിൾ ദൃശ്യമാകുന്നു. ആദ്യ മൂല്യം നൽകുന്നതിന് മുമ്പ്, ആഗോള വേരിയബിൾ ആക്സസ് ചെയ്യുന്നത് പൂജ്യത്തിൽ കലാശിക്കുന്നു.
MsgBox(ടോസ്ട്രിംഗ് (ജി)) --> ഇല്ല
MsgBox(ടോസ്ട്രിംഗ് (ജി)) --> 1
സ്ക്രിപ്റ്റിൻ്റെ എക്സിക്യൂഷൻ എൻവയോൺമെൻ്റ് നിലനിൽക്കുന്നിടത്തോളം ഒരു ആഗോള വേരിയബിൾ നിലനിൽക്കുകയും ആ പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കുന്ന ഏത് ലുവാ കോഡിനും ലഭ്യമാകുകയും ചെയ്യും.
ആവശ്യമെങ്കിൽ, ഒരു ഗ്ലോബൽ വേരിയബിളിന് nil എന്ന മൂല്യം നൽകിക്കൊണ്ട് നിങ്ങൾക്ക് വ്യക്തമായി നീക്കം ചെയ്യാം.
g = 1 - മൂല്യം 1 ഉപയോഗിച്ച് g ഒരു ആഗോള വേരിയബിൾ സൃഷ്ടിക്കുക
g = Nil - ഗ്ലോബൽ വേരിയബിൾ ഇല്ലാതാക്കുക
MsgBox(ടോസ്ട്രിംഗ് (ജി)) --> ഇല്ല
എല്ലാ ആഗോള വേരിയബിളുകളും ആഗോള പരിസ്ഥിതി എന്ന് വിളിക്കപ്പെടുന്ന ഒരു സാധാരണ പട്ടികയുടെ ഫീൽഡുകളാണ്. ആഗോള വേരിയബിൾ _G വഴി ഈ പട്ടിക ആക്സസ് ചെയ്യാൻ കഴിയും. ആഗോള പരിസ്ഥിതിയുടെ ഫീൽഡുകൾ എല്ലാ ആഗോള വേരിയബിളുകളും ആയതിനാൽ (_G ഉൾപ്പെടെ), തുടർന്ന് _G._G == _G.
ലുവാ ലോക്കൽ വേരിയബിളുകൾ
ഏതെങ്കിലും പ്രാദേശിക വേരിയബിളുകൾ ലോക്കൽ കീവേഡ് ഉപയോഗിച്ച് വ്യക്തമായി പ്രഖ്യാപിക്കണം. നിങ്ങൾക്ക് സ്ക്രിപ്റ്റിൽ എവിടെയും ഒരു ലോക്കൽ വേരിയബിൾ പ്രഖ്യാപിക്കാം. ഡിക്ലറേഷനിൽ വേരിയബിളിന് ഒരു പ്രാരംഭ മൂല്യം നൽകുന്നത് ഉൾപ്പെട്ടേക്കാം. മൂല്യമൊന്നും നൽകിയിട്ടില്ലെങ്കിൽ, വേരിയബിളിൽ nil അടങ്ങിയിരിക്കുന്നു.
ലോക്കൽ a - ഒരു ലോക്കൽ വേരിയബിൾ പ്രഖ്യാപിക്കുക a
ലോക്കൽ ബി = 1 - ഒരു ലോക്കൽ വേരിയബിൾ ബി പ്രഖ്യാപിക്കുക, അതിന് മൂല്യം 1 നൽകുക
ലോക്കൽ സി, ഡി = 2, 3 - ലോക്കൽ വേരിയബിളുകൾ സി, ഡി എന്നിവ പ്രഖ്യാപിക്കുക, അവയ്ക്ക് 2, 3 മൂല്യങ്ങൾ നൽകുക
ഒരു ലോക്കൽ വേരിയബിളിൻ്റെ വ്യാപ്തി പ്രഖ്യാപനത്തിന് ശേഷം ആരംഭിക്കുകയും ബ്ലോക്കിൻ്റെ അവസാനം വരെ തുടരുകയും ചെയ്യുന്നു.
കുറിപ്പ്
ഈ വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യം നിങ്ങൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയുന്ന പ്രോഗ്രാം കോഡിൻ്റെ മേഖലയാണ് ഒരു വേരിയബിളിൻ്റെ വ്യാപ്തി.
ഒരു ബ്ലോക്ക് അർത്ഥമാക്കുന്നത്:
നിയന്ത്രണ ഘടനയുടെ ബോഡി (എങ്കിൽ-പിന്നെ, വേറെ, വേണ്ടി, അതേസമയം, ആവർത്തിക്കുക);
ഫംഗ്ഷൻ ബോഡി;
do...end കീവേഡുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഒരു കോഡ് ശകലം.
ഒരു ബ്ലോക്കിന് പുറത്ത് ലോക്കൽ വേരിയബിൾ നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, അതിൻ്റെ വ്യാപ്തി സ്ക്രിപ്റ്റിൻ്റെ അവസാനം വരെ നീളുന്നു.
ലോക്കൽ i = 1 - വേരിയബിൾ i സ്ക്രിപ്റ്റിനുള്ളിൽ ലോക്കൽ ആണ്
അതേസമയം ഐ<= a do - цикл от 1 до 5
ലോക്കൽ a = i^2 - വേരിയബിൾ a, while ലൂപ്പിനുള്ളിൽ ലോക്കൽ ആണ്
MsgBox(a) --> 1, 4, 9, 16, 25
MsgBox(a) -->
i> 5 ആണെങ്കിൽ
ലോക്കൽ a - വേരിയബിൾ a അപ്പോൾ ഉള്ളിൽ ലോക്കൽ ആണ്
MsgBox(a) --> 10
MsgBox(a) --> 5 (ഗ്ലോബൽ എയിലേക്കുള്ള ആക്സസ് ഇവിടെ)
ലോക്കൽ a = 20 - വേരിയബിൾ a ലോക്കൽ ഇൻഡോ-എൻഡ് ആണ്
MsgBox(a) --> 20
MsgBox(a) --> 5 (ഗ്ലോബൽ എയിലേക്കുള്ള ആക്സസ് ഇവിടെ)
ദയവായി ശ്രദ്ധിക്കുക
സാധ്യമാകുമ്പോഴെല്ലാം, ആഗോള വേരിയബിളുകൾക്ക് പകരം പ്രാദേശിക വേരിയബിളുകൾ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു. ഇത് ആഗോള നെയിംസ്‌പെയ്‌സിനെ മലിനമാക്കുന്നത് ഒഴിവാക്കുകയും മികച്ച പ്രകടനം നൽകുകയും ചെയ്യും (ലുവയിലെ ലോക്കൽ വേരിയബിളുകൾ ആക്സസ് ചെയ്യുന്നത് ആഗോളതലത്തിൽ ആക്സസ് ചെയ്യുന്നതിനേക്കാൾ അൽപ്പം വേഗതയുള്ളതിനാൽ).
ലുവാ ഡാറ്റ തരങ്ങൾ
ഏത് തരത്തിലുള്ള ഡാറ്റയാണ് Lua പിന്തുണയ്ക്കുന്നത്?
ഇനിപ്പറയുന്ന ഡാറ്റ തരങ്ങളെ Lua പിന്തുണയ്ക്കുന്നു:
1. ഇല്ല (ഒന്നുമില്ല). ഒരു വേരിയബിളിൻ്റെ മൂല്യത്തിൻ്റെ അഭാവവുമായി പൊരുത്തപ്പെടുന്നു. ഈ തരത്തെ ഒരൊറ്റ മൂല്യം പ്രതിനിധീകരിക്കുന്നു - ഇല്ല.
2. ബൂളിയൻ (ലോജിക്കൽ). ഈ തരത്തിൽ തെറ്റും ശരിയും മൂല്യങ്ങൾ ഉൾപ്പെടുന്നു.
ലോജിക്കൽ പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ, മൂല്യം nil തെറ്റായി കണക്കാക്കുന്നു. നമ്പർ 0 ഉം ശൂന്യമായ സ്ട്രിംഗും ഉൾപ്പെടെ മറ്റെല്ലാ മൂല്യങ്ങളും ശരിയായി കണക്കാക്കുന്നു.
3. നമ്പർ (സംഖ്യ). സംഖ്യാ മൂല്യങ്ങളെ പ്രതിനിധീകരിക്കാൻ ഉപയോഗിക്കുന്നു.
സംഖ്യാ സ്ഥിരാങ്കങ്ങൾക്ക് ഒരു ഓപ്ഷണൽ ഫ്രാക്ഷണൽ ഭാഗവും ഒരു ഓപ്ഷണൽ ഡെസിമൽ എക്‌സ്‌പോണൻ്റും സൂചിപ്പിക്കാൻ കഴിയും, അത് "e" അല്ലെങ്കിൽ "E" പ്രതീകങ്ങളാൽ വ്യക്തമാക്കിയിരിക്കുന്നു. 0x പ്രിഫിക്‌സ് ഉപയോഗിച്ച് ഹെക്‌സാഡെസിമലിൽ പൂർണ്ണസംഖ്യാ സംഖ്യാ സ്ഥിരാങ്കങ്ങൾ വ്യക്തമാക്കാം.
സാധുവായ സംഖ്യാ സ്ഥിരാങ്കങ്ങളുടെ ഉദാഹരണങ്ങൾ: 3, 3.0, 3.1415926, 314.16e-2, 0xff.
4. സ്ട്രിംഗ്. സ്ട്രിംഗുകളെ പ്രതിനിധീകരിക്കാൻ ഉപയോഗിക്കുന്നു.
ഒറ്റ അല്ലെങ്കിൽ ഇരട്ട ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രതീകങ്ങളുടെ ഒരു ശ്രേണിയായി സ്ട്രിംഗ് മൂല്യങ്ങൾ സൂചിപ്പിച്ചിരിക്കുന്നു:
a = "ഇതൊരു സ്ട്രിംഗ് ആണ്"
b = "ഇത് രണ്ടാമത്തെ വരിയാണ്"
ഇരട്ട ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന സ്ട്രിംഗുകൾ "\" പ്രതീകത്തിൽ (ബാക്ക്സ്ലാഷ്) ആരംഭിക്കുന്ന സി പോലെയുള്ള എസ്കേപ്പ് സീക്വൻസുകൾ ഉപയോഗിച്ച് വ്യാഖ്യാനിക്കാം:
\b (സ്പേസ്),
\n (ലൈൻ ഫീഡ്),
\r (വണ്ടി മടക്കം);
\t (തിരശ്ചീന ടാബ്),
\\ (ബാക്ക്സ്ലാഷ്);
\"" (ഇരട്ട ഉദ്ധരണി);
\" (ഒറ്റ ഉദ്ധരണി).
ദയവായി ശ്രദ്ധിക്കുക
ഒരു എസ്കേപ്പ് സീക്വൻസ് ഉപയോഗിച്ച് ഒരു സ്‌ട്രിംഗിലെ ഒരു പ്രതീകത്തെ അതിൻ്റെ സ്വന്തം കോഡ് ഉപയോഗിച്ച് പ്രതിനിധീകരിക്കാനും കഴിയും:
ഇവിടെ ddd എന്നത് മൂന്ന് അക്കങ്ങളിൽ കൂടാത്ത ഒരു ശ്രേണിയാണ്.
ഉദ്ധരണികൾക്ക് പുറമേ, ഒരു സ്ട്രിംഗ് നിർവചിക്കുന്നതിന് ഇരട്ട ചതുര ബ്രാക്കറ്റുകളും ഉപയോഗിക്കാം:
ഇരട്ട സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഉപയോഗിച്ച് ഒരു സ്ട്രിംഗ് നിർവചിക്കുന്നത് എല്ലാ എസ്കേപ്പ് സീക്വൻസുകളും അവഗണിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അതായത്, വിവരിച്ചിരിക്കുന്നതുപോലെ സ്ട്രിംഗ് പൂർണ്ണമായും സൃഷ്ടിച്ചിരിക്കുന്നു:
ലോക്കൽ എ = [] ലുവായിൽ]=]
ഒരു പദം ഉണ്ടാകും: "ലുവയിലെ സ്ട്രിംഗിൻ്റെ നിർവ്വചനം"
5. പ്രവർത്തനം. ലുവയിലെ ഫംഗ്ഷനുകൾ വേരിയബിളുകളിലേക്ക് എഴുതുകയും മറ്റ് ഫംഗ്‌ഷനുകളിലേക്ക് പാരാമീറ്ററുകളായി കൈമാറുകയും ഫംഗ്ഷൻ എക്‌സിക്യൂഷൻ്റെ ഫലമായി നൽകുകയും ചെയ്യാം.
6. പട്ടിക (പട്ടിക). ഫീൽഡുകൾ അല്ലെങ്കിൽ പട്ടിക ഘടകങ്ങൾ എന്ന് വിളിക്കുന്ന കീ-മൂല്യം ജോഡികളുടെ ഒരു ശേഖരമാണ് പട്ടിക. കീകളും ടേബിൾ ഫീൽഡ് മൂല്യങ്ങളും nil ഒഴികെ ഏത് തരത്തിലും ആകാം. പട്ടികകൾക്ക് ഒരു നിശ്ചിത വലുപ്പമില്ല: എപ്പോൾ വേണമെങ്കിലും അവയിൽ അനിയന്ത്രിതമായ ഘടകങ്ങൾ ചേർക്കാൻ കഴിയും.
"ലുവയിൽ പട്ടികകൾ സൃഷ്ടിക്കുന്നു" എന്ന ലേഖനത്തിൽ കൂടുതൽ വായിക്കുക
7. ഉപയോക്തൃ ഡാറ്റ (ഉപയോക്തൃ ഡാറ്റ). ഒരു പ്രത്യേക ഡാറ്റാ തരമാണ്. ഈ തരത്തിലുള്ള മൂല്യങ്ങൾ ലുവാ സ്ക്രിപ്റ്റിൽ നേരിട്ട് സൃഷ്ടിക്കാനോ പരിഷ്ക്കരിക്കാനോ കഴിയില്ല.
സ്ക്രിപ്റ്റ് കോളിംഗ് പ്രോഗ്രാമിലോ C-യിൽ എഴുതിയ ലൈബ്രറികളിലോ സൃഷ്‌ടിച്ച പുതിയ തരങ്ങളെ പ്രതിനിധീകരിക്കാൻ ഉപയോക്തൃ ഡാറ്റ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, CronosPRO-യ്‌ക്കുള്ള Lua വിപുലീകരണ ലൈബ്രറികൾ ഇനിപ്പറയുന്നതുപോലുള്ള ഒബ്‌ജക്റ്റുകളെ പ്രതിനിധീകരിക്കാൻ ഈ തരം ഉപയോഗിക്കുന്നു:
ഡാറ്റ ബാങ്കുകൾ (ബാങ്ക് ക്ലാസ്);
ഡാറ്റാബേസുകൾ (ക്ലാസ് ബേസ്);
റെക്കോർഡുകൾ (റെക്കോർഡ് ക്ലാസ്) മുതലായവ.
8. ത്രെഡ് (ഫ്ലോ). നിർവ്വഹണത്തിൻ്റെ ത്രെഡുമായി യോജിക്കുന്നു. ഈ ത്രെഡുകൾ ഒരു തരത്തിലും ഓപ്പറേറ്റിംഗ് സിസ്റ്റവുമായി ബന്ധപ്പെടുത്തിയിട്ടില്ല, മാത്രമല്ല ലുവാ തന്നെ പിന്തുണയ്ക്കുകയും ചെയ്യുന്നു.
ലുവായിൽ ഒരു വേരിയബിളിൻ്റെ തരം എങ്ങനെ സജ്ജീകരിക്കാം?
Lua ഒരു വേരിയബിളിൻ്റെ തരം വ്യക്തമായി സജ്ജീകരിക്കുന്നില്ല. വേരിയബിളിന് ഒരു മൂല്യം നൽകുമ്പോൾ ഒരു വേരിയബിളിൻ്റെ തരം സ്ഥാപിക്കപ്പെടുന്നു. ഏത് വേരിയബിളിനും ഏത് തരത്തിലുള്ള മൂല്യവും നൽകാം (മുമ്പ് അതിൽ അടങ്ങിയിരിക്കുന്ന മൂല്യത്തിൻ്റെ തരം പരിഗണിക്കാതെ).
a = 123 - വേരിയബിൾ a ടൈപ്പ് നമ്പർ ആണ്
a = "123" - ഇപ്പോൾ വേരിയബിൾ a എന്നത് ടൈപ്പ് സ്ട്രിംഗ് ആണ്
a = true - ഇപ്പോൾ വേരിയബിൾ a ബൂളിയൻ തരം ആണ്
a = () - ഇപ്പോൾ വേരിയബിൾ a ടൈപ്പ് ടേബിളാണ്
ദയവായി ശ്രദ്ധിക്കുക
പട്ടിക, ഫംഗ്ഷൻ, ത്രെഡ്, ഉപയോക്തൃ ഡാറ്റ എന്നിവ പോലുള്ള വേരിയബിളുകളിൽ ഡാറ്റ തന്നെ അടങ്ങിയിട്ടില്ല, മറിച്ച് അനുബന്ധ ഒബ്‌ജക്റ്റുകളിലേക്ക് റഫറൻസുകൾ സംഭരിക്കുന്നു. അസൈൻ ചെയ്യുമ്പോൾ, ഒരു ഫംഗ്‌ഷനിലേക്ക് ഒരു ആർഗ്യുമെൻ്റായി കടന്നുപോകുമ്പോൾ, അതിൻ്റെ ഫലമായി ഫംഗ്‌ഷനിൽ നിന്ന് മടങ്ങുമ്പോൾ, ഒബ്‌ജക്റ്റുകൾ പകർത്തില്ല, അവയിലേക്കുള്ള റഫറൻസുകൾ മാത്രമേ പകർത്തൂ.
a = () - ഒരു പട്ടിക ഉണ്ടാക്കുക. a എന്ന വേരിയബിളിൽ പട്ടികയിലേക്കുള്ള ഒരു ലിങ്ക് അടങ്ങിയിരിക്കുന്നു
b = a - വേരിയബിൾ b എന്നത് a യുടെ അതേ പട്ടികയെ സൂചിപ്പിക്കുന്നു
a = 10 - സൂചിക 1 ഉള്ള പട്ടിക ഘടകത്തിന് മൂല്യം 10 നൽകിയിരിക്കുന്നു
MsgBox(b) --> "10"
MsgBox(a) --> "20"
ശേഷിക്കുന്ന ഡാറ്റ ഉടനടി മൂല്യങ്ങളാണ്.
MsgBox(a) --> "20"
MsgBox(b) --> "10"
ലുവായിൽ ഒരു വേരിയബിളിൻ്റെ തരം എങ്ങനെ ലഭിക്കും?
ഒരു വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യത്തിൻ്റെ തരം സ്റ്റാൻഡേർഡ് ടൈപ്പ് ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിർണ്ണയിക്കാവുന്നതാണ്. ഈ ഫംഗ്ഷൻ തരം പേര് ("nil", "number", "string", "boolean", "table", "function", "thread", "userdata") അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു.
t = തരം ("ഇതൊരു സ്ട്രിംഗ് ആണ്") - t "സ്ട്രിംഗ്" എന്നതിന് തുല്യമാണ്
t = തരം (123) - t "നമ്പറിന്" തുല്യമാണ്
t = തരം (തരം) - t "പ്രവർത്തനം" എന്നതിന് തുല്യമാണ്
t = തരം (ശരി) - t "ബൂളിയൻ" എന്നതിന് തുല്യമാണ്
t = തരം (പൂജ്യം) - t "nil" എന്നതിന് തുല്യമാണ്
t = തരം (CroApp.GetBank()) - t "ഉപയോക്തൃ ഡാറ്റ" എന്നതിന് തുല്യമാണ്
ലുവായിലെ ഒരു വേരിയബിളിൻ്റെ തരം എങ്ങനെ പരിവർത്തനം ചെയ്യാം?
ലുവ യാന്ത്രികമായി നമ്പറുകളെ സ്ട്രിംഗുകളിലേക്കും തിരിച്ചും ആവശ്യമുള്ളപ്പോൾ പരിവർത്തനം ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ഒരു ഗണിത പ്രവർത്തനത്തിൽ ഒരു സ്ട്രിംഗ് മൂല്യം ഒരു ഓപ്പറാൻറ് ആണെങ്കിൽ, അത് ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടും. അതുപോലെ, ഒരു സ്ട്രിംഗ് മൂല്യം പ്രതീക്ഷിക്കുന്ന സ്ഥലത്ത് കണ്ടുമുട്ടുന്ന ഒരു സംഖ്യാ മൂല്യം ഒരു സ്‌ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടും.
a = "10" + 2 - a 12 ന് തുല്യമാണ്
a = "10" + 2 - a സമം "10 + 2"
a = "-5.3e-10"*"2" - a സമം -1.06e-09
a = "സ്ട്രിംഗ്" + 2 - പിശക്! 'സ്ട്രിംഗ്' സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയില്ല
സ്റ്റാൻഡേർഡ് ടോസ്ട്രിംഗ് ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഏത് തരത്തിലുള്ള മൂല്യവും ഒരു സ്‌ട്രിംഗിലേക്ക് വ്യക്തമായി പരിവർത്തനം ചെയ്യാൻ കഴിയും.
a = tostring(10) - a എന്നത് "10" ന് തുല്യമാണ്
a = tostring (true) - a സമം "ശരി"
a = tostring (nil) - a സമം "nil"
a = tostring (( = "ഇത് ഫീൽഡ് 1")) - a സമം "പട്ടിക: 06DB1058"
മുമ്പത്തെ ഉദാഹരണത്തിൽ നിന്ന്, പട്ടികകളിലെ ഉള്ളടക്കങ്ങൾ ടോസ്ട്രിംഗ് ഫംഗ്ഷൻ വഴി പരിവർത്തനം ചെയ്യപ്പെടുന്നില്ലെന്ന് വ്യക്തമാണ്. റെൻഡർ ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ പരിവർത്തനം ചെയ്യാൻ കഴിയും.
a = റെൻഡർ(10) - a തുല്യ "10"
a = render(true) - a സമം "ശരി"
a = റെൻഡർ (nil) - a സമം "nil"
a = റെൻഡർ (( = "ഇത് ഫീൽഡ് 1")) - a സമം "( = "ഇത് ഫീൽഡ് 1)"
ഒരു മൂല്യത്തെ ഒരു സംഖ്യയിലേക്ക് വ്യക്തമായി പരിവർത്തനം ചെയ്യാൻ, നിങ്ങൾക്ക് സ്റ്റാൻഡേർഡ് ടോൺനമ്പർ ഫംഗ്ഷൻ ഉപയോഗിക്കാം. മൂല്യം ഒരു സംഖ്യയായി പരിവർത്തനം ചെയ്യാവുന്ന ഒരു സ്ട്രിംഗ് ആണെങ്കിൽ (അല്ലെങ്കിൽ ഇതിനകം ഒരു സംഖ്യയാണ്), ഫംഗ്ഷൻ പരിവർത്തനത്തിൻ്റെ ഫലം നൽകുന്നു, അല്ലാത്തപക്ഷം അത് പൂജ്യമായി നൽകുന്നു.
a = tonumber("10") - a എന്നത് "10" ന് തുല്യമാണ്
a = tonumber("10"..".5") - a 10.5 ന് തുല്യമാണ്
a = ടോണമ്പർ (ശരി) - a സമം "പൂജ്യം"
a = ടോണമ്പർ (പൂജ്യം) - a "nil" എന്നതിന് തുല്യമാണ്
ലുവയിൽ അഭിപ്രായങ്ങൾ ക്രമീകരിക്കുന്നു
ലുവായിലെ ഒരു കമൻ്റ് രണ്ട് മൈനസ് ചിഹ്നങ്ങളിൽ (--) ആരംഭിക്കുകയും വരിയുടെ അവസാനം വരെ തുടരുകയും ചെയ്യുന്നു.
ലോക്കൽ a = 1 - ഒറ്റവരി അഭിപ്രായം
"--" പ്രതീകങ്ങൾക്ക് തൊട്ടുപിന്നാലെ രണ്ട് ഓപ്പണിംഗ് സ്ക്വയർ ബ്രാക്കറ്റുകൾ ([[) ഉണ്ടെങ്കിൽ, കമൻ്റ് മൾട്ടിലൈൻ ആണ് കൂടാതെ രണ്ട് ക്ലോസിംഗ് സ്ക്വയർ ബ്രാക്കറ്റുകൾ വരെ തുടരും (]]).
ലോക്കൽ a = 1 - [[ മൾട്ടിലൈൻ
അഭിപ്രായം ]]
കമൻ്റുകളിലെ ഇരട്ട പരാൻതീസിസുകൾ നെസ്റ്റ് ചെയ്യാവുന്നതാണ്. അവ ആശയക്കുഴപ്പത്തിലാക്കാതിരിക്കാൻ, ബ്രാക്കറ്റുകൾക്കിടയിൽ തുല്യ ചിഹ്നം (=) ചേർത്തിരിക്കുന്നു:
ലോക്കൽ a = [[ക്രോണോസ് കമ്പനി]] - [=[
ലോക്കൽ a = [[ക്രോണോസ് കമ്പനി]]
“=” പ്രതീകങ്ങളുടെ എണ്ണം കൂടുകൂട്ടൽ നിർണ്ണയിക്കുന്നു:
ലോക്കൽ a = [=[ചില സ്ട്രിംഗിൻ്റെ [] ലുവായിലെ നിർവചനം]=] --[==[
ലോക്കൽ a = [=[ചില സ്ട്രിംഗിൻ്റെ നിർവചനം [] ലുവായിലെ]=]
ലുവയിൽ ഉപയോഗിച്ച പ്രവർത്തനങ്ങൾ
ലുവായിൽ എഴുതിയ പദപ്രയോഗങ്ങളിൽ ഇനിപ്പറയുന്ന തരത്തിലുള്ള പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കാം:
1. ഗണിത പ്രവർത്തനങ്ങൾ.
ഇനിപ്പറയുന്ന ഗണിത പ്രവർത്തനങ്ങളെ Lua പിന്തുണയ്ക്കുന്നു:
+ (കൂടാതെ);
- (കുറക്കൽ);
* (ഗുണനം);
/ (ഡിവിഷൻ);
^ (എക്‌സ്‌പോണൻഷ്യേഷൻ);
% (വിഭജനത്തിൻ്റെ ശേഷിപ്പ്).
ദയവായി ശ്രദ്ധിക്കുക
ഗണിത പ്രവർത്തനങ്ങൾ അക്കങ്ങൾക്കും സ്ട്രിംഗുകൾക്കും ബാധകമാണ്, ഈ സാഹചര്യത്തിൽ അക്കങ്ങളായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു.
2. താരതമ്യ പ്രവർത്തനങ്ങൾ.
ഇനിപ്പറയുന്ന മൂല്യ താരതമ്യ പ്രവർത്തനങ്ങൾ Lua-ൽ അനുവദനീയമാണ്:
== (തുല്യം);
~= (തുല്യമല്ല);
< (меньше);
> (കൂടുതൽ);
<= (меньше или равно);
>= (അതിനേക്കാൾ വലുതോ തുല്യമോ).
ദയവായി ശ്രദ്ധിക്കുക
താരതമ്യ പ്രവർത്തനങ്ങൾ എല്ലായ്പ്പോഴും ബൂളിയൻ മൂല്യം ശരിയോ തെറ്റോ നൽകുന്നു.
സംഖ്യകളെ സ്ട്രിംഗുകളാക്കി മാറ്റുന്നതിനുള്ള നിയമങ്ങൾ (തിരിച്ചും) താരതമ്യങ്ങൾക്കായി പ്രവർത്തിക്കില്ല, അതായത് "0" == 0 എന്ന പദപ്രയോഗം തെറ്റായി ഫലിക്കുന്നു.
3. ലോജിക്കൽ പ്രവർത്തനങ്ങൾ.
ലോജിക്കൽ പ്രവർത്തനങ്ങളിൽ ഇവ ഉൾപ്പെടുന്നു:
കൂടാതെ (ലോജിക്കൽ AND).
തെറ്റോ ശൂന്യമോ ആണെങ്കിൽ, ഓപ്പറേറ്ററും അതിൻ്റെ ആദ്യ പ്രവർത്തനവും തിരികെ നൽകുന്നു. അല്ലെങ്കിൽ, പ്രവർത്തനം രണ്ടാമത്തെ ഓപ്പറാൻറ് നൽകുന്നു (ഈ ഓപ്പറാൻറ് ഏത് തരത്തിലും ആകാം).
a = (പൂജ്യം കൂടാതെ 5) - a തുല്യം nil
a == (തെറ്റും 5) - a സമം തെറ്റ്
a == (4 ഉം 5 ഉം) - a 5 ന് തുല്യമാണ്
അല്ലെങ്കിൽ (ലോജിക്കൽ OR).
അല്ലെങ്കിൽ ഓപ്പറേഷൻ ആദ്യത്തെ ഓപ്പറാൻറ്, അത് തെറ്റോ ഇല്ലെങ്കിൽ, അത് രണ്ടാമത്തെ ഓപ്പറാൻറ് നൽകുന്നു.
a == (4 അല്ലെങ്കിൽ 5) - a 4 ന് തുല്യമാണ്
a == (തെറ്റ് അല്ലെങ്കിൽ 5) - a തുല്യം 5
ദയവായി ശ്രദ്ധിക്കുക
ലോജിക്കൽ ഓപ്പറേറ്റർമാർക്കും കൂടാതെ അല്ലെങ്കിൽ ഏതെങ്കിലും തരത്തിലുള്ള മൂല്യങ്ങൾ തിരികെ നൽകാനും കഴിയും.
ലോജിക്കൽ ഓപ്പറേറ്റർമാരും കൂടാതെ രണ്ടാമത്തെ ഓപ്പറണ്ടിൻ്റെ മൂല്യം അത് തിരികെ നൽകേണ്ടതുണ്ടെങ്കിൽ മാത്രം വിലയിരുത്തുന്നു. ഇത് ആവശ്യമില്ലെങ്കിൽ, രണ്ടാമത്തെ ഓപ്പറാൻറ് വിലയിരുത്തപ്പെടുന്നില്ല. ഉദാഹരണത്തിന്:
a == (4 അല്ലെങ്കിൽ f()) - f() ഫംഗ്ഷൻ വിളിക്കില്ല
അല്ല (ലോജിക്കൽ അല്ല).
അല്ലാത്ത പ്രവർത്തനം എല്ലായ്പ്പോഴും ശരിയോ തെറ്റോ നൽകുന്നു.
4. സംയോജന പ്രവർത്തനം.
സ്ട്രിംഗുകൾ സംയോജിപ്പിക്കാൻ (യൂണിറ്റ്) ഓപ്പറേഷൻ ഉപയോഗിക്കുക ... (രണ്ട് ഡോട്ടുകൾ).
a = “ക്രോണോസ്.”-”..“അറിയിക്കുക” - വേരിയബിളിന് “ക്രോണോസ്-അറിയിക്കുക” എന്ന മൂല്യം ലഭിക്കും.
ദയവായി ശ്രദ്ധിക്കുക
ഒന്നോ രണ്ടോ ഓപ്പറണ്ടുകൾ സംഖ്യകളാണെങ്കിൽ, അവ സ്ട്രിംഗുകളായി പരിവർത്തനം ചെയ്യപ്പെടും.
a = 0..1 - വേരിയബിൾ a ന് “01” മൂല്യം ലഭിക്കും
5. ദൈർഘ്യം നേടുന്നതിനുള്ള പ്രവർത്തനം.
ഒരു സ്ട്രിംഗിൻ്റെ നീളം ലഭിക്കാൻ ഉപയോഗിക്കാവുന്ന ഒരു നീളം ഓപ്പറേറ്റർ # ലുവ നിർവ്വചിക്കുന്നു.
a = "സ്ട്രിംഗ്"
ലെൻ = #എ - ലെൻ 6 ന് തുല്യമാണ്
ലെൻ = #“മറ്റൊരു വരി” - ലെൻ 10 ന് തുല്യമാണ്
ദയവായി ശ്രദ്ധിക്കുക
ഒരു അറേയുടെ പരമാവധി സൂചിക (അല്ലെങ്കിൽ വലുപ്പം) കണ്ടെത്താൻ നിങ്ങൾക്ക് # പ്രവർത്തനം ഉപയോഗിക്കാം. കൂടുതൽ വിവരങ്ങൾക്ക്, "ലുവയിലെ അറേകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു" എന്ന ലേഖനം കാണുക.
ലുവയിലെ പ്രവർത്തനങ്ങളുടെ മുൻഗണന
ലുവായിൽ, ഇനിപ്പറയുന്ന മുൻഗണന അനുസരിച്ച് പ്രവർത്തനങ്ങൾ നടത്തുന്നു (അവരോഹണ ക്രമത്തിൽ):
2. അല്ല # - (അനറി)
6. < > <= >= ~= ==
ഫോമുകളിൽ നിന്ന് സ്ക്രിപ്റ്റുകൾ വിളിക്കുന്നു
ഓരോ ഫോമിനും (നെസ്റ്റഡ് ഫോമുകൾ ഉൾപ്പെടെ) അതുമായി ബന്ധപ്പെട്ട ഒരു പ്രത്യേക സ്ക്രിപ്റ്റ് ഉണ്ട്, അതിൽ സാധാരണയായി ഫോമിനും അതിൻ്റെ ഘടകങ്ങൾക്കും ഇവൻ്റുകൾ കൈകാര്യം ചെയ്യുന്ന ഫംഗ്ഷനുകൾ അടങ്ങിയിരിക്കുന്നു.
ഫോം സമാരംഭിക്കുമ്പോൾ, അതിൻ്റെ സ്ക്രിപ്റ്റ് ആഗോള പരിതസ്ഥിതിയിലേക്ക് ലോഡ് ചെയ്യപ്പെടും. ഒരു ഫോമിലോ അതിൻ്റെ ഘടകത്തിലോ ഒരു ഇവൻ്റ് സംഭവിക്കുമ്പോൾ, ഈ ഇവൻ്റുമായി ബന്ധപ്പെട്ട ഹാൻഡ്‌ലർ ഫംഗ്‌ഷനെ സിസ്റ്റം വിളിക്കുന്നു.
ഫോം സ്ക്രിപ്റ്റ്, അതിൽ മൊഡ്യൂൾ ഫംഗ്ഷനിലേക്കുള്ള ഒരു കോൾ അടങ്ങിയിട്ടില്ലെങ്കിലും, യഥാർത്ഥത്തിൽ ഒരു മൊഡ്യൂൾ ആണെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ലോക്കൽ കീവേഡ് ഇല്ലാതെ ഫോം സ്ക്രിപ്റ്റിൽ പ്രഖ്യാപിച്ച വേരിയബിളുകൾ ആഗോള പരിതസ്ഥിതിയിൽ സ്ഥാപിച്ചിട്ടില്ലെന്നും ഈ സ്ക്രിപ്റ്റിൽ മാത്രമേ ലഭ്യമാകൂ എന്നും ഇതിനർത്ഥം. നിങ്ങൾക്ക് മറ്റ് രൂപങ്ങളുടെ സ്ക്രിപ്റ്റുകൾക്ക് ഒരു മൂല്യം ലഭ്യമാക്കണമെങ്കിൽ, അത് ആഗോള പട്ടികയിൽ വ്യക്തമായി നിർവചിച്ചിരിക്കണം _G:
ലോക്കൽ a = _G.var
പ്രസ്താവനകളുടെ ബ്ലോക്കുകൾ (നിർദ്ദേശങ്ങൾ)
അടിസ്ഥാന Lua ഓപ്പറേറ്റർമാരിൽ ഉൾപ്പെടുന്നു:
നിയമനം;
സോപാധിക ഓപ്പറേറ്റർ;
ലൂപ്പുകൾ സംഘടിപ്പിക്കുന്നതിനുള്ള ഓപ്പറേറ്റർമാർ.
ഡോ... എൻഡ് കൺസ്ട്രക്‌റ്റ് ഉപയോഗിച്ച് ഒരു കൂട്ടം പ്രസ്താവനകൾ ഒരു ബ്ലോക്കായി (കോമ്പൗണ്ട് സ്റ്റേറ്റ്മെൻ്റ്) സംയോജിപ്പിക്കാം.
ചെയ്യൂ - ബ്ലോക്കിൻ്റെ ആരംഭം
<оператор1>- ബ്ലോക്ക് ബോഡി
<оператор2>
<операторN>
അവസാനം - ബ്ലോക്കിൻ്റെ അവസാനം
ഒരു ബ്ലോക്ക് ലോക്കൽ വേരിയബിളുകൾ നിർവചിക്കാവുന്ന ഒരു പുതിയ സ്കോപ്പ് തുറക്കുന്നു.
a = 5 - ആഗോള വേരിയബിൾ a
ലോക്കൽ a = 20 - ഒരു ലോക്കൽ വേരിയബിൾ a എന്നത് do-end-നുള്ളിൽ നിർവചിച്ചിരിക്കുന്നു
MsgBox(a) --> 20
MsgBox(a) --> 5 (ഇവിടെ റഫറൻസ് ഗ്ലോബൽ a ആണ്)
ലുവയിലെ അസൈൻമെൻ്റ് ഓപ്പറേറ്റർ
ഒരു അസൈൻമെൻ്റ് ഒരു വേരിയബിളിൻ്റെ അല്ലെങ്കിൽ പട്ടിക ഫീൽഡിൻ്റെ മൂല്യം മാറ്റുന്നു. അതിൻ്റെ ഏറ്റവും ലളിതമായ രൂപത്തിൽ, ഒരു അസൈൻമെൻ്റ് ഇതുപോലെയായിരിക്കാം:
a = 1 - വേരിയബിൾ a ന് മൂല്യം 1 നൽകിയിരിക്കുന്നു
a = b + c - വേരിയബിൾ a, b, c എന്നീ വേരിയബിളുകളുടെ മൂല്യങ്ങളുടെ ആകെത്തുകയാണ്.
a = f(x) - f(x) എന്ന ഫംഗ്ഷൻ നൽകുന്ന മൂല്യം a വേരിയബിളിന് നൽകിയിരിക്കുന്നു
അസൈൻമെൻ്റ് ഓപ്പറേറ്ററുടെ ഇടതുവശത്തുള്ള നിരവധി വേരിയബിളുകൾക്ക് അസൈൻമെൻ്റ് ഓപ്പറേറ്ററുടെ വലതുവശത്ത് എഴുതിയിരിക്കുന്ന നിരവധി എക്സ്പ്രഷനുകളുടെ മൂല്യങ്ങൾ ലഭിക്കുമ്പോൾ, ഒന്നിലധികം അസൈൻമെൻ്റ് എന്ന് വിളിക്കപ്പെടുന്നതിനെ Lua അനുവദിക്കുന്നു:
a, b = 1.5 * c - a 1 ന് തുല്യമാണ്; b സമം 5*c
മൂല്യങ്ങളേക്കാൾ കൂടുതൽ വേരിയബിളുകൾ ഉണ്ടെങ്കിൽ, "അധിക" വേരിയബിളുകൾ nil ആണ്.
a, b, c = 1, 2 - a എന്നത് 1 ആണ്; b എന്നത് 2 ന് തുല്യമാണ്; c പൂജ്യത്തിന് തുല്യമാണ്
വേരിയബിളുകളേക്കാൾ കൂടുതൽ മൂല്യങ്ങൾ ഉണ്ടെങ്കിൽ, "അധിക" മൂല്യങ്ങൾ അവഗണിക്കപ്പെടും.
a, b = 1, 2, 3 - a 1 ന് തുല്യമാണ്; b എന്നത് 2 ന് തുല്യമാണ്; മൂല്യം 3 ഉപയോഗിച്ചിട്ടില്ല
വേരിയബിളുകൾക്കിടയിൽ മൂല്യങ്ങൾ കൈമാറാൻ ഒന്നിലധികം അസൈൻമെൻ്റ് ഉപയോഗിക്കാം:
a = 10; b = 20 - a 10, b 20 ന് തുല്യം
a, b = b, a - ഇപ്പോൾ a 20 ആണ്, b 10 ആണ്
ലുവായിലെ സോപാധിക പ്രസ്താവന (എങ്കിൽ).
if സ്റ്റേറ്റ്മെൻ്റ് നൽകിയിരിക്കുന്ന വ്യവസ്ഥയുടെ സത്യാവസ്ഥ പരിശോധിക്കുന്നു. വ്യവസ്ഥ ശരിയാണെങ്കിൽ, കീവേഡിന് (പിന്നെ വിഭാഗം) താഴെയുള്ള കോഡിൻ്റെ ഭാഗം എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. അല്ലെങ്കിൽ, മറ്റൊരു കീവേഡിന് (മറ്റൊരു വിഭാഗം) താഴെയുള്ള കോഡ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും.
a > b ആണെങ്കിൽ
a റിട്ടേൺ ചെയ്യുക - a bയേക്കാൾ വലുതാണെങ്കിൽ, a തിരികെ നൽകുക
b - അല്ലാത്തപക്ഷം - തിരികെ b
മറ്റ് വിഭാഗം ഓപ്ഷണൽ ആണ്.
എങ്കിൽ a< 0 then
a = 0 - a 0-ൽ കുറവാണെങ്കിൽ, a 0 ആയി സജ്ജമാക്കുക
നെസ്റ്റഡ് ഇഫ് സ്റ്റേറ്റ്‌മെൻ്റുകൾക്ക് പകരം, നിങ്ങൾക്ക് elseif കൺസ്ട്രക്‌റ്റ് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കോഡ്:
നിങ്ങൾ അത് ഇനിപ്പറയുന്നവ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിച്ചാൽ ഇത് മനസ്സിലാക്കാൻ എളുപ്പമാകും:
"ഇവാൻ" തിരികെ നൽകുക - a ആണെങ്കിൽ 1
elseif a == 2 അപ്പോൾ
"പീറ്റർ" തിരികെ നൽകുക - a ആണെങ്കിൽ 2
elseif a == 3 അപ്പോൾ
"സെർജി" തിരികെ നൽകുക - a 3 ന് തുല്യമാണെങ്കിൽ
"അത്തരമൊരു കളിക്കാരനില്ല" എന്ന് തിരികെ നൽകുക - ഒരു എങ്കിൽ - മുകളിൽ പറഞ്ഞതൊന്നും
ലുവയിൽ ലൂപ്പ് ചെയ്യുമ്പോൾ
അതേസമയം ഓപ്പറേറ്റർ ഒരു മുൻവ്യവസ്ഥയോടെ ലൂപ്പുകൾ സംഘടിപ്പിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്, കൂടാതെ ഇനിപ്പറയുന്ന ഫോം ഉണ്ട്:
സമയത്ത്
... - ലൂപ്പ് ബോഡി
ലൂപ്പിൻ്റെ ഓരോ ആവർത്തനത്തിനും മുമ്പായി, അവസ്ഥ പരിശോധിക്കുന്നു
വ്യവസ്ഥ തെറ്റാണെങ്കിൽ, ലൂപ്പ് അവസാനിക്കുകയും, while പ്രസ്താവനയ്ക്ക് ശേഷമുള്ള ആദ്യ പ്രസ്താവനയിലേക്ക് നിയന്ത്രണം മാറ്റുകയും ചെയ്യും;
വ്യവസ്ഥ ശരിയാണെങ്കിൽ, ലൂപ്പിൻ്റെ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുന്നു, അതിനുശേഷം എല്ലാ പ്രവർത്തനങ്ങളും ആവർത്തിക്കുന്നു.
i > 0 do - സൈക്കിൾ 10 മുതൽ 1 വരെ
t[i] = "ഫീൽഡ്"..i
a = (3, 5, 8, -6, 5)
i > 0 do - അറേയിൽ ഒരു നെഗറ്റീവ് മൂല്യത്തിനായി നോക്കുക
എങ്കിൽ[i]< 0 then break end - если найдено, прерываем цикл
i = i - 1 - അല്ലെങ്കിൽ അടുത്ത ഘടകത്തിലേക്ക് പോകുക
i> 0 ആണെങ്കിൽ
MsgBox("നെഗറ്റീവ് മൂല്യ സൂചിക: "..i)
MsgBox("അറേയിൽ നെഗറ്റീവ് മൂല്യങ്ങൾ അടങ്ങിയിട്ടില്ല")
കുറിപ്പ്
ലുവായിൽ പോസ്റ്റ്കണ്ടീഷൻ (ആവർത്തിച്ച്) ഉള്ള ലൂപ്പ്
റിപ്പീറ്റ് ഓപ്പറേറ്റർ ഒരു പോസ്റ്റ് കണ്ടീഷൻ ഉപയോഗിച്ച് ലൂപ്പുകൾ സംഘടിപ്പിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ് കൂടാതെ ഇനിപ്പറയുന്ന ഫോം ഉണ്ട്:
... - ലൂപ്പ് ബോഡി
വരെ
അവസ്ഥ വരെ ലൂപ്പിൻ്റെ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുന്നു
അറേ a യുടെ മൂല്യങ്ങൾ തുക 10 ൽ കൂടാത്തത് വരെ സംഗ്രഹിക്കുക
a = (3, 2, 5, 7, 9)
തുക = തുക + a[i]
തുക > 10 വരെ
MsgBox(""..i.." ഘടകങ്ങൾ ചേർത്തു. തുക "..sum" ആണ്)
ഒരു ലൂപ്പ് പൂർത്തിയാകുന്നതിന് മുമ്പ് ബ്രേക്ക് സ്റ്റേറ്റ്മെൻ്റ് ഉപയോഗിച്ച് പുറത്തുകടക്കാൻ കഴിയും.
കുറിപ്പ്
"ബ്രേക്ക് ആൻഡ് റിട്ടേൺ ഓപ്പറേറ്റർമാർ" എന്ന ലേഖനത്തിൽ ബ്രേക്ക് ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നതിൻ്റെ സവിശേഷതകളെ കുറിച്ച് കൂടുതൽ വായിക്കുക
ലുവയിലെ പ്രസ്താവനയ്‌ക്കൊപ്പം ലൂപ്പുകൾ
ഫോർ ഓപ്പറേറ്റർ ലൂപ്പുകൾ ഓർഗനൈസുചെയ്യാൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു കൂടാതെ രണ്ട് തരത്തിലുള്ള എഴുത്ത് അനുവദിക്കുന്നു:
ലളിതം (ഇതിനുള്ള സംഖ്യ);
വിപുലീകരിച്ചത് (സാർവത്രികമായി).
ഫോർ സ്റ്റേറ്റ്മെൻ്റിൻ്റെ ലളിതമായ രൂപം
ഫോർ സ്റ്റേറ്റ്മെൻ്റിൻ്റെ ഒരു ലളിതമായ രൂപം ഇതുപോലെ കാണപ്പെടുന്നു:
വേണ്ടി var = exp1, exp2, exp3 do
... - ലൂപ്പ് ബോഡി
exp1 മുതൽ exp2 വരെയുള്ള ഇടവേളയിൽ ലൂപ്പ് വേരിയബിളിൻ്റെ (കൌണ്ടർ) var ൻ്റെ ഓരോ മൂല്യത്തിനും വേണ്ടി ലൂപ്പിൻ്റെ ബോഡി എക്സിക്യൂട്ട് ചെയ്യുന്നു, ഘട്ടം exp3.
കുറിപ്പ്
ഘട്ടം വ്യക്തമാക്കിയേക്കില്ല. ഈ സാഹചര്യത്തിൽ, ഇത് 1 ന് തുല്യമായി എടുക്കുന്നു.
i = 1, 10 do - 1 മുതൽ 10 വരെ ഘട്ടം 1 ഉപയോഗിച്ച് ലൂപ്പ് ചെയ്യുക
MsgBox("i സമം "..i)
for i = 10, 1, -1 do - loop to 10 to 1 with step -1
MsgBox("i സമം "..i)
ദയവായി ശ്രദ്ധിക്കുക
എക്സ്പ്രഷനുകൾ exp1, exp2, exp3 എന്നിവ ലൂപ്പ് ആരംഭിക്കുന്നതിന് മുമ്പ് ഒരിക്കൽ മാത്രം വിലയിരുത്തപ്പെടുന്നു. അതിനാൽ, ചുവടെയുള്ള ഉദാഹരണത്തിൽ, ലൂപ്പിൻ്റെ ഉയർന്ന പരിധി കണക്കാക്കാൻ ഫംഗ്ഷൻ f(x) ഒരു തവണ മാത്രമേ വിളിക്കൂ:
i = 1, f(x) do - 1 മുതൽ f() ഫംഗ്ഷൻ നൽകുന്ന മൂല്യത്തിലേക്ക് ലൂപ്പ് ചെയ്യുക
MsgBox("i സമം "..i)
ഒരു ലൂപ്പ് വേരിയബിൾ ലൂപ്പ് സ്റ്റേറ്റ്മെൻ്റിൻ്റെ ലോക്കൽ ആണ്, അത് ലൂപ്പിൻ്റെ അവസാനം നിർവചിച്ചിട്ടില്ല.
i = 1, 10 do - 1 മുതൽ f() ഫംഗ്ഷൻ നൽകുന്ന മൂല്യത്തിലേക്ക് ലൂപ്പ് ചെയ്യുക
MsgBox("i സമം "..i)
MsgBox("ലൂപ്പിൽ നിന്ന് പുറത്തുകടന്നതിന് ശേഷം, ഞാൻ "..i എന്നതിന് തുല്യമാണ്) - തെറ്റാണ്! ഞാൻ പൂജ്യത്തിന് തുല്യമാണ്
ദയവായി ശ്രദ്ധിക്കുക
ഒരു ലൂപ്പ് വേരിയബിളിൻ്റെ മൂല്യം ഒരു ലൂപ്പിനുള്ളിൽ മാറ്റാൻ കഴിയില്ല; അത്തരം മാറ്റത്തിൻ്റെ അനന്തരഫലങ്ങൾ പ്രവചനാതീതമാണ്.
പൂർത്തിയാകുന്നതിന് മുമ്പ് ഒരു ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കാൻ, ബ്രേക്ക് സ്റ്റേറ്റ്മെൻ്റ് ഉപയോഗിക്കുക.
a = (3, 5, 8, -6, 5)
i = 1,#a do - അറേയിൽ ഒരു നെഗറ്റീവ് മൂല്യത്തിനായി നോക്കുക
എങ്കിൽ[i]< 0 then - если найдено...
സൂചിക = i - കണ്ടെത്തിയ മൂല്യത്തിൻ്റെ സൂചിക സംരക്ഷിക്കുക...
ബ്രേക്ക് - ലൂപ്പിനെ തടസ്സപ്പെടുത്തുക
MsgBox("നെഗറ്റീവ് മൂല്യ സൂചിക: "..ഇൻഡക്സ്)
കുറിപ്പ്
"ബ്രേക്ക് ആൻഡ് റിട്ടേൺ ഓപ്പറേറ്റർമാർ" എന്ന ലേഖനത്തിൽ ബ്രേക്ക് ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നതിൻ്റെ സവിശേഷതകളെ കുറിച്ച് കൂടുതൽ വായിക്കുക)
- വിപുലീകരണം (ഫോർമാറ്റ്) അവസാനത്തെ ഡോട്ടിന് ശേഷം ഫയലിൻ്റെ അവസാനത്തിലുള്ള പ്രതീകങ്ങളാണ്.- കമ്പ്യൂട്ടർ അതിൻ്റെ വിപുലീകരണത്തിലൂടെ ഫയൽ തരം നിർണ്ണയിക്കുന്നു.
- സ്ഥിരസ്ഥിതിയായി, വിൻഡോസ് ഫയൽ നെയിം എക്സ്റ്റൻഷനുകൾ കാണിക്കുന്നില്ല.
- ഫയലിൻ്റെ പേരിലും വിപുലീകരണത്തിലും ചില പ്രതീകങ്ങൾ ഉപയോഗിക്കാൻ കഴിയില്ല.
- എല്ലാ ഫോർമാറ്റുകളും ഒരേ പ്രോഗ്രാമുമായി ബന്ധപ്പെട്ടതല്ല.
- LUA ഫയൽ തുറക്കാൻ ഉപയോഗിക്കാവുന്ന എല്ലാ പ്രോഗ്രാമുകളും ചുവടെയുണ്ട്.
സ്റ്റാൻഡേർഡ് നോട്ട്പാഡ് ഉപയോഗിക്കാൻ വളരെ സൗകര്യപ്രദമല്ലാത്ത പ്രോഗ്രാമാണെന്ന് പല എംഎസ് വിൻഡോസ് ഉപയോക്താക്കളും പണ്ടേ ശ്രദ്ധിച്ചിട്ടുണ്ട്. ധാരാളം പ്രോഗ്രാമിംഗ് ഭാഷകൾക്ക് സിൻ്റാക്സ് പിന്തുണ നൽകുന്ന ഈ സൗജന്യ ടെക്സ്റ്റ് ഫയൽ എഡിറ്ററിന് അത് മാറ്റിസ്ഥാപിക്കാനാകും. പ്രോഗ്രാമിൽ വളരെ വിശാലമായ ഓപ്ഷനുകൾ അടങ്ങിയിരിക്കുന്നു, കൂടാതെ പ്രോസസ്സർ വിഭവങ്ങളുടെ കുറഞ്ഞ ഉപഭോഗം ഇതിൻ്റെ സവിശേഷതയാണ്. അനാവശ്യ വിൻഡോകൾ അടയ്ക്കാതെ ഒരേസമയം നിരവധി പ്രമാണങ്ങൾ കാണാനും അവ എഡിറ്റുചെയ്യാനും പ്രോഗ്രാം സാധ്യമാക്കുന്നു. ഒരു ഓപ്ഷനും ലഭ്യമാണ്: ഒരേ പ്രമാണം വ്യത്യസ്ത സ്ഥലങ്ങളിൽ എഡിറ്റുചെയ്യുന്നു, അത് വളരെ സൗകര്യപ്രദമാണ്...
വാചകം ടൈപ്പ് ചെയ്യാനും എഡിറ്റ് ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ലളിതമായ ആപ്ലിക്കേഷനാണ് Notepad2. കോഡ് ഹൈലൈറ്റ് ചെയ്യാൻ കഴിയുന്നതിനാൽ HTML പേജുകൾ സൃഷ്ടിക്കുന്നതിനും വിവിധ ഭാഷകളിൽ (CSS, Java, JavaScript, Python, SQL, Perl, PHP) പ്രോഗ്രാമിംഗ് നടത്തുന്നതിനും ഇത് സഹായിക്കും. ലളിതമായ നോട്ട്പാഡിൻ്റെ തത്വത്തിലാണ് പ്രോഗ്രാം നിർമ്മിച്ചിരിക്കുന്നത്, ഇത് ഭാരം കുറഞ്ഞതും ഒതുക്കമുള്ളതുമാണ്. ഈ ടെക്സ്റ്റ് എഡിറ്റർ ജോഡികൾക്കായി എല്ലാ പരാൻതീസിസും പരിശോധിക്കുകയും യാന്ത്രിക-ഇൻഡൻ്റേഷനെ പിന്തുണയ്ക്കുകയും ചെയ്യുന്നു. നോട്ട്പാഡ്2 ASCII, UTF-8 എൻകോഡിംഗുകളെ പിന്തുണയ്ക്കുക മാത്രമല്ല, അവയെ പരിവർത്തനം ചെയ്യാനും കഴിയും. ആവശ്യമില്ലാത്ത പ്രവർത്തനങ്ങൾ പല തലങ്ങളിലേക്കും തിരികെ കൊണ്ടുവരാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ടെക്സ്റ്റ് എലമെൻ്റുകളുടെ ബ്ലോക്ക് സെലക്ഷനെ പിന്തുണയ്ക്കുന്നു കൂടാതെ അക്കമിട്ടു...
വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളെ പിന്തുണയ്ക്കുന്ന സൗകര്യപ്രദമായ കോഡ് എഡിറ്ററാണ് കൊമോഡോ എഡിറ്റ്. പ്രോഗ്രാം ഉപയോക്താക്കൾക്ക് ഒരേസമയം നിരവധി ഫയലുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാനുള്ള അവസരം നൽകുന്നു; നിങ്ങൾ വേരിയബിളുകൾ തിരഞ്ഞെടുക്കുമ്പോൾ സ്വയമേവ ഹൈലൈറ്റ് ചെയ്യാൻ ആപ്ലിക്കേഷൻ നിങ്ങളെ അനുവദിക്കുന്നു. എഡിറ്റർ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ഫയലുകൾ കാണാൻ കഴിയും. പ്രോഗ്രാം സിൻ്റാക്സ് കളറിംഗും ഇൻഡൻ്റേഷനും പിന്തുണയ്ക്കുന്നു. സോഴ്സ് കോളം കോഡ് സംഭരിക്കുന്നതിന് ഉപയോഗിക്കുന്ന സിൻ്റാക്സ് പാരാമീറ്ററുകൾ, സ്നിപ്പെറ്റുകൾ എന്നിവ പരിശോധിക്കാൻ കഴിയും. ലളിതമായ എഡിറ്റിംഗ് മോഡ് ഉണ്ട്, ഡ്രാഗ് ആൻഡ് ഡ്രോപ്പ് പിന്തുണയ്ക്കുന്നു...
മറ്റൊരു പ്രോഗ്രാമിൻ്റെ സോഴ്സ് കോഡ്, ഫയൽ മുതലായവ എഡിറ്റ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ധാരാളം പ്രോഗ്രാമുകൾ ഇൻ്റർനെറ്റിൽ ഉണ്ട്. എന്നിരുന്നാലും, ഈ പ്രോഗ്രാമുകളിൽ ഭൂരിഭാഗവും നോട്ട്പാഡ് പോലെയുള്ള ഒരു ടെക്സ്റ്റ് എഡിറ്റർ മാത്രമാണ്. വാക്യഘടന ഹൈലൈറ്റിംഗ് ഉള്ളതുകൊണ്ട് മാത്രമാണ് അവ മുകളിലെ എഡിറ്ററിൽ നിന്ന് വ്യത്യസ്തമാകുന്നത്. എന്നിരുന്നാലും, ചില സാഹചര്യങ്ങളിൽ, ഈ പ്രോഗ്രാമിൻ്റെ പ്രവർത്തനം മതിയാകില്ല. ഒരു പ്രോഗ്രാമർക്ക് ഒരു ഡോക്യുമെൻ്റിൻ്റെ വിവിധ ഭാഗങ്ങൾ വേഗത്തിൽ കണ്ടെത്തേണ്ടി വന്നേക്കാം. ഇപ്പോൾ, ഒടുവിൽ, ഈ പ്രശ്നം പരിഹരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പ്രോഗ്രാം പ്രത്യക്ഷപ്പെട്ടു. പ്രോഗ്രാമിൻ്റെ പേര് SynWrite എന്നാണ്. മരത്തോടുകൂടിയ ഒരു നാവിഗേഷൻ പാനലിൻ്റെ സാന്നിധ്യമാണ് ഇതിൻ്റെ പ്രത്യേകത...
LUA പ്ലഗിൻ - GTA 5-ന് വേണ്ടി സ്ക്രിപ്റ്റ് ഹുക്ക് V-ൽ എഴുതിയിരിക്കുന്ന ചില മോഡുകൾക്ക് ആവശ്യമാണ്.
കാത്തലിക് യൂണിവേഴ്സിറ്റി ഓഫ് റിയോ ഡി ജനീറോയിലെ (ബ്രസീൽ) ടെക്ഗ്രാഫ് (കമ്പ്യൂട്ടർ ഗ്രാഫിക്സ് ടെക്നോളജി ഗ്രൂപ്പ്) ഡിവിഷൻ വികസിപ്പിച്ചെടുത്ത ഒരു സ്ക്രിപ്റ്റിംഗ് പ്രോഗ്രാമിംഗ് ഭാഷയാണ് ലുവാ. ഭാഷാ വ്യാഖ്യാതാവ് സ്വതന്ത്രമായി വിതരണം ചെയ്യപ്പെടുന്നു, സി ഭാഷയിൽ ഓപ്പൺ സോഴ്സ്.
കഴിവുകൾ, പ്രത്യയശാസ്ത്രം, നടപ്പാക്കൽ എന്നിവയുടെ കാര്യത്തിൽ, ഭാഷ ജാവാസ്ക്രിപ്റ്റിന് ഏറ്റവും അടുത്താണ്, എന്നാൽ ലുവയ്ക്ക് കൂടുതൽ ശക്തവും കൂടുതൽ വഴക്കമുള്ളതുമായ ഡിസൈനുകൾ ഉണ്ട്. ലുവയിൽ ക്ലാസിൻ്റെയും ഒബ്ജക്റ്റിൻ്റെയും ആശയം വ്യക്തമായി ഉൾപ്പെടുന്നില്ലെങ്കിലും, മൾട്ടിപ്പിൾ ഹെറിറ്റൻസ് ഉൾപ്പെടെയുള്ള ഒബ്ജക്റ്റ്-ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗിൻ്റെ സംവിധാനങ്ങൾ മെറ്റാറ്റബിളുകൾ ഉപയോഗിച്ച് എളുപ്പത്തിൽ നടപ്പിലാക്കുന്നു, അവ ഓപ്പറേറ്റർ ഓവർലോഡിംഗിനും ഉത്തരവാദിയാണ്. ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗ് മോഡൽ നടപ്പിലാക്കുന്നു. പ്രോട്ടോടൈപ്പിക്കൽ (ജാവാസ്ക്രിപ്റ്റിൽ ഉള്ളത് പോലെ).
സ്ക്രിപ്റ്റ് ഹുക്കിനായുള്ള LUA പ്ലഗിൻ വി
പകർത്താവുന്ന സോഫ്‌റ്റ്‌വെയർ സൃഷ്‌ടിക്കുന്നതിന് ഭാഷ വ്യാപകമായി ഉപയോഗിക്കുന്നു (ഉദാഹരണത്തിന്, അഡോബ് ലൈറ്റ്‌റൂം പാക്കേജിൻ്റെ ഗ്രാഫിക്കൽ ഇൻ്റർഫേസ് അതിൽ എഴുതിയിരിക്കുന്നു). എംബെഡ് ചെയ്യാനുള്ള എളുപ്പവും കോഡ് എക്‌സിക്യൂഷൻ്റെ വേഗതയും പഠനത്തിൻ്റെ എളുപ്പവും കാരണം നിരവധി ഗെയിമുകളിലെ (വേൾഡ് ഓഫ് വാർക്രാഫ്റ്റ് ഉൾപ്പെടെ) ലെവലുകൾക്കും വിപുലീകരണങ്ങൾക്കുമുള്ള ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയായി ഇത് ജനപ്രീതി നേടിയിട്ടുണ്ട്.
എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാം
- നിങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ടോ
- തുടർന്ന് എല്ലാ ഫയലുകളും ആർക്കൈവിൽ നിന്ന് (ഫോൾഡറുകൾ ഉൾപ്പെടെ) GTA 5 റൂട്ട് ഫോൾഡറിലേക്ക് പകർത്തുക.
- തുടർന്ന്, LUA സ്ക്രിപ്റ്റുകൾ "/scripts/addins" ഫോൾഡറിലേക്ക് ലോഡ് ചെയ്യുന്നു
കാത്തലിക് യൂണിവേഴ്സിറ്റി ഓഫ് റിയോ ഡി ജനീറോയുടെ (ബ്രസീലിലെ റിയോ ഡി ജനീറോയിലെ പോണ്ടിഫിക്കൽ കാത്തലിക് യൂണിവേഴ്‌സിറ്റിയുടെ കമ്പ്യൂട്ടർ ഗ്രാഫിക്സ് ടെക്നോളജി ഗ്രൂപ്പ്) ടെക്ഗ്രാഫ് ഡിവിഷൻ വികസിപ്പിച്ച ഒരു വ്യാഖ്യാന പ്രോഗ്രാമിംഗ് ഭാഷയാണ് ലുവാ ഫോർ വിൻഡോസ് (LfW). വികസിപ്പിച്ച വ്യാഖ്യാതാവ് സ്വതന്ത്രമായി വിതരണം ചെയ്യപ്പെടുന്നു, സി ഭാഷയിൽ ഓപ്പൺ സോഴ്സ്.
കഴിവുകൾ, പ്രത്യയശാസ്ത്രം, നടപ്പാക്കൽ എന്നിവയുടെ കാര്യത്തിൽ, ഭാഷ ജാവാസ്ക്രിപ്റ്റിന് ഏറ്റവും അടുത്താണ്, എന്നാൽ ലുവയ്ക്ക് കൂടുതൽ ശക്തവും കൂടുതൽ വഴക്കമുള്ളതുമായ ഡിസൈനുകൾ ഉണ്ട്. ലുവയിൽ ക്ലാസിൻ്റെയും ഒബ്ജക്റ്റിൻ്റെയും ആശയം വ്യക്തമായി ഉൾപ്പെടുന്നില്ലെങ്കിലും, മൾട്ടിപ്പിൾ ഹെറിറ്റൻസ് ഉൾപ്പെടെയുള്ള ഒബ്ജക്റ്റ്-ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗിൻ്റെ സംവിധാനങ്ങൾ മെറ്റാറ്റബിളുകൾ ഉപയോഗിച്ച് എളുപ്പത്തിൽ നടപ്പിലാക്കുന്നു, അവ ഓപ്പറേറ്റർ ഓവർലോഡിംഗിനും ഉത്തരവാദിയാണ്. ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗ് മോഡൽ നടപ്പിലാക്കുന്നു. പ്രോട്ടോടൈപ്പിക്കൽ (ജാവാസ്ക്രിപ്റ്റിലും).
പകർത്താവുന്ന സോഫ്‌റ്റ്‌വെയർ സൃഷ്ടിക്കാൻ ഈ ഭാഷ വ്യാപകമായി ഉപയോഗിക്കുന്നു - പ്രത്യേകിച്ചും, അഡോബ് ഫോട്ടോഷോപ്പ് ലൈറ്റ്‌റൂം പാക്കേജിൻ്റെ ഗ്രാഫിക്കൽ ഇൻ്റർഫേസ് അതിൽ എഴുതിയിരിക്കുന്നു. എംബെഡ് ചെയ്യാനുള്ള എളുപ്പവും കോഡ് എക്‌സിക്യൂഷൻ്റെ വേഗതയും പഠനത്തിൻ്റെ എളുപ്പവും കാരണം നിരവധി ഗെയിമുകളിലെ ലെവലുകൾക്കും വിപുലീകരണങ്ങൾക്കുമുള്ള പ്രോഗ്രാമിംഗ് ഭാഷ എന്ന നിലയിലും ഇത് പ്രശസ്തി നേടിയിട്ടുണ്ട് (ഉദാഹരണത്തിന്, വേൾഡ് ഓഫ് വാർക്രാഫ്റ്റ്).
ലുവായെ സാധാരണയായി ഒരു മൾട്ടി-പാരഡൈം ലാംഗ്വേജ് എന്ന് വിളിക്കുന്നു. ഒരൊറ്റ മാതൃകയിൽ പ്രോഗ്രാമിംഗ് നടപ്പിലാക്കുന്ന സങ്കീർണ്ണവും കർക്കശവുമായ സ്പെസിഫിക്കേഷനുകളേക്കാൾ വ്യത്യസ്തമായ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് വിപുലീകരിക്കാൻ കഴിയുന്ന അടിസ്ഥാന സംവിധാനങ്ങളുടെ ഒരു ചെറിയ സെറ്റ് ഇത് നൽകുന്നു.
അതിനാൽ, ലുവ അനന്തരാവകാശത്തെ വ്യക്തമായി പിന്തുണയ്ക്കുന്നില്ല, പക്ഷേ മെറ്റാറ്റബിളുകൾ ഉപയോഗിച്ച് ഇത് എളുപ്പത്തിൽ നടപ്പിലാക്കുന്നു.
മുഴുവൻ പരമ്പരയും ഒരു വ്യവസ്ഥയും അനുസരിക്കില്ല. പാഠങ്ങൾ തുടർച്ചയായി നിരവധി ഭാഷാ നിർമ്മിതികൾ അവതരിപ്പിക്കും, അതിനാൽ മൂന്നാമത്തെയോ നാലാമത്തെയോ പാഠത്തിൽ നിങ്ങൾക്ക് ഇതിനകം തന്നെ നിങ്ങളുടെ സ്വന്തം പ്രോഗ്രാമുകൾ എഴുതാൻ കഴിയും. ഭാഷ സ്വയം പഠിക്കാൻ നിങ്ങളെ പ്രേരിപ്പിക്കുക, അത് അനുഭവിക്കാൻ സഹായിക്കുക, എ മുതൽ ഇസഡ് വരെ വിശദീകരിക്കരുത് - നിങ്ങൾക്ക് ഭാഷ പൂർണ്ണമായും പഠിക്കണമെങ്കിൽ, റഫറൻസ് ഗൈഡ് വായിക്കുക (അത് മോശമാണെങ്കിലും, റഷ്യൻ ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്തു: http://www.lua .ru/doc/). ഇൻ്റർനെറ്റിലെ "ഫോർ ഡമ്മി" പാഠങ്ങളിൽ നിന്ന് റഫറൻസ് പുസ്തകം പഠിക്കുന്നതിലേക്ക് നിങ്ങൾ എത്രയും വേഗം നീങ്ങുന്നുവോ അത്രയും നല്ലത്.
എന്തെങ്കിലും അവ്യക്തമാണെങ്കിൽ, അഭിപ്രായങ്ങളിൽ ഒരു ചോദ്യം ചോദിക്കുന്നത് ഉറപ്പാക്കുക, ഞാനും മറ്റ് പങ്കാളികളും നിങ്ങളെ സഹായിക്കാൻ ശ്രമിക്കും.
ലുവാ ഒരു ജനപ്രിയവും പഠിക്കാൻ എളുപ്പമുള്ളതും ഉൾച്ചേർത്തതും വ്യാഖ്യാനിച്ചതും ചലനാത്മകമായി ടൈപ്പ് ചെയ്തതുമായ ഒരു പൊതു-ഉദ്ദേശ്യ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. ഇല്ല, മുമ്പത്തെ വാക്യത്തിൽ പറഞ്ഞ പകുതി വാക്കുകൾ നിങ്ങൾ മനസ്സിലാക്കേണ്ടതില്ല - പ്രധാന കാര്യം അത് ജനപ്രിയവും സങ്കീർണ്ണമല്ലാത്തതുമാണെന്ന് അറിയുക എന്നതാണ്. വഴിയിൽ, അതിൻ്റെ ലാളിത്യം, അതുപോലെ തന്നെ വിതരണത്തിൻ്റെ ചെറിയ വലിപ്പം (ഏകദേശം 150 കിലോബൈറ്റുകൾ) കാരണം അതിൻ്റെ പ്രശസ്തി നേടിയിട്ടുണ്ട്. ഗെയിമുകൾ ഉൾപ്പെടെ നിരവധി ആപ്ലിക്കേഷനുകൾ ലുവാ സ്ക്രിപ്റ്റുകൾ പിന്തുണയ്ക്കുന്നു. വേൾഡ് ഓഫ് വാർക്രാഫ്റ്റും എസ്.ടി.എ.എൽ.കെ.ഇ.ആർ. ലുവാ ഭാഷ ഉപയോഗിക്കുക. ലുവാ ഉപയോഗിച്ച് വൈവിധ്യമാർന്ന ഗെയിമുകൾ എളുപ്പത്തിൽ സൃഷ്ടിക്കാൻ എൻ്റെ പ്രിയപ്പെട്ട ഗെയിം എഞ്ചിൻ നിങ്ങളെ അനുവദിക്കും. നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ലുവാ നിങ്ങൾക്കായി ധാരാളം ചക്രവാളങ്ങൾ തുറക്കുന്നു!
ഞങ്ങൾ ആരംഭിക്കുന്നതിന് മുമ്പ്, നിങ്ങൾ ഒരു പ്രോഗ്രാമിംഗ് പരിതസ്ഥിതി സജ്ജീകരിക്കണം: അതായത്, നിങ്ങൾ എഴുതുന്ന Lua കോഡ് സ്വീകരിച്ച് അത് നടപ്പിലാക്കുന്ന ഒരു പ്രോഗ്രാം കണ്ടെത്തുക: ഒരു വ്യാഖ്യാതാവ്. മൂന്ന് ഓപ്ഷനുകൾ ഉണ്ട്:
1. ഔദ്യോഗിക ലുവാ വിതരണം അവ വിതരണം ചെയ്യുന്ന സൈറ്റുകളിലൊന്നിൽ നിന്ന് ഡൗൺലോഡ് ചെയ്യുക.
ഔദ്യോഗിക ലുവാ വെബ്‌സൈറ്റിൽ നിന്ന് നിങ്ങൾക്ക് ഇൻ്റർപ്രെറ്റർ സോഴ്സ് കോഡുകൾ മാത്രമേ ഡൗൺലോഡ് ചെയ്യാനാകൂ. എന്നിരുന്നാലും, നിങ്ങൾ ബൈനറീസ് വിഭാഗത്തിൽ http://lua.org/download.html നോക്കുകയാണെങ്കിൽ, Windows-നായി എക്സിക്യൂട്ടബിൾ ഫയലുകളുള്ള സൈറ്റുകളിലേക്കുള്ള ലിങ്കുകൾ നിങ്ങൾക്ക് കണ്ടെത്താം. അവയിലൊന്ന്: . അവിടെ നിന്ന് ആർക്കൈവുകളിൽ ഒന്ന് ഡൗൺലോഡ് ചെയ്യുക (നിങ്ങളുടെ പ്ലാറ്റ്‌ഫോമുമായി പൊരുത്തപ്പെടുന്നു: Win32 അല്ലെങ്കിൽ Win64) അത് എവിടെയെങ്കിലും അൺപാക്ക് ചെയ്യുക, വെയിലത്ത് ഒരു ഹ്രസ്വ പാതയുള്ള ഒരു ഡയറക്ടറിയിലേക്ക്: C:\lua പോലെ. ഇനി മുതൽ നിങ്ങൾ വിൻഡോസ് ഉപയോഗിക്കുന്നുണ്ടെന്നും നിങ്ങളുടെ വ്യാഖ്യാതാവ് അവിടെയുണ്ടെന്നും ഞാൻ അനുമാനിക്കും.
ഈ അർത്ഥത്തിൽ, ലിനക്സ് അധിഷ്ഠിത ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ ഉപയോക്താക്കൾക്ക് ഇത് എളുപ്പമാണ്: അവർ ഒരു പാക്കേജ് മാനേജർ ഉപയോഗിക്കുകയും റിപ്പോസിറ്ററികളിൽ നിന്ന് Lua ഇൻസ്റ്റാൾ ചെയ്യുകയും വേണം. Debian, Ubuntu എന്നിവയിൽ apt-get install lua എന്ന കമാൻഡ് ഉപയോഗിച്ചും Fedora, Red Hat, ഡെറിവേറ്റീവ് ഡിസ്ട്രിബ്യൂഷനുകളിൽ - yum install lua എന്നിവയിലുമാണ് ഇത് ചെയ്യുന്നത്. എന്നിരുന്നാലും, എന്നെ അന്ധമായി വിശ്വസിക്കരുത്, ഇത് നിങ്ങൾക്കായി എങ്ങനെ ചെയ്യുന്നുവെന്ന് കണ്ടെത്താൻ നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ മാനുവൽ പരിശോധിക്കുക.
2. ഒരു ഓൺലൈൻ ഇൻ്റർപ്രെറ്റർ ഉപയോഗിക്കുക.
http://www.lua.org/demo.html എന്നതിൽ കണ്ടെത്തി. ആദ്യം ഇത് മതിയാകും, എന്നാൽ പിന്നീട്, ഞങ്ങൾ മൊഡ്യൂളുകളിൽ സ്പർശിക്കുമ്പോൾ, ഓഫ്‌ലൈൻ പതിപ്പ് ഉപയോഗിക്കാൻ നിങ്ങൾ നിർബന്ധിതരാകും. ഓൺലൈൻ ഇൻ്റർപ്രെറ്റർ ഉപയോഗിക്കുന്നത് വളരെ ലളിതമാണ്: ടെക്സ്റ്റ് ബോക്സിൽ നിങ്ങളുടെ പ്രോഗ്രാം നൽകി റൺ ബട്ടൺ ക്ലിക്ക് ചെയ്യുക. പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യും, ഔട്ട്പുട്ട് വിൻഡോ നിങ്ങളുടെ പ്രോഗ്രാമിൻ്റെ ഔട്ട്പുട്ടും അതുപോലെ തന്നെ നിങ്ങൾ ഉണ്ടാക്കിയ പിശക് റിപ്പോർട്ടുകളും പ്രദർശിപ്പിക്കും.
3. ഒരു IDE ഉപയോഗിക്കുക.
ഉദാഹരണത്തിന് ZeroBrane സ്റ്റുഡിയോ: http://studio.zerobrane.com/. മറ്റുള്ളവയുണ്ട് - ഇൻ്റർനെറ്റിൽ നോക്കുക.
ലുവയുടെ രണ്ട് വ്യത്യസ്ത പതിപ്പുകൾ നിലവിൽ ഉപയോഗത്തിലുണ്ട്: 5.1, 5.2. ഞാൻ ഏറ്റവും പുതിയ പതിപ്പിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും - പതിപ്പ് 5.2, എന്നാൽ ഇത് 5.1 ഉം തമ്മിലുള്ള പ്രധാന വ്യത്യാസങ്ങൾ ചൂണ്ടിക്കാണിക്കാൻ എനിക്ക് ഉറപ്പുണ്ട്, കാരണം രണ്ടാമത്തേതും വളരെ സാധാരണമാണ്. വഴിയിൽ, Lua 5.1, Lua 5.2 നേക്കാൾ ഒന്നര മടങ്ങ് വേഗത്തിൽ കോഡ് നിർവ്വഹിക്കുന്നു, നിങ്ങൾക്കറിയാം.
=== പാഠം നമ്പർ 1 ===
അതിനാൽ നമുക്ക് ആരംഭിക്കാം. അധിക ഫയലുകളിൽ നിന്ന് വേർതിരിച്ച ഒരു ഫോൾഡറിൽ ഒരു main.lua ഫയൽ സൃഷ്ടിച്ച് അതിൽ എഴുതുക:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- main.lua --
പ്രിൻ്റ് ("ഹലോ വേൾഡ്!")
തുടർന്ന് അത് കമാൻഡ് ലൈനിൽ പ്രവർത്തിപ്പിക്കുക (cd കമാൻഡ് ഉപയോഗിച്ച് main.lua ഉള്ള ഡയറക്ടറിയിലേക്ക് നീങ്ങാൻ മറക്കരുത്):
200?"200px":""+(this.scrollHeight+5)+"px");">
> സി:\lua\lua.exe main.lua
ലുവാ വ്യാഖ്യാതാവ് ഇപ്രകാരം പ്രതികരിക്കും:
200?"200px":""+(this.scrollHeight+5)+"px");">
ഹലോ വേൾഡ്!
തത്വത്തിൽ, ഇത് പ്രതീക്ഷിക്കേണ്ടതായിരുന്നു. പ്രോഗ്രാമിൽ ഞങ്ങൾ പ്രിൻ്റ് ഫംഗ്ഷൻ എന്ന് വിളിച്ചു. പ്രിൻ്റ് ഫംഗ്ഷൻ പാരാമീറ്ററുകളുടെ അനിയന്ത്രിതമായ എണ്ണം എടുക്കുകയും അവ സ്ക്രീനിൽ തുടർച്ചയായി പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ അതിനെ "ഹലോ വേൾഡ്!" എന്ന സ്ട്രിംഗ് (കഥാപാത്രങ്ങളുടെ ശൃംഖല) കൈമാറി. നിങ്ങൾക്ക് ഇത് ഒരു പാരാമീറ്റർ പോലെ എളുപ്പത്തിൽ കൈമാറാൻ കഴിയും:
200?"200px":""+(this.scrollHeight+5)+"px");">
പ്രിൻ്റ് (8) -- ചില ദശാംശ സംഖ്യകൾ
-- ഔട്ട്പുട്ട് ചെയ്യും: 8
പ്രിൻ്റ്(0xDEADBEEF) -- ഹെക്സാഡെസിമൽ നമ്പർ
-- ഔട്ട്പുട്ട് ചെയ്യും: 3735928559
പ്രിൻ്റ് ("0xDEADBEEF") - എന്നാൽ ഇതൊരു സ്ട്രിംഗ് ആണ്, ഒരു സംഖ്യയല്ല! നിങ്ങൾ ഉദ്ധരണികൾ കാണുന്നുണ്ടോ?
-- ഔട്ട്പുട്ട് ചെയ്യും: 0xDEADBEEF
പ്രിൻ്റ്(1.35e-4) -- ഫ്ലോട്ടിംഗ് പോയിൻ്റ് നമ്പർ (ഫ്രാക്ഷണൽ നമ്പർ)
-- 0.000135 ഔട്ട്പുട്ട് ചെയ്യും. 1.35e-4 എന്നത് "1.35 തവണയായി മനസ്സിലാക്കണം
- പത്തിൽ നിന്ന് മൈനസ് നാലാമത്തെ ശക്തിയിലേക്ക്,” ആർക്കെങ്കിലും അറിയില്ലെങ്കിൽ.
പ്രിൻ്റ്((198*99)-3*500 + 14/88) -- എക്സ്പ്രഷൻ
-- പദപ്രയോഗത്തിൻ്റെ മൂല്യം പ്രിൻ്റ് ചെയ്യുന്നു: 18102.159090909. ഒരു മോശം ബദലല്ല
-- ഡെസ്ക്ടോപ്പ് കാൽക്കുലേറ്റർ!
പ്രിൻ്റ്(198/7, "വളം", 2^9) -- നിരവധി അനിയന്ത്രിതമായ പാരാമീറ്ററുകൾ
-- ഒരുതരം. അവയിൽ ഓരോന്നിൻ്റെയും മൂല്യങ്ങൾ അടയാളങ്ങളാൽ വേർതിരിച്ച് പ്രദർശിപ്പിക്കും
-- ടാബുകൾ:
-- 28.285714285714 വളം 512
-- വളത്തിന് ചുറ്റുമുള്ള ഉദ്ധരണികൾ പ്രദർശിപ്പിച്ചിട്ടില്ലെന്ന് ദയവായി ശ്രദ്ധിക്കുക!
പ്രിൻ്റ്(1.35) -- രണ്ട് സംഖ്യകൾ, ദശാംശ ഭിന്നസംഖ്യ 1.35 അല്ല!
-- പരാമീറ്ററുകൾ വേർതിരിക്കാൻ കോമ ഉപയോഗിക്കുന്നു.
-- ഔട്ട്പുട്ട് ചെയ്യും:
-- 1 35
"--" ചിഹ്നം കേവലം ഭംഗിക്കായി തിരുകിയിരിക്കുന്ന ഡാഷ് ചിഹ്നത്തിൻ്റെ അനുകരണമല്ല. ലുവയിലെ "--" അടയാളം അഭിപ്രായങ്ങളെ അടയാളപ്പെടുത്തുന്നു: വ്യാഖ്യാതാവ് അവഗണിക്കുന്ന പ്രോഗ്രാമർക്കുള്ള സൂചനകൾ, കൂടാതെ കോഡ് എളുപ്പം മനസ്സിലാക്കാൻ ഉദ്ദേശിച്ചുള്ളതുമാണ്. നിങ്ങൾക്ക് പ്രോഗ്രാമിൽ എഴുതാൻ ശ്രമിക്കാം:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- പ്രിൻ്റ് ("ഒന്നുമില്ല")
ഇതൊരു കമൻ്റാണെന്നും നിർദ്ദേശം നടപ്പിലാക്കില്ലെന്നും വ്യാഖ്യാതാവ് കരുതുന്നു.
ഹോസ്റ്റസ് ശ്രദ്ധിക്കുക: നിങ്ങൾക്ക് ഒരു വരി മാത്രം പ്രിൻ്റ് ചെയ്യണമെങ്കിൽ, പരാൻതീസിസുകളില്ലാതെ നിങ്ങൾക്ക് ഇതുപോലെ പ്രിൻ്റ് കോൾ എഴുതാം:
200?"200px":""+(this.scrollHeight+5)+"px");">
"ഒരു സ്ട്രിംഗ്" എന്ന് അച്ചടിക്കുക
സൗകര്യം തീർച്ചയായും സംശയാസ്പദമാണ്: ഇത് സാധ്യമാണെന്ന് ഓർമ്മിക്കുക. എന്നിരുന്നാലും, അത്തരം കോളുകൾ അസ്വീകാര്യമാണ്:
200?"200px":""+(this.scrollHeight+5)+"px");">
പ്രിൻ്റ് 2 പ്രവർത്തിക്കില്ല, 2 ഒരു സ്ട്രിംഗ് അല്ല.
പ്രിൻ്റ് 2*2 + 6 -- എന്തായാലും ഇത് പ്രവർത്തിക്കില്ല
Str = "സ്ട്രിംഗ്!!" -- വേരിയബിളിന് "സ്ട്രിംഗ്!!" മൂല്യം നൽകി
-- വേരിയബിളുകളെക്കുറിച്ച് താഴെ വായിക്കുക
പ്രിൻ്റ് str -- ഒന്നുകിൽ പ്രവർത്തിക്കില്ല.
മുകളിലുള്ള ഓരോ സാഹചര്യത്തിലും, പ്രോഗ്രാം പ്രവർത്തിക്കാൻ വിസമ്മതിക്കും. അതിനാൽ, "ബ്രാക്കറ്റ്‌ലെസ്സ്" കോളിൽ, ഫംഗ്ഷൻ നാമത്തെ അക്ഷരാർത്ഥത്തിൽ ഒരു സ്ട്രിംഗ് മാത്രമേ പിന്തുടരാൻ കഴിയൂ (അതായത്, ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രതീകങ്ങളുടെ ഒരു ശ്രേണി), മറ്റൊന്നുമല്ല. ഭാവിയിൽ ഞാൻ ഈ സവിശേഷതയെക്കുറിച്ച് കുറച്ചുകൂടി വിശദമായി സംസാരിക്കും, എന്നാൽ ഇപ്പോൾ, അത് മതി.
ഏത് നല്ല പ്രോഗ്രാമിംഗ് ഭാഷയും വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു: കുറച്ച് ഡാറ്റ സൂക്ഷിക്കാൻ കഴിയുന്ന ചെറിയ കണ്ടെയ്‌നറുകൾ. ലുവായിൽ ഇത് ഇതുപോലെയാണ് ചെയ്യുന്നത്:
200?"200px":""+(this.scrollHeight+5)+"px");">
<имя_переменной> = <выражение>
ഉദാഹരണത്തിന്:
200?"200px":""+(this.scrollHeight+5)+"px");">
നക്ഷത്രം = 8 -- ഇപ്പോൾ സ്റ്റാർ വേരിയബിൾ 8 എന്ന സംഖ്യ സംഭരിക്കുന്നു
യുദ്ധങ്ങൾ = "മൂങ്ങ" -- യുദ്ധ വേരിയബിളിൽ - സ്ട്രിംഗ് "മൂങ്ങ"
jedi = 42/2 -- വേരിയബിളിൽ jedi - നമ്പർ 21
luke = star*jedi -- ലൂക്ക് വേരിയബിളിൽ - സംഖ്യ 168 (അതെ, 21 തവണ 8)
വേരിയബിളുകളുടെയും അവയ്‌ക്കൊപ്പമുള്ള പദപ്രയോഗങ്ങളുടെയും മൂല്യങ്ങളും പ്രദർശിപ്പിക്കാൻ കഴിയും:
200?"200px":""+(this.scrollHeight+5)+"px");">
പ്രിൻ്റ് (നക്ഷത്രം, യുദ്ധങ്ങൾ, ജെഡി, ജെഡി-സ്റ്റാർ+ലൂക്ക്)
-- ഔട്ട്പുട്ട് ചെയ്യും:
-- 8 മൂങ്ങ 21 181
വേരിയബിളുകൾ നക്ഷത്രവും യുദ്ധങ്ങളും ചേർക്കാൻ ശ്രമിക്കരുത് - "മൂങ്ങ" എന്നതിലേക്ക് 8 ചേർക്കാൻ ശ്രമിക്കുന്നത് നിങ്ങൾക്ക് ഒരു ഗുണവും ചെയ്യില്ല!
നിങ്ങൾ ശ്രദ്ധിച്ചതുപോലെ, ഒരു വേരിയബിളിൻ്റെ പേര് ഏതാണ്ട് എന്തും ആകാം: പ്രധാന കാര്യം അത് ഒരു സംഖ്യയിൽ ആരംഭിക്കുന്നില്ല എന്നതാണ്. ഗൗരവമായി, നിങ്ങൾക്ക് പ്രിൻ്റ് എന്ന് വിളിക്കുന്ന ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാൻ പോലും കഴിയും, തുടർന്ന് പ്രിൻ്റ് ഫംഗ്ഷൻ പ്രവർത്തിക്കുന്നത് നിർത്തും, കാരണം നെയിം പ്രിൻ്റ് പുതുതായി പ്രഖ്യാപിച്ച വേരിയബിളിനെ സൂചിപ്പിക്കും. എന്നാൽ വേരിയബിൾ പേരുകളായി ഉപയോഗിക്കുന്നതിൽ നിന്ന് വിലക്കപ്പെട്ട ഒരു കൂട്ടം പദങ്ങളുണ്ട് - ഇവ നമുക്ക് ഇതുവരെ പരിചയപ്പെട്ടിട്ടില്ലാത്ത ഭാഷാ കീവേഡുകളാണ്, എന്നാൽ അവ തീർച്ചയായും നോക്കേണ്ടതാണ്:
200?"200px":""+(this.scrollHeight+5)+"px");">
പിന്നെ ബ്രേക്ക് ഡു അല്ലാതെ വേറെ എൻഡ്
ഇൻ ചെയ്താൽ ഫംഗ്ഷൻ ഗോട്ടോയ്‌ക്ക് തെറ്റ്
ലോക്കൽ nil അല്ല അല്ലെങ്കിൽ ആവർത്തിക്കുക
പിന്നീട് അത് വരെ സത്യമാണ്
ഈ പേരുകളിലൊന്ന് ഉപയോഗിച്ച് ഒരു വേരിയബിൾ സൃഷ്ടിക്കുന്നതിലൂടെ, നിങ്ങൾ പ്രോഗ്രാമിൽ ഒരു പിശക് ഉണ്ടാക്കും, അത് തീർച്ചയായും പ്രവർത്തിക്കില്ല. ദയവായി ശ്രദ്ധിക്കുക: Lua 5.1-ൽ Goto കീവേഡ് ഇല്ല, നിങ്ങൾക്ക് ഒരു വേരിയബിളിനെ ആ രീതിയിൽ വിളിക്കാം, എന്നാൽ നിങ്ങൾ അത് ചെയ്യാതിരിക്കുന്നതാണ് നല്ലത്.
വേരിയബിൾ പേരുകൾ കേസ് സെൻസിറ്റീവ് ആണെന്നതും ശ്രദ്ധിക്കുക. ഇതിനർത്ഥം foo, fOo, fOO, FOO എന്നിവ നാല് വ്യത്യസ്ത വേരിയബിളുകളാണ്, അതിനാൽ നിങ്ങൾ ഒരു വേരിയബിളിൻ്റെ പേര് ചെറിയക്ഷരത്തിൽ എഴുതുകയും പിന്നീട് വലിയക്ഷരത്തിൽ എഴുതുകയും ചെയ്താൽ, പ്രോഗ്രാം മിക്കവാറും ശരിയായി പ്രവർത്തിക്കില്ല.
ഇപ്പോൾ ഒരു പ്രധാന കാര്യം: നിങ്ങൾ ആകസ്‌മികമായോ മനഃപൂർവമോ നിലവിലില്ലാത്ത ഒരു വേരിയബിളിനെ പരാമർശിച്ചാൽ എന്ത് സംഭവിക്കും? മറ്റ് മിക്ക ഭാഷകളിലും ഇത് ഒരു പിശകിന് കാരണമാകും, എന്നാൽ ലുവായിൽ ഈ സാഹചര്യം സ്വീകാര്യമാണ്. നിലവിലില്ലാത്ത വേരിയബിൾ യഥാർത്ഥത്തിൽ നിലനിൽക്കുന്നതുപോലെയാണ് ഇതിനെ കണക്കാക്കുന്നത്, എന്നാൽ അതിൻ്റെ മൂല്യം ഇല്ല. ഇല്ല- ഈ വാക്ക് ഓർക്കുക! "ഒന്നുമില്ല" എന്നർത്ഥമുള്ള ലുവയിലെ ഒരു പ്രത്യേക മൂല്യമാണ്. പൂജ്യമല്ല, ഒരു ശൂന്യമായ സ്ട്രിംഗും അല്ല ("" പോലെയുള്ള ഒരു സ്ട്രിംഗ് - ഇത് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കാൻ ശ്രമിക്കുക), പക്ഷേ ഒന്നുമില്ല. ഈ മോഡലുമായി ഇത് താരതമ്യം ചെയ്യുക: രണ്ട് ആളുകളുണ്ട്, അവരിൽ ഒരാൾക്ക് ബാങ്ക് അക്കൗണ്ട് ഉണ്ട്, പക്ഷേ അതിൽ പണമില്ല, മറ്റേയാൾക്ക് ബാങ്ക് അക്കൗണ്ട് ഇല്ല. ലുവാ പദങ്ങളിൽ, ആദ്യത്തെയാളുടെ അക്കൗണ്ടിൽ $0 ഉണ്ടെന്നും രണ്ടാമത്തേതിൻ്റെ അക്കൗണ്ടിൽ $0 ഉണ്ടെന്നും കണക്കാക്കും. ഇല്ല. ഡോളർ പോലുമല്ല, ലളിതമായി ഇല്ല. ഞാൻ നിങ്ങളെ ആശയക്കുഴപ്പത്തിലാക്കിയില്ലെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.
ഉദാഹരണത്തിന്, ഈ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കുക:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- main.lua --
foo = "ബാർ"
പ്രിൻ്റ് (ഫൂ, ബാസ്)
-- ഔട്ട്പുട്ട് ചെയ്യും:
--ബാർ ഇല്ല
അങ്ങനെ, വേരിയബിൾ baz, നിലവിലില്ല, എന്നാൽ നിലവിലുണ്ടെന്ന് കരുതപ്പെടുന്നു, മൂല്യം nil ആണ്, പ്രിൻ്റ് ഫംഗ്ഷൻ ഇത് മനസ്സിലാക്കുകയും സ്ക്രീനിൽ "nil" എന്ന സ്ട്രിംഗ് ആയി പ്രിൻ്റ് ചെയ്യുകയും ചെയ്യുന്നു. ഒരു വേരിയബിളിൻ്റെ അസ്തിത്വം പരിശോധിക്കുന്നതിന് ലുവയ്ക്ക് ഒരു നല്ല രീതിയുണ്ട്: വേരിയബിളിൻ്റെ മൂല്യം പൂജ്യമല്ലെങ്കിൽ, അത് കുറഞ്ഞത് പ്രഖ്യാപിക്കും. മറുവശത്ത്, നിങ്ങൾക്ക് nil-ന് തുല്യമായ ഒരു വേരിയബിൾ വ്യക്തമായി പ്രഖ്യാപിക്കാൻ കഴിയും:
200?"200px":""+(this.scrollHeight+5)+"px");">
cool_var = ഇല്ല
ഇത് ചെയ്യാൻ കഴിയും, ഒറ്റനോട്ടത്തിൽ ഇത് മണ്ടത്തരമാണെന്ന് തോന്നുമെങ്കിലും, ചിലപ്പോൾ ഇത് ചെയ്യാറുണ്ട്. തുടർന്നുള്ള പാഠങ്ങളിൽ ആരാണ്, എന്തിന് എന്ന് നിങ്ങൾ പഠിക്കും, നിങ്ങൾ ഒരുപക്ഷേ അത് ചെയ്യാൻ തുടങ്ങും. ചിലപ്പോൾ, തീർച്ചയായും.
nil ഉപയോഗിച്ച് ശ്രദ്ധാലുവായിരിക്കുക: നിങ്ങൾക്ക് nil എന്ന് അച്ചടിക്കാൻ കഴിയും, എന്നാൽ നിങ്ങൾക്ക് അത് ഉപയോഗിച്ച് ഗണിത പ്രവർത്തനങ്ങൾ നടത്താൻ കഴിയില്ല, അതായത്, നിങ്ങൾക്ക് പ്രിൻ്റ് (nil) ഉപയോഗിച്ച് രക്ഷപ്പെടാൻ കഴിയുമെങ്കിൽ, 99+nil പോലുള്ള ഒരു നിർമ്മാണം ഒരു പിശകിന് കാരണമാകും. പോലെ 99+ nil ആയിരുന്നു 99. എന്നെ വിശ്വസിക്കൂ, അറിഞ്ഞപ്പോൾ ഞാനും അസ്വസ്ഥനായിരുന്നു.
പുനരാരംഭിക്കുക:
1. പ്രിൻ്റ് ഫംഗ്‌ഷനെക്കുറിച്ചും അതിന് എന്തുചെയ്യാൻ കഴിയുമെന്നും പരാൻതീസിസില്ലാതെ എങ്ങനെ ശരിയായി വിളിക്കാമെന്നും ഞങ്ങൾ പഠിച്ചു.
2. വേരിയബിളുകൾ എങ്ങനെ പ്രഖ്യാപിക്കാം, എക്സ്പ്രഷനുകൾ എങ്ങനെ വിലയിരുത്താം (കുറച്ച് ആണെങ്കിലും), വേരിയബിളുകൾക്ക് എന്ത് പേരുകൾ ഉണ്ടാകും എന്ന് ഞങ്ങൾ പഠിച്ചു.
3. ഞങ്ങൾ nil-നെക്കുറിച്ച് പഠിച്ചു, അതിൻ്റെ നിഗൂഢമായ നിഗൂഢതയിൽ മുഴുകി, ഭാവിയിൽ ഞങ്ങൾക്ക് ഇതുമായി ഒരുപാട് കാര്യങ്ങൾ ചെയ്യാനുണ്ടാകുമെന്ന് ആത്മവിശ്വാസം നേടി.
അന്വേഷണാത്മകവും അവരുടെ അറിവ് ശക്തിപ്പെടുത്താൻ ആഗ്രഹിക്കുന്നവർക്കും, ഞാൻ ലളിതമായ വ്യായാമങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു,നിങ്ങൾക്ക് ഇതിനകം വേണ്ടത്ര കഴിവുണ്ടെന്ന് തോന്നുന്നുവെങ്കിൽ നിങ്ങൾ ചെയ്യേണ്ടതില്ല:
1. നിങ്ങളുടെ പ്രിയപ്പെട്ട പാട്ടിൻ്റെ കോറസ് പ്രിൻ്റ് ചെയ്യുന്ന ഒരു പ്രോഗ്രാം എഴുതുക.
2. ഇനിപ്പറയുന്ന എക്സ്പ്രഷനുകളുടെ മൂല്യങ്ങൾ നേടുന്നതിന് ശ്രമിക്കുക. അവയിൽ ചിലത് പ്രവർത്തിക്കുന്നതും ചിലത് പ്രവർത്തിക്കാത്തതും എന്തുകൊണ്ടാണെന്ന് മനസിലാക്കാൻ ശ്രമിക്കുക. പ്രവർത്തിക്കാത്ത എക്സ്പ്രഷനുകൾ ഏതൊക്കെ പിശകുകളാണ് ഉണ്ടാക്കുന്നതെന്ന് കാണുക.
200?"200px":""+(this.scrollHeight+5)+"px");">
2 + "സ്ട്രിംഗ്";
6 + "14";
"ബോക്സ്" - "വോക്സ്";
1 * "11 ബി"
"148" * "1e6";
3. രണ്ട് വേരിയബിളുകൾക്കിടയിൽ മൂല്യങ്ങൾ കൈമാറുന്ന ഒരു പ്രോഗ്രാം എഴുതുക. അതായത്:
200?"200px":""+(this.scrollHeight+5)+"px");">
a = 6502
b = 8086
8086 ന് തുല്യവും b 6502 നും തുല്യമാക്കുക. ഇത് ചെയ്യുന്നതിന്, ഒരു മൂന്നാം വേരിയബിൾ സൃഷ്ടിച്ച് കുറച്ച് ലളിതമായ പുനഃക്രമീകരണങ്ങൾ നടത്തുക. എക്‌സ്‌ചേഞ്ചിന് മുമ്പായി പ്രിൻ്റ്(a,b) എന്നും ശേഷം പ്രിൻ്റ്(a,b) എന്നും വിളിച്ച് പ്രശ്നം ശരിയായി പരിഹരിച്ചെന്ന് ഉറപ്പാക്കുക.
