लूआ पर लूप के लिए

Question 1

मेरा काम है कि कैसे एक लूप के लिए किया जाए। मैंने इसे संख्या के संदर्भ में समझ लिया है, लेकिन नामों के संदर्भ में इसका पता नहीं लगा सकता। मैं लूप के लिए एक नाम बनाना चाहता हूं जो नामों की एक सूची बनाता है। निम्नलिखित वह है जो मेरे पास अभी तक है:

names = {'John', 'Joe', 'Steve'}
for names = 1, 3 do
  print (names)
end

मैंने कुछ अन्य चीजों की कोशिश की है, लेकिन यह सिर्फ काम नहीं करता है, टर्मिनल हमेशा 1, 2, 3 को सूचीबद्ध करता है ... मैं क्या गलत कर रहा हूं?

Question 2

आपकी समस्या सरल है:

names = {'John', 'Joe', 'Steve'}
for names = 1, 3 do
  print (names)
end

यह कोड पहली बार एक वैश्विक चर घोषित करता है names। उसके बाद, आप लूप के लिए प्रारंभ करें। लूप के लिए एक स्थानीय वैरिएबल घोषित करता है, जो कि सिर्फ इतना ही होता namesहै; इस तथ्य को कि पहले एक चर के साथ परिभाषित किया गया था names, पूरी तरह से अप्रासंगिक है। namesलूप के लिए अंदर का कोई भी उपयोग स्थानीय को संदर्भित करेगा , वैश्विक को नहीं।

फॉर लूप का कहना है कि लूप के अंदरूनी हिस्से को names = 1तब names = 2, और अंत में बुलाया जाएगा names = 3। लूप के लिए एक काउंटर घोषित करता है जो पहले नंबर से आखिरी तक गिना जाता है, और यह आंतरिक कोड को एक बार प्रत्येक मूल्य के लिए कॉल करता है।

जो आप वास्तव में चाहते थे वह कुछ इस तरह था:

names = {'John', 'Joe', 'Steve'}
for nameCount = 1, 3 do
  print (names[nameCount])
end

[] वाक्यविन्यास है कि आप एक लुआ तालिका के सदस्यों तक कैसे पहुँचते हैं। लुआ टेबल "मान" के लिए "चाबियाँ" का नक्शा। आपका सरणी स्वतः पूर्णांक प्रकार की कुंजी बनाता है, जो वृद्धि करता है। तो तालिका में "जो" से जुड़ी कुंजी 2 है (लुआ सूचकांक हमेशा 1 पर शुरू होता है)।

इसलिए, आपको एक लूप की आवश्यकता है जो 1 से 3 तक गिना जाता है, जो आपको मिलता है। आप तालिका से तत्व तक पहुंचने के लिए गिनती चर का उपयोग करते हैं।

हालांकि, इसमें एक दोष है। यदि आप सूची में से किसी एक तत्व को हटाते हैं तो क्या होता है?

names = {'John', 'Joe'}
for nameCount = 1, 3 do
  print (names[nameCount])
end

अब, हम प्राप्त करते हैं John Joe nil, क्योंकि परिणाम तालिका में मौजूद मानों तक पहुँचने का प्रयास नहीं किया जाता है nil। इसे रोकने के लिए, हमें तालिका की लंबाई 1 से गिनने की आवश्यकता है :

names = {'John', 'Joe'}
for nameCount = 1, #names do
  print (names[nameCount])
end

#लंबाई ऑपरेटर है। यह टेबल और स्ट्रिंग्स पर काम करता है, दोनों की लंबाई वापस करता है। अब, कोई फर्क नहीं पड़ता कि कितना बड़ा या छोटा namesमिलता है, यह हमेशा काम करेगा।

हालाँकि, आइटम की एक सरणी के माध्यम से पुनरावृति करने का एक और अधिक सुविधाजनक तरीका है:

names = {'John', 'Joe', 'Steve'}
for i, name in ipairs(names) do
  print (name)
end

ipairsएक Lua मानक फ़ंक्शन है जो एक सूची पर प्रसारित होता है। forलूप की यह शैली, लूप के लिए इटरेटर, इस तरह के इटरेटर फ़ंक्शन का उपयोग करता है। iमान सरणी में प्रवेश के सूचकांक है। nameमूल्य कि सूचकांक में मूल्य है। तो यह मूल रूप से आपके लिए बहुत सारे गंभीर काम करता है।

Question 3

ऑनलाइन ( टेबल ट्यूटोरियल ) पढ़ने से ऐसा लगता है कि सारणी की तरह सारणी व्यवहार करती है ताकि आप देख रहे हैं:

Way1

names = {'John', 'Joe', 'Steve'}
for i = 1,3 do print( names[i] ) end

Way2

names = {'John', 'Joe', 'Steve'}
for k,v in pairs(names) do print(v) end

Way1 तालिका का उपयोग करता है index/key, आपकी तालिका में namesप्रत्येक तत्व में 1 से शुरू होने वाली एक कुंजी है, उदाहरण के लिए:

names = {'John', 'Joe', 'Steve'}
print( names[1] ) -- prints John

तो आप बस i1 से 3 कर दें।

पर Way2 बजाय आपके द्वारा निर्दिष्ट क्या तालिका आप चलाने के लिए और उसके प्रमुख और उदाहरण के लिए मूल्य के लिए एक चर प्रदान करना चाहते हैं:

names = {'John', 'Joe', myKey="myValue" }
for k,v in pairs(names) do print(k,v) end

निम्नलिखित प्रिंट करता है:

1   John
2   Joe
myKey   myValue

Question 4

names = {'John', 'Joe', 'Steve'}
for names = 1, 3 do
  print (names)
end

आप अपनी तालिका को हटा रहे हैं और इसे एक इंट के साथ बदल रहे हैं
आप तालिका से कोई मान नहीं निकाल रहे हैं

प्रयत्न:

names = {'John','Joe','Steve'}
for i = 1,3 do
    print(names[i])
end