प्रिंट और पुट में क्या अंतर है?

Question

उदाहरण के लिए इस कोड की लाइन में मैंने लिखा है, printऔर putsअलग-अलग परिणाम उत्पन्न करता है।

1.upto(1000).each { |i| print i if i % 2 == 0 }

Comments

यह भी देखें stackoverflow.com/questions/612258/... , stackoverflow.com/questions/1255324/p-vs-puts-in-ruby , और stackoverflow.com/questions/4415834/print-function-in-ruby

— Phrogz

Answer 1

puts प्रत्येक तर्क के अंत में एक नई पंक्ति जोड़ता है यदि कोई पहले से ही नहीं है।

print नई लाइन नहीं जोड़ता है।

---

उदाहरण के लिए:

puts [[1,2,3], [4,5,nil]] लौटूंगा:

1
2
3
4
5

जबकि print [[1,2,3], [4,5,nil]] लौटेगा:

[[१,२,३], [४,५, नील]]

ध्यान रखें कि प्रिंट करते समय शून्य मान आउटपुट कैसे नहीं करता है।

Comments

वास्तव में, प्रत्येक तर्क के बाद एक नई रूपरेखा। यह एक महत्वपूर्ण बिंदु है और रूबी डॉक्स से स्पष्ट नहीं है (क्योंकि उदाहरण में केवल 1 तर्क है)।

— cdunn2001

एक और बात है ... सरणी वर्ग का विस्तार करें और to_s विधि को ओवरराइड करें। पुट आपके नए वर्ग की किसी वस्तु के लिए नए to_s का उपयोग नहीं करता है जबकि प्रिंट करता है

— kapv89

irb का उपयोग करते हुए 0.9.5 डालता है ("a") और डालता है ("a \ n") का REPL पर बिल्कुल वही आउटपुट है।

— माक्र्स जुनियस ब्रूटस

@ kapv89 यह सच नहीं है: मैंने अभी-अभी कोशिश की है और दोनों ई प्रिंट विधि to_s पद्धति का उपयोग करते हैं। केवल p इसका उपयोग नहीं करता है।

— Collimarco

@Fronker, यह अभी भी सिर्फ एक तर्क है। संकलक आसन्न तारों को समेटता है।

— cdunn2001

Answer 2

यदि आप एरेज़ प्रदर्शित कर रहे हैं तो एक बड़ा अंतर है। खासकर एनआईएल वाले। उदाहरण के लिए:

print [nil, 1, 2]

देता है

[nil, 1, 2]

परंतु

puts [nil, 1, 2]

देता है

1
2

ध्यान दें, कोई दिखने वाली नील वस्तु (सिर्फ एक रिक्त रेखा) और प्रत्येक वस्तु अलग रेखा पर नहीं।

Comments

मैंने आज इस पर ध्यान दिया, जो मुझे यहां लाया। मैं उस सोच को जानना पसंद करूंगा। ऐसा लगता है कि इस तरह के सरणियों को संभालने के लिए पुट के लिए एक विशेष मामला है। आश्चर्य है कि तर्क क्या था ... क्या यह अन्य भाषाओं के अनुरूप होना है?

— दान बैरन

यह समझ में आता है क्योंकि पुट एक नई लाइन के साथ आउटपुट देगा, इसलिए आप इसके बारे में सोच सकते हैं कि यह एरे पर nil

— चलना

Answer 3

printप्रत्येक तर्क को, उसके बाद $,, को $stdout, उसके बाद आउटपुट देता है $\। के बराबर हैargs.join($,) + $\

putsसेट दोनों $,और $\के लिए "\ n" और उसके बाद के रूप में एक ही बात करता है print। महत्वपूर्ण अंतर यह है कि प्रत्येक तर्क एक नई रेखा है puts।

आप उपयोगकर्ता के अनुकूल नामों केrequire 'english' साथ उन वैश्विक चर का उपयोग कर सकते हैं ।

Comments

पर अच्छा टिप englishlib

— lacostenycoder

Answer 4

एपीआई डॉक्स कुछ अच्छे संकेत देते हैं:

print() → nil

print(obj, ...) → nil

दिए गए ऑब्जेक्ट (ओं) को ios को लिखता है । लौटता है nil।

लेखन के लिए धारा खोलनी होगी। प्रत्येक दी गई वस्तु जो एक स्ट्रिंग नहीं है उसे इसकी to_sविधि कहकर परिवर्तित किया जाएगा । जब तर्कों के बिना बुलाया जाता है, की सामग्री प्रिंट करता है $_।

यदि आउटपुट फ़ील्ड विभाजक ( $,) नहीं है nil, तो इसे ऑब्जेक्ट्स के बीच डाला जाता है। यदि आउटपुट रिकॉर्ड विभाजक ( $\) नहीं है nil, तो इसे आउटपुट में जोड़ा जाता है।

...

puts(obj, ...) → nil

दिए गए ऑब्जेक्ट (ओं) को ios को लिखता है । किसी के बाद एक नई पंक्ति लिखता है जो पहले से ही एक नए अनुक्रम के साथ समाप्त नहीं होती है। लौटता है nil।

