Lua ट्यूटोरियल
शुरुआत हुई लुआ से

टिप्पणियों

संस्करण

स्थापना

बाइनरी

Lua बायनेरिज़ अधिकांश GNU / Linux वितरणों द्वारा पैकेज के रूप में प्रदान किए जाते हैं।

उदाहरण के लिए, डेबियन, उबंटू और उनके डेरिवेटिव पर इसे निष्पादित करके प्राप्त किया जा सकता है:

sudo apt-get install lua50

sudo apt-get install lua51

sudo apt-get install lua52

विंडोज, मैकओएस और सोर्सफॉर्ग में होस्ट किए गए कुछ अन्य ऑपरेटिंग सिस्टम के लिए कुछ अर्ध-आधिकारिक बिल्ड दिए गए हैं।

Apple उपयोगकर्ता भी Homebrew का उपयोग करके आसानी से Lua स्थापित कर सकते हैं:

brew install lua

(वर्तमान में Homebrew में 5.2.4 है, 5.3 के लिए Homebrew / संस्करण देखें।)

स्रोत

स्रोत आधिकारिक पृष्ठ पर उपलब्ध है। स्रोतों का अधिग्रहण और निर्माण स्वयं तुच्छ होना चाहिए। लिनक्स सिस्टम पर निम्नलिखित पर्याप्त होना चाहिए:

$ wget http://lua.org/ftp/lua-5.3.3.tar.gz
$ echo "a0341bc3d1415b814cc738b2ec01ae56045d64ef ./lua-5.3.3.tar.gz" | sha1sum -c -
$ tar -xvf ./lua-5.3.3.tar.gz
$ make -C ./lua-5.3.3/ linux

ऊपर दिए गए उदाहरण में, हम मूल रूप से आधिकारिक साइट से एक स्रोत tarball डाउनलोड कर रहे हैं, इसके चेकसम की पुष्टि कर रहे हैं, और निकालने और निष्पादित make । ( आधिकारिक पेज पर चेकसम को दोहराएं।)

नोट: आपको निर्दिष्ट करना होगा कि आपको कौन सा लक्ष्य बनाना है। उदाहरण में, हमने linux निर्दिष्ट किया। अन्य उपलब्ध बनाने के लक्ष्य शामिल solaris , aix , bsd , freebsd , macosx , mingw , आदि की जाँच करें doc/readme.html है, जो स्रोत, अधिक जानकारी के लिए में शामिल है। (आप README के नवीनतम संस्करण को ऑनलाइन भी पा सकते हैं।)

मॉड्यूल

मानक लाइब्रेरी आदिम तक सीमित हैं:

• coroutine - कोरोटीन प्रबंधन कार्यक्षमता
• debug - डिबग हुक और उपकरण
• io - मूल IO आदिम
• package - मॉड्यूल प्रबंधन कार्यक्षमता
• string - स्ट्रिंग और लुआ विशिष्ट पैटर्न मिलान कार्यक्षमता
• table - आवश्यक लेकिन जटिल Lua प्रकार - तालिकाओं से निपटने के लिए आदिम
• os - मूल ओएस ऑपरेशन
• utf8 - मूल UTF-8 आदिम (लुआ 5.3 के बाद से)

उन सभी पुस्तकालयों को एक विशिष्ट निर्माण के लिए अक्षम किया जा सकता है या रन-टाइम पर लोड किया जा सकता है।

मॉड्यूल बांटने के लिए थर्ड-पार्टी लुआ लाइब्रेरी और बुनियादी ढांचा विरल है, लेकिन सुधार। LuaRocks , Lua Toolbox , और LuaDist जैसी परियोजनाएं स्थिति में सुधार कर रही हैं। पुराने लुका विकी पर बहुत सी जानकारी और कई सुझाव मिल सकते हैं, लेकिन ध्यान रखें कि इस जानकारी में से कुछ काफी पुरानी और पुरानी हैं।

टिप्पणियाँ

लुआ में एकल-पंक्ति टिप्पणियाँ शुरू होती हैं -- और पंक्ति के अंत तक जारी रहती हैं:

