Lua Academy · पाठ

require फ़ंक्शन

require से बाहरी मॉड्यूल लोड करें और मॉड्यूल कैशिंग समझें।

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

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

require कैसे काम करता है

require(modname) एक मॉड्यूल लोड करके लौटाता है। यह package.path में .lua फ़ाइल और package.cpath में C लाइब्रेरी खोजता है। परिणाम package.loaded[modname] में कैश हो जाता है—बाद की कॉल फ़ाइल को दोबारा चलाए बिना कैश किया हुआ मान लौटाती हैं।

-- First require: loads and executes math_utils.lua
local math_utils = require("math_utils")

-- Second require: returns cached value (file not re-run)
local math_utils2 = require("math_utils")

print(math_utils == math_utils2)   -- true (same object)
print(package.loaded["math_utils"] == math_utils)  -- true

मॉड्यूल का लौटाया गया मान

मॉड्यूल फ़ाइल को एक मान लौटाना चाहिए—आमतौर पर फ़ंक्शनों की टेबल। यही लौटाया गया मान require कॉल करने वाले को देता है। यदि फ़ाइल कुछ नहीं लौटाती (या true लौटाती है), तो require वही लौटाता है।

-- mymodule.lua:
-- local M = {}
-- function M.hello() print("Hello from module!") end
-- return M

-- In main script:
local m = require("mymodule")
m.hello()   -- Hello from module!

-- The module table is the interface

package.loaded में कैशिंग

package.loaded एक ऐसी टेबल है जो मॉड्यूल नामों को उनके लोड किए गए मानों से मैप करती है। आप मॉक को पहले से लोड करने के लिए किसी प्रविष्टि को मैन्युअली सेट कर सकते हैं, या उसे nil पर सेट करके दोबारा लोड करना बाध्य कर सकते हैं (अगली require पर मॉड्यूल फ़ाइल फिर चलेगी)।

-- Force reload by clearing cache
package.loaded["mymodule"] = nil
local fresh = require("mymodule")  -- re-executes the file

-- Preload a mock for testing
package.loaded["db"] = {
  query = function() return {} end,
  close = function() end,
}
local db = require("db")  -- gets the mock

package.path का प्रारूप

package.path पैटर्नों की अर्धविराम से अलग की गई सूची है। प्लेसहोल्डर ? को मॉड्यूल नाम से बदला जाता है (डॉट को पथ विभाजक से बदलकर)। package.path के आरंभ में जोड़कर आप खोजने के लिए निर्देशिकाएँ शामिल कर सकते हैं।

print(package.path)
-- typically: ./?.lua;./?.luac;/usr/share/lua/5.4/?.lua;...

-- Add local lib directory
package.path = "./lib/?.lua;" .. package.path

-- Now require("utils") will look in ./lib/utils.lua

require बनाम dofile बनाम loadfile

require: कैश करता है और package.path में खोजता है। dofile(path): फ़ाइल को तुरंत चलाता है, कैश नहीं करता और सीधे पथ लेता है। loadfile(path): संकलित करता है लेकिन चलाता नहीं, और एक फ़ंक्शन लौटाता है। मॉड्यूल के लिए require; एकबारगी स्क्रिप्ट के लिए dofile उपयोग करें।

-- dofile: no caching, direct path
dofile("./scripts/setup.lua")

-- loadfile: compile only, returns function
local fn, err = loadfile("./config.lua")
if fn then
  local result = fn()   -- execute when ready
end

-- require: best for modules
local json = require("json")

निर्देशिकाओं के लिए डॉट के साथ require

उपनिर्देशिकाओं में मौजूद फ़ाइलों को संदर्भित करने के लिए मॉड्यूल नामों में डॉट का उपयोग करें। require("utils.string") का मैप utils/string.lua पर होता है (पथ पैटर्न में ? के साथ)। बहु-फ़ाइल लाइब्रेरी इसी तरह व्यवस्थित की जाती हैं।

-- Directory structure:
-- lib/
--   utils/
--     string.lua
--     table.lua
--   init.lua

package.path = "./lib/?.lua;" .. package.path

local strUtils = require("utils.string")   -- loads lib/utils/string.lua
local tblUtils = require("utils.table")    -- loads lib/utils/table.lua

