लुआ

Question

में तारों का संगतता कई भाषाओं में आप परिवर्तनीय असाइनमेंट पर स्ट्रिंग को जोड़ सकते हैं। मेरे पास लूआ प्रोग्रामिंग भाषा का उपयोग करके एक परिदृश्य है, जहां मुझे किसी मौजूदा चर के लिए कमांड के आउटपुट को जोड़ने की आवश्यकता है। क्या नीचे दिए गए उदाहरणों में लुआ में एक कार्यात्मक समतुल्य है?

अन्य भाषाओं के उदाहरण:

===== PERL ===== 
$filename = "checkbook"; 
$filename .= ".tmp"; 
================ 

===== C# ===== 
string filename = "checkbook"; 
filename += ".tmp"; 
=============== 

आपकी मदद के लिए अग्रिम धन्यवाद।

Answer 1

जैसा कि अन्य उत्तरों ने कहा है, लुआ में स्ट्रिंग कॉन्सटेनेशन ऑपरेटर दो बिंदु है।

आपका सरल उदाहरण इस तरह लिखा जाएगा:

filename = "checkbook" 
filename = filename .. ".tmp" 

हालांकि, वहाँ एक चेतावनी के बारे में पता होना है। चूंकि लुआ में तार अपरिवर्तनीय हैं, इसलिए प्रत्येक संयोजन एक नई स्ट्रिंग ऑब्जेक्ट बनाता है और स्रोत स्ट्रिंग्स से डेटा को प्रतिलिपि बनाता है। इससे एक स्ट्रिंग के लिए लगातार संगतता बहुत खराब प्रदर्शन करती है।

इस मामले के लिए लुआ मुहावरा कुछ इस तरह है:

function listvalues(s) 
    local t = { } 
    for k,v in ipairs(s) do 
     t[#t+1] = tostring(v) 
    end 
    return table.concat(t,"\n") 
end 

तार एकत्रित करके एक सरणी t में श्रेणीबद्ध किया जाना है, मानक पुस्तकालय दिनचर्या table.concat के साथ (उन सब ऊपर श्रेणीबद्ध करने के लिए इस्तेमाल किया जा सकता अनावश्यक स्ट्रिंग प्रतिलिपि के बिना प्रत्येक जोड़ी के बीच एक विभाजक स्ट्रिंग)।

अद्यतन: मैं सिर्फ देखा है कि मैं मूल रूप से pairs() बजाय ipairs() का उपयोग करके उपरोक्त कोड का टुकड़ा लिखा था।

मूल रूप से लिखा गया है, फ़ंक्शन listvalues() वास्तव में पारित तालिका से प्रत्येक मान का उत्पादन करेगा, लेकिन एक स्थिर या अनुमानित क्रम में नहीं। दूसरी तरफ, इसमें मूल्य शामिल होंगे जो कुंजी 1 से #s के दौरान सकारात्मक पूर्णांक नहीं थे। यही है pairs() करता है: यह तालिका में संग्रहीत प्रत्येक एकल (कुंजी, मान) जोड़ी उत्पन्न करता है।

ज्यादातर मामलों में जहां आप listvaluas() जैसे कुछ का उपयोग करेंगे, तो आप उनके आदेश को संरक्षित करने में रुचि रखते हैं। तो listvalues{13, 42, 17, 4} के रूप में लिखा गया एक कॉल उस क्रम में उन मान वाले स्ट्रिंग का उत्पादन करेगा।हालांकि, pairs() ऐसा नहीं करेगा, यह उन्हें कुछ आदेश में आइटम करेगा जो तालिका डेटा संरचना के अंतर्निहित कार्यान्वयन पर निर्भर करता है। यह ज्ञात है कि आदेश न केवल चाबियों पर निर्भर करता है, बल्कि उस क्रम पर भी जिसमें कुंजी डाली गई थी और अन्य कुंजियां हटा दी गई थीं।

बेशक ipairs() या तो एक सही उत्तर नहीं है। यह केवल तालिका के उन मानों को दर्शाता है जो "अनुक्रम" बनाते हैं। यही वह मान है, जिनकी चाबियाँ 1 से कुछ ऊपरी बाउंड तक फैली एक अखंड ब्लॉक बनाती हैं, जो आमतौर पर # ऑपरेटर द्वारा लौटाई गई मान है। (कई मामलों में, समारोह ipairs() ही बेहतर है एक सरल for पाश है कि बस #s करने के लिए 1 से गिना जाता है के द्वारा बदल दिया गया है। यह जहां सरल for पाश और अधिक कुशलता से ipairs() इटरेटर से लागू किया जा सकता लुआ 5.2 में और LuaJIT में सिफारिश की प्रथा है ।)

यदि pairs() वास्तव में सही दृष्टिकोण है, तो आमतौर पर यह मामला है कि आप दोनों कुंजी और मूल्य मुद्रित करना चाहते हैं। यह डेटा को आत्म-वर्णन करके आदेश के बारे में चिंताओं को कम करता है। बेशक, चूंकि किसी भी लुआ प्रकार (nil और फ़्लोटिंग पॉइंट NaN को छोड़कर) को एक कुंजी के रूप में उपयोग किया जा सकता है (और NaN को मूल्य के रूप में भी संग्रहीत किया जा सकता है) एक स्ट्रिंग प्रस्तुति को छात्र के लिए अभ्यास के रूप में छोड़ दिया जाता है। और पेड़ों और टेबल की जटिल संरचनाओं के बारे में मत भूलना।

Answer 2

स्ट्रिंग्स संयोजन ऑपरेटर का उपयोग एक साथ संयोजित किया जा सकता ".."

इस चर मुझे लगता है कि के लिए एक ही है

Answer 3

कड़ी:

लुआ में स्ट्रिंग संयोजन ऑपरेटर से दर्शाया जाता है दो बिंदु ('..')। यदि दोनों ऑपरेटिंग तार या संख्या हैं, तो वे §2.2.1 में उल्लिखित नियमों के अनुसार तारों में परिवर्तित हो जाते हैं। अन्यथा, "concat" मेटामाइट कहा जाता है (देखें §2.8)।

से: http://www.lua.org/manual/5.1/manual.html#2.5.4

Answer 4

तुम वहाँ ऑपरेटर .. की आशुलिपि संस्करण है कि क्या पूछ रहे हैं, तो - कोई वहाँ नहीं है। आप a ..= b नहीं लिख सकते हैं। आपको इसे पूर्ण रूप से टाइप करना होगा: filename = filename .. ".tmp"