-- this is single line comment
-- need another line
-- huh?

ब्लॉक टिप्पणी के साथ शुरू --[[ और के साथ अंत ]] :

--[[
    This is block comment.
    So, it can go on...
    and on...
    and on....
]]

ब्लॉक टिप्पणियां लंबी स्ट्रिंग के रूप में सीमांकक की एक ही शैली का उपयोग करती हैं; सम्‍मिलित चिह्नों को सम्‍मिलित करने के लिए कोष्ठकों के बीच किसी भी समान संकेत जोड़े जा सकते हैं:

--[=[
    This is also a block comment
    We can include "]]" inside this comment
--]=]

--[==[
    This is also a block comment
    We can include "]=]" inside this comment
--]==]

कोड के विखंडन के बारे में टिप्पणी करने के लिए एक साफ चाल है --[[ और --]] साथ इसे --]] :

--[[
    print'Lua is lovely'
--]]

हिस्सा फिर से सक्रिय करने के लिए, बस एक संलग्न - टिप्पणी आरंभिक दृश्य करने के लिए:

---[[
    print'Lua is lovely'
--]]

इस तरह, अनुक्रम -- पहली पंक्ति में अंतिम पंक्ति की तरह एकल-पंक्ति टिप्पणी शुरू होती है, और print स्टेटमेंट पर टिप्पणी नहीं की जाती है।

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

---[[
  print 'Lua is love'
--[=[]]
  print 'Lua is life'
--]=]

सक्रिय दूसरा हिस्सा है, जबकि पहले हिस्सा अक्षम करने, हटाने अग्रणी - पहली पंक्ति पर:

--[[
  print 'Lua is love'
--[=[]]
  print 'Lua is life'
--]=]

लुआ कार्यक्रमों को निष्पादित करना

आमतौर पर, लूआ को दो बायनेरिज़ के साथ भेजा जा रहा है:

• lua - स्टैंडअलोन दुभाषिया और इंटरैक्टिव खोल
• luac - बाइटकोड कंपाइलर

कहते हैं कि हमारे पास एक उदाहरण कार्यक्रम है ( bottles_of_mate.lua ) इस तरह:

local string = require "string"    

function bottle_take(bottles_available)

    local count_str = "%d bottles of mate on the wall."
    local take_str = "Take one down, pass it around, " .. count_str
    local end_str = "Oh noes, " .. count_str
    local buy_str = "Get some from the store, " .. count_str
    local bottles_left = 0

    if bottles_available > 0 then
         print(string.format(count_str, bottles_available))
         bottles_left = bottles_available - 1
         print(string.format(take_str, bottles_left))
    else
        print(string.format(end_str, bottles_available))
        bottles_left = 99
        print(string.format(buy_str, bottles_left))
    end

    return bottles_left
end

local bottle_count = 99

while true do
    bottle_count = bottle_take(bottle_count)
end

कार्यक्रम को आपके शेल पर चलकर निष्पादित किया जा सकता है:

$ lua bottles_of_mate.lua

आउटपुट इस तरह दिखना चाहिए, जो अंतहीन लूप में चल रहा है:

Get some from the store, 99 bottles of mate on the wall.
99 bottles of mate on the wall.
Take one down, pass it around, 98 bottles of mate on the wall.
98 bottles of mate on the wall.
Take one down, pass it around, 97 bottles of mate on the wall.
97 bottles of mate on the wall.
...
...
3 bottles of mate on the wall.
Take one down, pass it around, 2 bottles of mate on the wall.
2 bottles of mate on the wall.
Take one down, pass it around, 1 bottles of mate on the wall.
1 bottles of mate on the wall.
Take one down, pass it around, 0 bottles of mate on the wall.
Oh noes, 0 bottles of mate on the wall.
Get some from the store, 99 bottles of mate on the wall.
99 bottles of mate on the wall.
Take one down, pass it around, 98 bottles of mate on the wall.
...

आप अपने शेल पर निम्न कार्य करके कार्यक्रम को लुआ के बायटेकोड में संकलित कर सकते हैं:

$ luac bottles_of_mate.lua -o bottles_of_mate.luac

