Lua Academy · पाठ

एकाधिक वापसी मान

एक ही फ़ंक्शन कॉल से कई मान लौटाएँ और प्राप्त करें।

पाठ 2, कुल 4 में से12 चरण

एकाधिक वापसी मान, CoddyKit पर Lua Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Lua Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Lua Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

एकाधिक मान लौटाना

अधिकांश भाषाओं के विपरीत, Lua फ़ंक्शन एक ही return कथन से मूल रूप से कई मान लौटा सकते हैं। कई मानों को return के बाद अल्पविराम से अलग किया जाता है। इससे आवरण ऑब्जेक्ट या आउटपुट पैरामीटर की आवश्यकता नहीं रहती।

local function divmod(a, b)
  return math.floor(a / b), a % b
end

local quotient, remainder = divmod(17, 5)
print(quotient, remainder)   -- 3  2

वापसी मानों को समायोजित करना

Lua वापसी मानों की संख्या को प्राप्त करने वाले चरों की संख्या के अनुसार समायोजित करता है। अतिरिक्त मान हटा दिए जाते हैं; अनुपस्थित मान nil बन जाते हैं। यह समायोजन तब होता है जब फ़ंक्शन कॉल किसी सूची में अंतिम व्यंजक न हो—उस स्थान पर केवल पहला मान रखा जाता है।

local function triple()
  return 10, 20, 30
end

local a, b, c = triple()
print(a, b, c)      -- 10  20  30

local x, y = triple()
print(x, y)         -- 10  20  (30 discarded)

local p = triple()
print(p)            -- 10  (only first when 1 var)

मध्य स्थिति का समायोजन

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

local function pair()
  return 1, 2
end