मॉड्यूल आरंभीकरण के साइड इफ़ेक्ट

मॉड्यूल फ़ाइलें पहली बार require किए जाने पर एक बार चलती हैं। शीर्ष-स्तर का कोई भी कोड (फ़ंक्शनों के बाहर) require के समय चलता है। यह एकबारगी आरंभीकरण के लिए उपयोगी है, लेकिन सावधान रहें—नेटवर्क कनेक्शन या फ़ाइल कार्रवाइयों जैसे साइड इफ़ेक्ट आयात के समय चलते हैं।

-- counter.lua:
-- local count = 0   -- initialized once on first require
-- local M = {}
-- function M.increment() count = count + 1 end
-- function M.get() return count end
-- return M

local c = require("counter")
c.increment()
c.increment()
print(c.get())   -- 2

local c2 = require("counter")
print(c2.get())  -- 2 (same instance, cached)

require में त्रुटि प्रबंधन

यदि मॉड्यूल फ़ाइल में सिंटैक्स त्रुटि हो या लोड होते समय त्रुटि उठे, तो require त्रुटि उठाता है। त्रुटि संदेश में मॉड्यूल नाम और फ़ाइल के भीतर की त्रुटि शामिल होती है। मॉड्यूल लोड होने की विफलताओं को सहजता से संभालने के लिए pcall का उपयोग करें।

local ok, mod = pcall(require, "possibly_missing")
if not ok then
  print("Module not available:", mod)
  -- fall back to alternative or default implementation
  mod = {feature = function() return "fallback" end}
end

print(mod.feature())

package.preload

package.preload एक ऐसी तालिका है जिसमें आप मॉड्यूल नाम के आधार पर लोडर फ़ंक्शन पंजीकृत कर सकते हैं। जब require("name") को कॉल किया जाता है, तो Lua सबसे पहले preload की जाँच करता है। इससे आप फ़ाइलों के बिना मॉड्यूल पंजीकृत कर सकते हैं — एम्बेडेड Lua या परीक्षण के लिए उपयोगी।

package.preload["mymath"] = function()
  return {
    double = function(n) return n * 2 end,
    triple = function(n) return n * 3 end,
  }
end

local m = require("mymath")
print(m.double(5))   -- 10
print(m.triple(5))   -- 15

परिपत्र require

परिपत्र निर्भरताओं (A को B की आवश्यकता है और B को A की) को आंशिक रूप से संभाला जाता है: मॉड्यूल को निष्पादित करने से पहले Lua, package.loaded में true प्लेसहोल्डर रखता है। यदि B, A की अधूरी तालिका का उपयोग करने का प्रयास करता है, तो उसे अधूरे परिणाम मिल सकते हैं। मॉड्यूल के डिज़ाइन में परिपत्र निर्भरताओं से बचें।

-- a.lua: local b = require("b"); local M = {}; M.name = "A"; return M
-- b.lua: local a = require("a"); print("a.name:", a.name); return {}

-- When a.lua is loaded:
-- 1. a starts executing
-- 2. requires b -> b starts executing
-- 3. b requires a -> gets partial a (still loading!)
-- 4. a.name may be nil at step 3

print("Avoid circular requires in module design")

त्वरित जाँच

जब आप दूसरी बार require("mod") को कॉल करते हैं, तो क्या होता है?

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

पुनरावलोकन: require

सारांश:

require(name) मॉड्यूल को एक बार लोड करता है और package.loaded में कैश करता है
मॉड्यूल फ़ाइल अपना सार्वजनिक इंटरफ़ेस (आमतौर पर एक तालिका) लौटाती है
पुनः लोड करने के लिए package.loaded[name] को साफ़ करें
कस्टम खोज निर्देशिकाएँ जोड़ने के लिए package.path में जोड़ें
मेमोरी में मौजूद मॉड्यूल के लिए package.preload का उपयोग करें
परिपत्र निर्भरताओं से बचें

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

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

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

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

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

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

क्या “require फ़ंक्शन” पाठ निःशुल्क है?

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

“require फ़ंक्शन” में मैं क्या सीखूँगा?

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

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

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

“require फ़ंक्शन” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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