इसके अलावा बायोटेक लिस्टिंग निम्नलिखित निष्पादित करके उपलब्ध है:

$ luac -l bottles_of_mate.lua


main <./bottles.lua:0,0> (13 instructions, 52 bytes at 0x101d530)
0+ params, 4 slots, 0 upvalues, 2 locals, 4 constants, 1 function
    1    [1]    GETGLOBAL    0 -1    ; require
    2    [1]    LOADK        1 -2    ; "string"
    3    [1]    CALL         0 2 2
    4    [22]    CLOSURE      1 0    ; 0x101d710
    5    [22]    MOVE         0 0
    6    [3]    SETGLOBAL    1 -3    ; bottle_take
    7    [24]    LOADK        1 -4    ; 99
    8    [27]    GETGLOBAL    2 -3    ; bottle_take
    9    [27]    MOVE         3 1
    10    [27]    CALL         2 2 2
    11    [27]    MOVE         1 2
    12    [27]    JMP          -5    ; to 8
    13    [28]    RETURN       0 1

function <./bottles.lua:3,22> (46 instructions, 184 bytes at 0x101d710)
1 param, 10 slots, 1 upvalue, 6 locals, 9 constants, 0 functions
    1    [5]    LOADK        1 -1    ; "%d bottles of mate on the wall."
    2    [6]    LOADK        2 -2    ; "Take one down, pass it around, "
    3    [6]    MOVE         3 1
    4    [6]    CONCAT       2 2 3
    5    [7]    LOADK        3 -3    ; "Oh noes, "
    6    [7]    MOVE         4 1
    7    [7]    CONCAT       3 3 4
    8    [8]    LOADK        4 -4    ; "Get some from the store, "
    9    [8]    MOVE         5 1
    10    [8]    CONCAT       4 4 5
    11    [9]    LOADK        5 -5    ; 0
    12    [11]    EQ           1 0 -5    ; - 0
    13    [11]    JMP          16    ; to 30
    14    [12]    GETGLOBAL    6 -6    ; print
    15    [12]    GETUPVAL     7 0    ; string
    16    [12]    GETTABLE     7 7 -7    ; "format"
    17    [12]    MOVE         8 1
    18    [12]    MOVE         9 0
    19    [12]    CALL         7 3 0
    20    [12]    CALL         6 0 1
    21    [13]    SUB          5 0 -8    ; - 1
    22    [14]    GETGLOBAL    6 -6    ; print
    23    [14]    GETUPVAL     7 0    ; string
    24    [14]    GETTABLE     7 7 -7    ; "format"
    25    [14]    MOVE         8 2
    26    [14]    MOVE         9 5
    27    [14]    CALL         7 3 0
    28    [14]    CALL         6 0 1
    29    [14]    JMP          15    ; to 45
    30    [16]    GETGLOBAL    6 -6    ; print
    31    [16]    GETUPVAL     7 0    ; string
    32    [16]    GETTABLE     7 7 -7    ; "format"
    33    [16]    MOVE         8 3
    34    [16]    MOVE         9 0
    35    [16]    CALL         7 3 0
    36    [16]    CALL         6 0 1
    37    [17]    LOADK        5 -9    ; 99
    38    [18]    GETGLOBAL    6 -6    ; print
    39    [18]    GETUPVAL     7 0    ; string
    40    [18]    GETTABLE     7 7 -7    ; "format"
    41    [18]    MOVE         8 4
    42    [18]    MOVE         9 5
    43    [18]    CALL         7 3 0
    44    [18]    CALL         6 0 1
    45    [21]    RETURN       5 2
    46    [22]    RETURN       0 1

शुरू करना

चर

var = 50 -- a global variable
print(var) --> 50
do
  local var = 100 -- a local variable
  print(var) --> 100
end
print(var) --> 50
-- The global var (50) still exists 
-- The local var (100) has gone out of scope and can't be accessed any longer.

प्रकार

