Lua
iterators

सामान्य लूप के लिए

Iterators का एक रूप का उपयोग for के रूप में जाना पाश पाश के लिए सामान्य ।

लूप के for सामान्य रूप तीन मापदंडों का उपयोग करता है:

1. एक इटेरेटर फ़ंक्शन जिसे अगले मान की आवश्यकता होने पर कॉल किया जाता है। यह दोनों अपरिवर्तनीय स्थिति और पैरामीटर के रूप में नियंत्रण चर प्राप्त करता है। nil संकेतों को वापस करना समाप्ति।
2. अपरिवर्तनीय स्थिति एक ऐसा मान है जो पुनरावृत्ति के दौरान परिवर्तित नहीं होता है। यह आमतौर पर पुनरावृत्ति का विषय है, जैसे कि तालिका, स्ट्रिंग या उपयोगकर्ताडेटा।
3. नियंत्रण चर पुनरावृत्ति के लिए एक प्रारंभिक मूल्य का प्रतिनिधित्व करता है।

हम अगले फ़ंक्शन का उपयोग करके सभी कुंजी-मान वाले जोड़े को तालिका में दर्ज करने के for एक लूप के लिए लिख सकते हैं।

local t = {a=1, b=2, c=3, d=4, e=5}

-- next is the iterator function
-- t is the invariant state
-- nil is the control variable (calling next with a nil gets the first key)
for key, value in next, t, nil do
  -- key is the new value for the control variable
  print(key, value) 
  -- Lua calls: next(t, key)  
end

मानक Iterators

Lua मानक पुस्तकालय दो पुनरावृत्ति कार्य प्रदान करता है जो तालिकाओं के लिए कुंजी-मूल्य जोड़े को पार करने के for लूप के साथ उपयोग किया जा सकता है।

एक दृश्य मेज पर पुनरावृति करने के लिए हम पुस्तकालय समारोह का उपयोग कर सकते ipairs ।

for index, value in ipairs {'a', 'b', 'c', 'd', 'e'} do
  print(index, value)  --> 1 a, 2 b, 3 c, 4 d, 5 e
end

किसी भी तालिका में सभी कुंजियों और मूल्यों पर पुनरावृत्ति करने के लिए हम लाइब्रेरी फ़ंक्शन जोड़े का उपयोग कर सकते हैं।

for key, value in pairs {a=1, b=2, c=3, d=4, e=5} do
  print(key, value)  --> e 5, c 3, a 1, b 2, d 4  (order not specified)
end

स्टेटलेस इटरेटर

दोनों जोड़े और आइपर्स स्टेटलेस पुनरावृत्तियों का प्रतिनिधित्व करते हैं। एक स्टेटलेस इटरेटर लूप के नियंत्रण चर और अपरिवर्तनीय स्थिति के लिए केवल जेनेरिक का उपयोग करता है।

जोड़े Iterator

हम next फ़ंक्शन का उपयोग करके स्टेटलेस pairs इटेरेटर को लागू कर सकते हैं।

-- generator function which initializes the generic for loop
local function pairs(t)
  -- next is the iterator function
  -- t is the invariant state
  -- control variable is nil
  return next, t, nil
end

इप्सटर इटरेटर

हम दो अलग-अलग कार्यों में स्टेटलेस ipairs को लागू कर सकते हैं।

-- function which performs the actual iteration
local function ipairs_iter(t, i)
  local i = i + 1  -- next index in the sequence (i is the control variable)
  local v = t[i]   -- next value (t is the invariant state)
  if v ~= nil then
    return i, v    -- index, value
  end
  return nil       -- no more values (termination)
end

-- generator function which initializes the generic for loop
local function ipairs(t)
  -- ipairs_iter is the iterator function
  -- t is the invariant state (table to be iterated)
  -- 0 is the control variable (first index)
  return ipairs_iter, t, 0
end

कैरेक्टर इटरेटर

हम लूप के for जेनेरिक के अनुबंध को पूरा करके नए स्टेटलेस पुनरावृत्तियों का निर्माण कर सकते हैं।

-- function which performs the actual iteration
local function chars_iter(s, i)
  if i < #s then
    i = i + 1
    return i, s:sub(i, i)
  end
end

-- generator function which initializes the generic for loop
local function chars(s)
  return chars_iter, s, 0
end

-- used like pairs and ipairs
for i, c in chars 'abcde' do
    print(i, c) --> 1 a, 2 b, 3 c, 4 f, 5 e
end

प्राइम नंबर Iterator

यह एक स्टेटलेस इटरेटर का एक और अधिक सरल उदाहरण है।

-- prime numbers iterator
local incr = {4, 1, 2, 0, 2}
function primes(s, p, d)
   s, p, d = s or math.huge, p and p + incr[p % 6] or 2, 1
   while p <= s do
      repeat
         d = d + incr[d % 6]
         if d*d > p then return p end
      until p % d == 0
      p, d = p + incr[p % 6], 1
   end
end

-- print all prime numbers <= 100
for p in primes, 100 do  -- passing in the iterator (do not call the iterator here)
   print(p)  -->  2  3  5  7  11 ... 97
end

-- print all primes in endless loop
for p in primes do  -- please note: "in primes", not "in primes()"
   print(p)
end

स्टेटफुल इटरेटर

स्टेटफुल इटैटर इटरेटर की वर्तमान स्थिति के बारे में कुछ अतिरिक्त जानकारी देते हैं।

टेबल्स का उपयोग करना

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

  local function chars_iter(t, i)
    local i = i + 1
    if i <= t.len then
      return i, t.s:sub(i, i)
    end
  end

  local function chars(s)
    -- the iterators state
    local t = {
      s = s,    -- the subject
      len = #s  -- cached length
    }
    return chars_iter, t, 0
  end

  for i, c in chars 'abcde' do
    print(i, c) --> 1 a, 2 b, 3 c, 4 d, 5 e
  end

क्लोजर का उपयोग करना

अतिरिक्त राज्य को एक फ़ंक्शन क्लोजर के भीतर लपेटा जा सकता है। चूंकि राज्य पूरी तरह से बंद होने के दायरे में समाहित है और अपरिवर्तनीय स्थिति और नियंत्रण चर की आवश्यकता नहीं है।

  local function chars(s)
    local i, len = 0, #s
    return function() -- iterator function
      i = i + 1
      if i <= len then
        return i, s:sub(i, i)
      end
    end
  end

  for i, c in chars 'abcde' do
    print(i, c) --> 1 a, 2 b, 3 c, 4 d, 5 e
  end

Coroutines का उपयोग करना

अतिरिक्त राज्य को एक कोरटाइन के भीतर समाहित किया जा सकता है, फिर से अपरिवर्तनीय स्थिति और नियंत्रण चर की आवश्यकता नहीं होती है।

  local function chars(s)
    return coroutine.wrap(function()
      for i = 1, #s do
        coroutine.yield(s:sub(i, i))
      end
    end)
  end

  for c in chars 'abcde' do
    print(c) --> a, b, c, d, e
  end