मेरे पास कोड है:
def make_all_thumbs(source)
sizes = ['1000','1100','1200','800','600']
threads = []
sizes.each do |s|
threads << Thread.new(s) {
create_thumbnail(source+'.png', source+'-'+s+'.png', s)
}
end
end
क्या <<मतलब है?
जवाबों:
'<<' एक साधारण विधि के रूप में
ज्यादातर मामलों में '<<' बाकी की तरह परिभाषित की गई विधि है, आपके मामले में इसका मतलब है "इस सरणी के अंत में जोड़ें" ( यहां भी देखें )।
यह आपके विशेष मामले में है, लेकिन कई अन्य अवसर भी हैं जहां आप "<<" विधि का सामना करेंगे। मैं इसे 'ऑपरेटर' नहीं कहूंगा क्योंकि यह वास्तव में एक ऐसी विधि है जो किसी वस्तु पर परिभाषित है जिसे आपके द्वारा ओवरराइड किया जा सकता है या अपनी खुद की वस्तुओं के लिए कार्यान्वित किया जा सकता है। '<<' के अन्य मामले
सिंगलटन वर्ग परिभाषा;
फिर कार्यक्रम प्रवाह के भीतर वर्तमान स्कोप (= स्वयं का परिवर्तन) की रहस्यमय पारी है:
class A
class << self
puts self # self is the singleton class of A
end
end
a = A.new
class << a
puts self # now it's the singleton class of object a
end
रहस्य class << selfने मुझे आश्चर्यचकित कर दिया और वहां के आंतरिक लोगों के बारे में जांच की। जबकि मेरे द्वारा बताए गए सभी उदाहरणों <<में वास्तव में एक वर्ग में परिभाषित एक विधि है, अर्थात
obj << stuff
के बराबर है
obj.<<(stuff)
class << selfनिर्माण (या किसी भी स्वयं के स्थान पर वस्तु) को सही मायने में अलग है। यह वास्तव में ही भाषा, CRuby में उस में परिभाषित किया है की अंतर्निहित सुविधा है parse.y के रूप में
k_class tLSHFT expr
जहाँ tLSHFT एक '<<' टोकन है, k_class 'क्लास' कीवर्ड है और expr एक मनमाना अभिव्यक्ति है। यही है, आप वास्तव में लिख सकते हैं
class << <any expression>
और अभिव्यक्ति के परिणाम के सिंगलटन वर्ग में 'स्थानांतरित' हो जाएगा। TLSHFT अनुक्रम को 'NODE_SCLASS' अभिव्यक्ति के रूप में पार्स किया जाएगा, जिसे एक सिंगलटन क्लास परिभाषा (cf. node.c) कहा जाता है
case NODE_SCLASS:
ANN("singleton class definition");
ANN("format: class << [nd_recv]; [nd_body]; end");
ANN("example: class << obj; ..; end");
F_NODE(nd_recv, "receiver");
LAST_NODE;
F_NODE(nd_body, "singleton class definition");
break;
यहाँ दस्तावेज़
और, मैं उन लोगों को कैसे भूल सकता हूं, यहां दस्तावेज़ '<<' का एक तरह से उपयोग करते हैं जो फिर से पूरी तरह से अलग है। आप एक स्ट्रिंग को परिभाषित कर सकते हैं जो आसानी से घोषित करके कई लाइनों पर फैल जाती है
here_doc = <<_EOS_
The quick brown fox jumps over the lazy dog.
...
_EOS_
'यहाँ डॉक्टर ऑपरेटर' को भेद करने के लिए एक मनमाने ढंग से स्ट्रिंग सीमांकक को तुरंत '<<' का पालन करना होगा। सब कुछ उस प्रारंभिक सीमांकक और उसी परिसीमन की दूसरी घटना अंतिम स्ट्रिंग का हिस्सा होगा। '<< -' का उपयोग करना भी संभव है, अंतर यह है कि उत्तरार्द्ध का उपयोग किसी भी अग्रणी या अनुगामी व्हाट्सएप की उपेक्षा करेगा।
सरणी के अंत में मान को जोड़ने के लिए अधिकतर सरणियों में उपयोग किया जाता है।
a = ["orange"]
a << "apple"
puts a
यह देता है
["नारंगी", "सेब"]परिणाम।
यह ऑपरेटर है जो आपको नई वस्तुओं को जोड़कर , मौजूदा सरणियों को खिलाने की अनुमति देता है ।
ऊपर दिए गए उदाहरण में आप केवल threads5 नए थ्रेड्स के साथ खाली सरणी को आबाद कर रहे हैं।
'a << b' का अर्थ है a के अंत में संलग्न b
माणिक में आपके पास हमेशा चीजों को करने का एक तरीका होता है। तो, रूबी के पास सामान्य विधि के नाम के लिए कुछ अच्छे शॉर्टकट हैं। जैसे यह एक .push के लिए है .push विधि नाम लिखने के बजाय, आप बस <<, कॉन्टेक्टेशन ऑपरेटर का उपयोग कर सकते हैं। वास्तव में कुछ मामलों में आप इनमें से किसी भी एक ही ऑपरेशन के लिए उपयोग कर सकते हैं। Push और + << के साथ।
जैसे आप इस उदाहरण में देख सकते हैं:
alphabet = ["a", "b", "c"]
alphabet << "d" # Update me!
alphabet.push("e") # Update me!
print alphabet
caption = "the boy is surrounded by "
caption << "weezards!" # Me, too!
caption += " and more. " # Me, too!
# .push can no be uses for concatenate
print caption
तो आप देखिए परिणाम है:
["a", "b", "c", "d", "e"]
the boy is surrounded by weezards! and more.
आप किसी सरणी में किसी तत्व को धकेलने के लिए या किसी स्ट्रिंग को दूसरे में पहुंचाने के लिए ऑपरेटर << का उपयोग कर सकते हैं।
इसलिए, यह जो कर रहा है वह एक नया तत्व / ऑब्जेक्ट थ्रेड प्रकार बना रहा है और इसे सरणी में धकेल रहा है।
threads << Thread.new(s) {
create_thumbnail(source+'.png', source+'-'+s+'.png', s)
}
रूबी '<<' ऑपरेटर के लिए मूल रूप से उपयोग किया जाता है:
सरणी में मान (अंतिम स्थिति में) लागू करना
[२, ४, ६] << will यह देगा [२, ४, ६,,]
यह माणिक में कुछ सक्रिय रिकॉर्ड संचालन के लिए भी उपयोग किया जाता है। उदाहरण के लिए हमारे पास कार्ट और लाइन इटेम मॉडल है जिसे कार्ट has_many line_items से संबद्ध किया गया है। Cart.find (ए) .line_items ActiveRecord :: पंक्ति आइटम के साथ संबद्धता ऑब्जेक्ट जो कार्ट 'A' से संबंधित है, वापस करेगा।
अब, एक और लाइन_इटेम (एक्स) को कार्ट (ए) में जोड़ने (या कहने के लिए),
Cart.find(A).line_items << LineItem.find(X)
अब उसी लाइन 'A' में एक और LineItem जोड़ने के लिए, लेकिन इस बार हम कोई भी लाइन_आइटम ऑब्जेक्ट नहीं बनाने जा रहे हैं (मेरा मतलब है कि एक्टिवरकॉर्ड ऑब्जेक्ट मैन्युअल रूप से नहीं बनाएंगे)
Cart.find (ए) .line_items << LineItem.new
ऊपर दिए गए कोड में << ऑब्जेक्ट को सेव किया जाएगा और इसे लेफ्ट साइड एक्टिव रिकॉर्ड एसोसिएशन एरे में जोड़ा जाएगा।
और कई अन्य जो पहले से ही उपरोक्त उत्तरों में शामिल हैं।
इसके अलावा, रूबी 2.6 के बाद से, <<विधि को भी परिभाषित किया गया है Proc।
प्रोक # << दो या दो से अधिक गद्यों की रचना करने की अनुमति देता है।