-- pair() in middle: only 1 value used
local t = {pair(), pair()}
print(#t, t[1], t[2], t[3])  -- 3  1  1  2
-- first pair() gives just 1; last pair() gives 1,2

-- pair() at end: all values used
local t2 = {10, pair()}
print(#t2, t2[1], t2[2], t2[3])  -- 3  10  1  2

कोष्ठक एकल मान सुनिश्चित करते हैं

फ़ंक्शन कॉल को कोष्ठकों में रखने पर वह ठीक एक मान लौटाने के लिए बाध्य हो जाता है। यह तब उपयोगी है जब आप फ़ंक्शन द्वारा लौटाए जाने वाले मानों की संख्या चाहे जितनी हो, केवल पहला वापसी मान चाहते हों।

local function coords()
  return 10, 20, 30
end

print(coords())    -- 10  20  30  (all three)
print((coords()))  -- 10  (parentheses: single value only)

local x = (coords())
print(x)           -- 10

string.find के वापसी मान

कई मानक लाइब्रेरी फ़ंक्शन कई मान लौटाते हैं। string.find मिलान की शुरुआत और अंत की स्थितियाँ लौटाता है, साथ ही कैप्चर भी। math.modf पूर्णांक और भिन्नात्मक भाग लौटाता है। इन स्वरूपों को समझने से आप मानक लाइब्रेरी का सहजता से उपयोग कर पाएँगे।

local s = "hello world"
local start, finish = string.find(s, "world")
print(start, finish)   -- 7  11

-- math.modf: integer and fractional parts
local int, frac = math.modf(3.75)
print(int, frac)       -- 3   0.75

table.pack से मान कैप्चर करना

table.pack(...) सभी तर्कों को, या ... के माध्यम से वापसी मानों को, एक तालिका में कैप्चर करता है। तालिका में कुल संख्या वाला n फ़ील्ड भी शामिल होता है, जिसमें nil मान भी गिने जाते हैं। यह # के विपरीत सटीक संख्या सुरक्षित रखता है, जो पहले रिक्त स्थान पर रुक जाता है।

local function getData()
  return "Alice", 30, nil, true
end

local t = table.pack(getData())
print(t.n)         -- 4
print(t[1])        -- Alice
print(t[2])        -- 30
print(t[3])        -- nil
print(t[4])        -- true

विस्तार के लिए table.unpack

table.unpack(t, i, j) तालिका के तत्वों को अलग-अलग मानों के रूप में लौटाता है। यह table.pack का उलटा है। इसका उपयोग तालिका की सामग्री को किसी फ़ंक्शन के तर्कों के रूप में पास करने या return कथन में मानों का विस्तार करने के लिए करें।

local args = {10, 20, 30}

local function sum3(a, b, c)
  return a + b + c
end

print(sum3(table.unpack(args)))  -- 60

-- Use in return
local function passThrough(t)
  return table.unpack(t)
end
print(passThrough({5, 6, 7}))   -- 5  6  7

त्रुटि-शैली के वापसी मान

Lua की एक सामान्य परंपरा है कि विफलता पर nil, errorMessage और सफलता पर परिणाम लौटाया जाए। कॉल करने वाला पहला वापसी मान जाँचता है: यदि वह nil है, तो त्रुटि हुई है। इससे अपेक्षित विफलताओं के लिए अपवादों की आवश्यकता नहीं रहती।

local function openConfig(path)
  local f = io.open(path, "r")
  if not f then
    return nil, "cannot open: " .. path
  end
  local content = f:read("*a")
  f:close()
  return content
end

local data, err = openConfig("config.lua")
if not data then
  print("Error:", err)
end

एकाधिक वापसी मानों से अदला-बदली

एकाधिक वापसी मान अदला-बदली की समस्या का सुंदर समाधान करते हैं। असाइनमेंट से पहले दाईं ओर का व्यंजक मूल्यांकित होता है, इसलिए a, b = b, a किसी अस्थायी चर के बिना मानों को सही ढंग से बदल देता है।

local a, b = 5, 10
print(a, b)   -- 5  10

a, b = b, a
print(a, b)   -- 10  5

-- Works for three-way rotation too
local x, y, z = 1, 2, 3
x, y, z = z, x, y
print(x, y, z)  -- 3  1  2

pcall की वापसी परंपरा

pcall(f, ...) स्वयं कई वापसी मानों का उपयोग करता है: पहला मान बूलियन होता है, जो सफलता पर true और त्रुटि पर false होता है; बाद के मान या तो f के वापसी मान होते हैं या त्रुटि संदेश। शेष मानों का उपयोग करने से पहले हमेशा पहला वापसी मान जाँचें।

local function risky(x)
  if x < 0 then error("negative input") end
  return math.sqrt(x)
end

local ok, result = pcall(risky, 16)
print(ok, result)   -- true  4.0

ok, result = pcall(risky, -1)
print(ok, result)   -- false  input:2: negative input

त्वरित जाँच

print((string.find("hello", "ll"))) क्या आउटपुट देगा?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: एकाधिक वापसी मान

मुख्य निष्कर्ष:

कई मान लौटाएँ: return a, b, c
अतिरिक्त मान हटा दिए जाते हैं; अनुपस्थित मान nil बन जाते हैं
मध्य-स्थिति वाली कॉल को 1 मान तक सीमित कर दिया जाता है
(f()) ठीक 1 मान सुनिश्चित करता है
गतिशील मान-सूचियों के लिए table.pack/table.unpack
परंपरा: विफलता पर nil, errmsg लौटाएँ

शुरुआत निःशुल्क

एआई शिक्षक के साथ Lua सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 40
पाठ: 159

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “एकाधिक वापसी मान” पाठ निःशुल्क है?

हाँ — Lua Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “एकाधिक वापसी मान” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Lua Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“एकाधिक वापसी मान” में मैं क्या सीखूँगा?

एक ही फ़ंक्शन कॉल से कई मान लौटाएँ और प्राप्त करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Lua Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Lua Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Lua Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“एकाधिक वापसी मान” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Lua Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Lua Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Lua Academy पर वापस जाएँ