num = 20 -- a number
num = 20.001 -- still a number
str = "zaldrizes buzdari iksos daor" -- a string
tab = {1, 2, 3} -- a table (these have their own category)
bool = true -- a boolean value
bool = false -- the only other boolean value
print(type(num)) --> 'number'
print(type(str)) --> 'string'
print(type(bool)) --> 'boolean'
type(type(num)) --> 'string'

-- Functions are a type too, and first-class values in Lua.
print(type(print)) --> prints 'function'
old_print = print
print = function (x) old_print "I'm ignoring the param you passed me!" end
old_print(type(print)) --> Still prints 'function' since it's still a function.
-- But we've (unhelpfully) redefined the behavior of print.
print("Hello, world!") --> prints "I'm ignoring the param you passed me!"

विशेष प्रकार का nil

लुआ में एक अन्य प्रकार nil । nil प्रकार में एकमात्र मान nil । nil लुआ के अन्य सभी मूल्यों से अलग है। यह एक तरह का गैर-मूल्य मूल्य है।

print(foo) -- This prints nil since there's nothing stored in the variable 'foo'.
foo = 20
print(foo) -- Now this prints 20 since we've assigned 'foo' a value of 20.

-- We can also use `nil` to undefine a variable
foo = nil -- Here we set 'foo' to nil so that it can be garbage-collected.

if nil then print "nil" end --> (prints nothing)
-- Only false and nil are considered false; every other value is true.
if 0 then print "0" end --> 0
if "" then print "Empty string!" --> Empty string!

भाव

a = 3
b = a + 20 a = 2 print(b, a) -- hard to read, can also be written as
b = a + 20; a = 2; print(a, b) -- easier to read, ; are optional though
true and true --> returns true
true and 20 --> 20
false and 20 --> false
false or 20 --> 20
true or 20 --> true
tab or {}
  --> returns tab if it is defined
  --> returns {} if tab is undefined
  -- This is useful when we don't know if a variable exists
tab = tab or {} -- tab stays unchanged if it exists; tab becomes {} if it was previously nil.

a, b = 20, 30 -- this also works
a, b = b, a -- switches values

कार्यों को परिभाषित करना

function name(parameter)
    return parameter
end
print(name(20)) --> 20
-- see function category for more information
name = function(parameter) return parameter end -- Same as above

बूलियन्स

केवल false और nil मूल्यांकन असत्य के रूप में, बाकी सब सहित, 0 और खाली स्ट्रिंग सत्य के रूप में मूल्यांकन करते हैं।

कचरा इकठा करना

tab = {"lots", "of", "data"}
tab = nil; collectgarbage()
-- tab does no longer exist, and doesn't take up memory anymore.

टेबल

tab1 = {"a", "b", "c"}
tab2 = tab1
tab2[1] = "d"
print(tab1[1]) --> 'd' -- table values only store references.
--> assigning tables does not copy its content, only the reference.

tab2 = nil; collectgarbage()
print(tab1) --> (prints table address) -- tab1 still exists; it didn't get garbage-collected.

tab1 = nil; collectgarbage()
-- No more references. Now it should actually be gone from memory.

ये मूल बातें हैं, लेकिन अधिक जानकारी वाली तालिकाओं के बारे में एक खंड है।

शर्तेँ

if (condition) then
    -- do something
elseif (other_condition) then
    -- do something else
else
    -- do something
end

छोरों के लिए

वहाँ के दो प्रकार हैं for एक अंकीय: लुआ में पाश for पाश और एक सामान्य for पाश।

• लूप के for एक सांख्यिक का निम्न रूप है:

  for a=1, 10, 2 do -- for a starting at 1, ending at 10, in steps of 2
    print(a) --> 1, 3, 5, 7, 9
  end
  

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

   for a=10, 1, -1 do
     print(a) --> 10, 9, 8, 7, 6, etc.
   end
  

  यदि चरण अभिव्यक्ति छोड़ दी जाती है, तो Lua 1 का डिफ़ॉल्ट चरण मानता है।

   for a=1, 10 do
     print(a) --> 1, 2, 3, 4, 5, etc.
   end
  

  यह भी ध्यान दें कि लूप वेरिएबल लूप के for स्थानीय है। लूप खत्म होने के बाद यह मौजूद नहीं होगा।

