Lua Academy · पाठ

अंकगणितीय और संबंधपरक ऑपरेटर

+,-,*,/,//,% ,^ और तुलना ऑपरेटरों का प्रभावी उपयोग करें।

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

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

अंकगणितीय ऑपरेटरों का अवलोकन

Lua अंकगणितीय ऑपरेटरों का पूरा समूह उपलब्ध कराता है: + (जोड़ना), - (घटाना), * (गुणा करना), / (दशमलव भाग), // (फ़्लोर भाग), % (शेषफल), ^ (घातांक) और एकल - (ऋणात्मक करना)। Lua 5.3+ में प्रत्येक ऑपरेटर पूर्णांक या दशमलव में से क्या लौटाता है, यह समझना बहुत महत्वपूर्ण है।

print(10 + 3)   -- 13
print(10 - 3)   -- 7
print(10 * 3)   -- 30
print(10 / 3)   -- 3.3333...  (always float)
print(10 // 3)  -- 3          (floor division)
print(10 % 3)   -- 1          (modulo)
print(2 ^ 10)   -- 1024.0     (always float)
print(-5)       -- -5

पूर्णांक बनाम दशमलव भाग

/ ऑपरेटर हमेशा दशमलव लौटाता है, यहाँ तक कि तब भी जब समान रूप से विभाजित होने वाले दो पूर्णांकों का भाग दिया जाए। फ़्लोर भाग देने वाला // ऑपरेटर केवल तभी पूर्णांक लौटाता है, जब दोनों संक्रियक पूर्णांक हों; यदि इनमें से कोई एक दशमलव हो, तो परिणाम दशमलव होता है, लेकिन फिर भी नीचे की ओर पूर्णांकित रहता है।

^ घातांक ऑपरेटर हमेशा मान को दशमलव में बदल देता है, इसलिए 2^3 का परिणाम 8 नहीं, बल्कि 8.0 होता है। आवश्यकता होने पर वापस बदलने के लिए math.tointeger() का उपयोग करें।

print(6 / 2)        -- 3.0  (float!)
print(6 // 2)       -- 3    (integer)
print(6.0 // 2)     -- 3.0  (float floor)
print(7 // 2)       -- 3    (floor toward -inf)
print(-7 // 2)      -- -4   (floor, not truncate!)
print(2 ^ 3)        -- 8.0  (always float)

शेषफल ऑपरेटर

Lua का % ऑपरेटर a % b == a - floor(a/b) * b के रूप में परिभाषित है। इसका अर्थ है कि इसका चिह्न भाजक के अनुसार होता है, भाज्य के अनुसार नहीं। यह C/Java से अलग है, जहाँ परिणाम का चिह्न भाज्य के अनुसार होता है।

शेषफल ऑपरेटर मानों को चक्रीय रूप से दोहराने, ऐरे में क्रम से घूमने और रिंग बफ़र लागू करने के लिए उपयोगी है। एक सामान्य उपयोग: i % n 0 से n-1 तक चक्र बनाता है।

print(10 % 3)    --  1  (positive)
print(-10 % 3)   --  2  (sign of divisor!)
print(10 % -3)   -- -2  (sign of divisor)

-- Cycling 1..5 example
for i = 1, 8 do
  local idx = (i - 1) % 5 + 1
  io.write(idx .. " ")  -- 1 2 3 4 5 1 2 3
end

संबंधपरक ऑपरेटर

Lua के संबंधपरक ऑपरेटर बूलियन मान लौटाते हैं: == (समान), ~= (समान नहीं), <, >, <=, >=। ध्यान दें कि अधिकांश भाषाओं में प्रयुक्त != के विपरीत, Lua असमानता के लिए ~= का उपयोग करता है।

== से अलग-अलग प्रकार के मानों की तुलना करने पर हमेशा false मिलता है — समानता की जाँच के लिए कोई अंतर्निहित प्रकार-रूपांतरण नहीं होता। Lua में 1 == "1" का परिणाम false है।

print(3 == 3)    -- true
print(3 ~= 4)    -- true
print(3 < 4)     -- true
print(3 >= 3)    -- true

-- No cross-type equality coercion
print(1 == "1")  -- false
print(0 == false) -- false

-- Strings compare lexicographically
print("abc" < "abd")  -- true

तार्किक ऑपरेटर: and, or, not

लुआ के तार्किक ऑपरेटर and, or और not हैं। कई भाषाओं के विपरीत, and और or बूलियन मान नहीं लौटाते—वे अपने ऑपरैंड में से एक लौटाते हैं। इससे डिफ़ॉल्ट मान और सशर्त असाइनमेंट जैसे प्रचलित पैटर्न संभव होते हैं।

a and b, यदि a falsy है, तो a लौटाता है; अन्यथा b लौटाता है
a or b, यदि a truthy है, तो a लौटाता है; अन्यथा b लौटाता है

-- and/or return operands, not booleans
print(1 and 2)        -- 2
print(false and 2)    -- false
print(1 or 2)         -- 1
print(false or 2)     -- 2

-- Default value idiom
local name = nil
local display = name or "Anonymous"
print(display)        -- Anonymous

टर्नरी इडियम

लुआ में टर्नरी ऑपरेटर (?:) नहीं है, लेकिन आप and/or का उपयोग करके उसका अनुकरण कर सकते हैं। condition and value_if_true or value_if_false पैटर्न तभी काम करता है जब value_if_true, nil या false न हो।

यह लुआ का बहुत सामान्य इडियम है। किनारे की स्थिति का ध्यान रखें: यदि सत्य शाखा का मान सचमुच false है, तो यह पैटर्न विफल हो जाता है—इसके बजाय if कथन का उपयोग करें।

local x = 10
-- Ternary idiom
local label = x > 5 and "big" or "small"
print(label)   -- big

-- Works for non-false truthy values
local age = 20
local status = age >= 18 and "adult" or "minor"
print(status)  -- adult

-- Edge case: true branch is false -> use if
local val = true and false or "fallback"
print(val)  -- fallback (wrong!)

ऑपरेटर प्राथमिकता

लुआ में सबसे कम से सबसे अधिक प्राथमिकता का क्रम: or, and, तुलनाएँ (< > <= >= == ~=), |, ~, &, शिफ्ट, .., + -, * / // %, यूनरी (not # - ~), ^। ^ और .. ऑपरेटर दाएँ-सहचारी हैं; बाकी सभी बाएँ-सहचारी हैं।

-- Precedence examples
print(2 + 3 * 4)     -- 14  (not 20)
print(2 ^ 3 ^ 2)     -- 512 (right assoc: 2^(3^2) = 2^9)
print(not 1 == 1)    -- false (not (1) == 1 => false == 1)
print(not (1 == 1))  -- false

-- Use parens to be explicit
print((2 + 3) * 4)   -- 20

बिटवाइज़ ऑपरेटर (लुआ 5.3+)

लुआ 5.3 में पूर्णांकों पर काम करने वाले मूल बिटवाइज़ ऑपरेटर जोड़े गए: & (AND), | (OR), ~ (द्विआधारी होने पर XOR, यूनरी होने पर NOT), << (बाएँ शिफ्ट), >> (दाएँ शिफ्ट)। लाइब्रेरी के बिना ये लुआ 5.1/5.2 में उपलब्ध नहीं हैं।

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

-- Bitwise operators (Lua 5.3+)
print(0xFF & 0x0F)   -- 15  (AND)
print(0xF0 | 0x0F)   -- 255 (OR)
print(0xFF ~ 0x0F)   -- 240 (XOR)
print(~0)            -- -1  (bitwise NOT)
print(1 << 4)        -- 16  (left shift)
print(256 >> 4)      -- 16  (right shift)

स्ट्रिंग की लंबाई और संयोजन

# ऑपरेटर बाइट में स्ट्रिंग की लंबाई लौटाता है और .. ऑपरेटर दो स्ट्रिंग को जोड़ता है। जब आप संख्याओं पर .. लागू करते हैं, तो लुआ उन्हें अपने-आप स्ट्रिंग में बदल देता है। हालांकि, + के साथ प्रकार मिलाने पर बलपूर्वक रूपांतरण के नियम लागू होते हैं—संख्या जैसी दिखने वाली स्ट्रिंग का उपयोग अंकगणित में किया जा सकता है।

local s = "hello"
print(#s)            -- 5
print(s .. " world") -- hello world
print(1 .. 2)        -- 12  (number to string)

-- Length of table = array part length
local t = {10, 20, 30}
print(#t)   -- 3

-- Beware: # on tables with holes is undefined
local h = {1, nil, 3}
print(#h)   -- 1 or 3 (undefined behavior!)

ऑपरेटरों से जुड़ी सामान्य गलतियाँ

लुआ में ऑपरेटरों से जुड़ी कई बग सामान्य हैं: यह भूल जाना कि / हमेशा फ़्लोट लौटाता है; ~= की जगह != का उपयोग करना (वाक्यविन्यास त्रुटि); 0 या "" को falsy मानना (वे truthy होते हैं); और तब and/or पर निर्भर करना जब सत्य शाखा false हो सकती हो।

सीमा-स्थितियों का हमेशा परीक्षण करें, खासकर ऋणात्मक संख्याओं के साथ फ़्लोर डिविज़न में, जहाँ // ऋणात्मक अनंत की ओर फ़्लोर करता है।

-- Common mistakes
-- 1. / is always float
local result = 10 / 2
print(math.type(result))  -- float, not integer!

-- 2. ~= not !=
-- if x != 5 then  -- SYNTAX ERROR!
if 3 ~= 5 then print("not equal") end

-- 3. 0 is truthy
if 0 then print("0 is truthy in Lua!") end

-- 4. Negative floor division
print(-7 // 2)  -- -4 (not -3!)

त्वरित जाँच

लुआ में -7 // 2 का परिणाम क्या है?

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

पुनरावलोकन: अंकगणितीय और संबंधपरक ऑपरेटर

मुख्य बिंदु:

/ हमेशा फ़्लोट लौटाता है; // ऋणात्मक अनंत की ओर फ़्लोर करता है
^ हमेशा फ़्लोट लौटाता है और दाएँ-सहचारी है
~= असमानता का ऑपरेटर है (!= नहीं)
and/or ऑपरैंड लौटाते हैं, बूलियन नहीं—इससे डिफ़ॉल्ट मान वाला इडियम संभव होता है
केवल nil और false falsy होते हैं—0 और "" truthy होते हैं
बिटवाइज़ ऑपरेटर (& | ~ << >>) के लिए लुआ 5.3+ के पूर्णांक आवश्यक हैं

अगला विषय: प्रकार का बलपूर्वक रूपांतरण और स्पष्ट रूपांतरण फ़ंक्शन।

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

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

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

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

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

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

क्या “अंकगणितीय और संबंधपरक ऑपरेटर” पाठ निःशुल्क है?

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

“अंकगणितीय और संबंधपरक ऑपरेटर” में मैं क्या सीखूँगा?

+,-,*,/,//,% ,^ और तुलना ऑपरेटरों का प्रभावी उपयोग करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Lua Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

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

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

“अंकगणितीय और संबंधपरक ऑपरेटर” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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