लेखन के लिए धारा खोलनी होगी। यदि एक सरणी तर्क के साथ कहा जाता है, तो प्रत्येक तत्व को एक नई लाइन पर लिखता है। प्रत्येक दी गई वस्तु जो एक स्ट्रिंग या सरणी नहीं है, उसकी to_sविधि को कॉल करके परिवर्तित किया जाएगा । यदि तर्कों के बिना कहा जाता है, तो एक ही नई पंक्ति आउटपुट करती है।

ऊपर दिए गए बिंदुओं के साथ थोड़ा प्रयोग करने पर, अंतर प्रतीत होता है:

• कई तर्कों के साथ, printउन्हें 'आउटपुट फ़ील्ड सेपरेटर' द्वारा अलग किया जाता है $,(जो कि कुछ भी नहीं चूकता है) जबकि putsउन्हें नई सुर्खियों से अलग करता है। putsअंतिम तर्क के बाद एक नई पंक्ति भी डालता है, जबकि printऐसा नहीं करता है।

  2.1.3 :001 > print 'hello', 'world'
  helloworld => nil 
  2.1.3 :002 > puts 'hello', 'world'
  hello
  world
   => nil
  2.1.3 :003 > $, = 'fanodd'
   => "fanodd" 
  2.1.3 :004 > print 'hello', 'world'
  hellofanoddworld => nil 
  2.1.3 :005 > puts 'hello', 'world'
  hello
  world
   => nil

• putsस्वचालित रूप से अनपेक्स सरणियों, जबकि printनहीं है:

  २.१.३: ००१> प्रिंट [१, [२, ३]], [४]
  [१, [२, ३]] [४] => नील 
  २.१.३: ००२> पुट [१, [२, ३]], [४]
  1
  2
  3
  4
   => नील

• printकोई तर्क प्रिंट के साथ $_(आखिरी चीज़ जिसे पढ़ा जाता है gets), जबकि putsएक नई रेखा प्रिंट करता है:

  2.1.3 :001 > gets
  hello world
   => "hello world\n" 
  2.1.3 :002 > puts
  
   => nil 
  2.1.3 :003 > print
  hello world
   => nil

• printइस चर $\को putsअनदेखा करते हुए, जो भी प्रिंट करता है, उसके बाद आउटपुट रिकॉर्ड विभाजक लिखते हैं :

  mark@lunchbox:~$ irb
  2.1.3 :001 > $\ = 'MOOOOOOO!'
   => "MOOOOOOO!" 
  2.1.3 :002 > puts "Oink! Baa! Cluck! "
  Oink! Baa! Cluck! 
   => nil 
  2.1.3 :003 > print "Oink! Baa! Cluck! "
  Oink! Baa! Cluck! MOOOOOOO! => nil

Answer 5

putsto_sप्रत्येक तर्क का कॉल और प्रत्येक स्ट्रिंग में एक नई लाइन जोड़ता है, अगर यह नई लाइन के साथ समाप्त नहीं होता है। printबस उनके द्वारा कॉल करके प्रत्येक तर्क का उत्पादन करें to_s।

उदाहरण के लिए puts "one two":: one two

{नई पंक्ति}

puts "one two\n": one two

{new line} #puts परिणाम में एक नई रेखा नहीं जोड़ेगा, क्योंकि स्ट्रिंग एक नई रेखा के साथ समाप्त होती है

print "one two": one two

print "one two\n": one two

{नई पंक्ति}

और आउटपुट का एक और तरीका है: p

प्रत्येक ऑब्जेक्ट के लिए, सीधे obj.inspect लिखता है, उसके बाद प्रोग्राम के मानक आउटपुट के लिए एक नई लाइन।

यह डिबगिंग संदेश को आउटपुट करने में सहायक है। p "aa\n\t":aa\n\t

Answer 6

यदि आप स्ट्रिंग का उपयोग करके सरणी को आउटपुट करना चाहते हैं puts, तो आपको वही परिणाम मिलेगा जैसे आप उपयोग कर रहे थे print:

puts "#{[0, 1, nil]}":
[0, 1, nil]

लेकिन अगर एक उद्धृत स्ट्रिंग के साथ नहीं तो हाँ। एकमात्र अंतर नई लाइन के बीच है जब हम उपयोग करते हैं puts।

Comments

-1 दो कारणों से। सबसे पहले, स्पष्टता की कमी: मुझे समझ में नहीं आता है कि प्रारंभिक "लेकिन ..." यहां से आने के लिए क्या करना है, और न ही मैं समझता हूं कि अंतिम पैराग्राफ में "हां" क्या है। दूसरे, शुद्धता की कमी के लिए: आप कहते हैं कि अपने उदाहरण कोड के printfबजाय उपयोग करने से putsसमान परिणाम मिलेगा, लेकिन वास्तव में ऐसा नहीं होता है। putsसंस्करण अंत में एक नई पंक्ति कहते हैं, जबकि printfएक नहीं करता है, सिर्फ मामले में जहां कोई सरणी स्ट्रिंग में अंतर्वेशित वहाँ की तरह। (निश्चित रूप से, चूंकि स्ट्रिंग शाब्दिक का मूल्यांकन करते समय प्रक्षेप होता है।)

— मार्क अमेरी

अहा! अन्य उत्तरों को पढ़ने के बाद, मुझे लगता है कि मैं समझता हूँ - आपने इसका जवाब stackoverflow.com/a/14534145/1709587 पर दिया । किसी भी मामले में, यह वास्तव में अपने दम पर जवाब नहीं देता है।

— मार्क एमी