• लूप्स के for सामान्य सभी मानों के माध्यम से काम करते हैं जो एक पुनरावृत्ति फ़ंक्शन देता है:

  for key, value in pairs({"some", "table"}) do
    print(key, value)
    --> 1 some
    --> 2 table
  end
  

  Lua कई ipairs (जैसे, pairs , ipairs ) में निर्मित प्रदान करता है, और उपयोगकर्ता अपने स्वयं के कस्टम ipairs को परिभाषित करने के साथ-साथ लूप के for सामान्य उपयोग कर सकते हैं।

ब्लॉक करो

local a = 10
do
    print(a) --> 10
    local a = 20
    print(a) --> 20
end
print(a) --> 10

कुछ मुश्किल बातें

कभी-कभी लुआ उस तरह से व्यवहार नहीं करता है जिस तरह से प्रलेखन पढ़ने के बाद किसी ने सोचा होगा। इनमें से कुछ मामले हैं:

शून्य और कुछ भी समान नहीं हैं (COMMON PITFALL!)

जैसा कि अपेक्षित था, table.insert(my_table, 20) मान को तालिका में 20 जोड़ता है, और table.insert(my_table, 5, 20) 5 वें स्थान पर मान 20 जोड़ता है। हालांकि table.insert(my_table, 5, nil) क्या करता है? कोई अपेक्षा कर सकता है कि वह nil को बिना किसी तर्क के मान सकता है, और तालिका के अंत में मान 5 डाल सकता है, लेकिन यह वास्तव में तालिका के 5 वें स्थान पर मूल्य nil जोड़ता है। यह कब समस्या है?

(function(tab, value, position)
    table.insert(tab, position or value, position and value)
end)({}, 20)
-- This ends up calling table.insert({}, 20, nil)
-- and this doesn't do what it should (insert 20 at the end)

इसी तरह की बात tostring() साथ tostring() :

print (tostring(nil)) -- this prints "nil"
table.insert({}, 20) -- this returns nothing
-- (not nil, but actually nothing (yes, I know, in lua those two SHOULD
-- be the same thing, but they aren't))

-- wrong:
print (tostring( table.insert({}, 20) ))
-- throws error because nothing ~= nil

--right:
local _tmp = table.insert({}, 20) -- after this _tmp contains nil
print(tostring(_tmp)) -- prints "nil" because suddenly nothing == nil

तृतीय पक्ष कोड का उपयोग करते समय यह भी त्रुटियों का कारण हो सकता है। हैं, उदाहरण के लिए, कुछ काम राज्यों के प्रलेखन "रिटर्न डोनट्स अगर भाग्यशाली, शून्य अन्यथा", कुछ हद तक कार्यान्वयन हो सकता है इस तरह दिखता है

function func(lucky)
    if lucky then
        return "donuts"
    end
end

यह कार्यान्वयन पहले उचित प्रतीत हो सकता है; यह डोनट्स को देता है जब इसे करना होता है, और जब आप result = func(false) टाइप करते हैं result = func(false) परिणाम में वैल्यू nil ।

हालाँकि, अगर किसी को print(tostring(func(false))) लिखना होता है, तो lua एक त्रुटि देगा जो कुछ इस तरह दिखती है stdin:1: bad argument #1 to 'tostring' (value expected)

ऐसा क्यों है? tostring स्पष्ट रूप से एक तर्क हो जाता है, भले ही यह nil । गलत। func कुछ भी नहीं देता है, इसलिए tostring(func(false)) tostring() के समान है और tostring(nil) के समान नहीं है।

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

सरणियों में अंतराल छोड़कर

यदि आप लुआ के लिए नए हैं, तो यह एक बड़ा नुकसान है, और तालिकाओं की श्रेणी में बहुत सारी जानकारी है

नमस्ते दुनिया

यह हैलो वर्ल्ड कोड है:

print("Hello World!")

यह काम किस प्रकार करता है? यह आसान है! Lua print() फ़ंक्शन को निष्पादित करता है और तर्क के रूप में "Hello World" स्ट्रिंग का उपयोग करता है।