p vs रूबी में डालता है

Question

वहाँ के बीच कोई अंतर है pऔर putsरूबी में?

Answer 1

p foofoo.inspectएक न्यूलाइन के बाद प्रिंट , यानी यह inspectइसके बजाय के मूल्य को प्रिंट करता है to_s, जो डिबगिंग के लिए अधिक उपयुक्त है (क्योंकि आप इसके बीच अंतर को बता सकते हैं 1, "1"और "2\b1", जिसे आप बिना प्रिंट किए नहीं कर सकते हैं inspect)।

Comments

हां, पी (और पुट) दोनों कर्नेल मॉड्यूल में हैं ताकि आप यहां विवरण देख सकें: ruby-doc.org/core/classes/Kernel.html#M005961

— mikej

ध्यान दें कि pवस्तु का मूल्य भी लौटाता है, जबकि putsऐसा नहीं करता है। 1.9.3p125 :002 > (p "foo").class "foo" => String 1.9.3p125 :003 > (puts "foo").class foo => NilClass

— डैरेन चेंग

गैरेथ रीस द्वारा प्रदान किया गया महान सारांश "रूबी पी बनाम पुट बनाम प्रिंट" शीर्षक से ।

— अलेक्जेंडरसिंगटन

ऐसा महसूस होता है कि यह मुझे सवालों के एक खरगोश छेद के साथ छोड़ देता है। Whats का निरीक्षण? Whats to_s? मैं एक चर के बजाय मुद्रित पाठ का निरीक्षण क्यों करना चाहता हूं? आपके डीबगिंग, पी या पुट के उल्लेख के कारण प्रोग्रामिंग की दुनिया के लिए कौन सा मानक है? डिबगिंग के पूरा होने पर सभी "पी" को "पुट" से बदल दिया जाना चाहिए ?? मैं देखता हूं, एक उपरोक्त टिप्पणी में, पी एक वस्तु देता है, जो एक बड़ा अंतर है। मुझे यकीन नहीं है कि अगर यह जवाब पूरा हो जाता है, तो यह केवल एक छोटे से अंतर का उल्लेख करता है जो मूल प्रश्नों का जवाब देने वाले बड़े प्रश्नों को जन्म देगा।

@AaronLoften to_sरूबी में मानक-से-स्ट्रिंग विधि है। inspect। जैसा कि मैंने कहा, एक वैकल्पिक स्ट्रिंग पद्धति है, जो डिबगिंग के लिए अधिक उपयुक्त आउटपुट का उत्पादन करती है। डिबगिंग के पूरा होने पर आपको स्पष्ट रूप से अपने डिबगिंग स्टेटमेंट को हटा देना चाहिए (या अधिक गंभीर परियोजनाओं के लिए आपको संभवतः लॉगिंग फ्रेमवर्क का उपयोग करना चाहिए और डिबगिंग के लिए पी या पुट का उपयोग नहीं करना चाहिए)। तथ्य यह है कि pवस्तु लौटाता है ज्यादातर स्थितियों में अप्रासंगिक लगता है (और मुझे विश्वास है कि मैंने यह उत्तर दिया था इससे पहले कि यह मामला था)। आउटपुट में अंतर मुख्य अंतर है (और केवल एक ही हुआ करता था)।

— sepp2k

Answer 2

यह नोट करना भी महत्वपूर्ण है कि puts"एक वर्ग को" प्रतिक्रिया करता है to_sजिसे परिभाषित किया गया है, pनहीं। उदाहरण के लिए:

class T
   def initialize(i)
      @i = i
   end
   def to_s
      @i.to_s
   end
end

t = T.new 42
puts t   => 42
p t      => #<T:0xb7ecc8b0 @i=42>

यह .inspectकॉल से सीधे आता है , लेकिन व्यवहार में स्पष्ट नहीं है।

Answer 3

p foo के समान है puts foo.inspect

Comments

लेकिन putsवापसी करता है nil, के बजाय के fooरूप में करता है p।

— रिबमार

यह गलत है। यह उसी तरह हैputs foo.inspect; foo

— एरिक डुमिनील

यह साबित करता है कि आप जवाब दे रहे हैं गलत है (-> {p "Hello World"}.call) == (-> {puts "Hello World".inspect}.call ) :। कई upvotes यह एक अच्छा जवाब नहीं है!

— लैकोस्टेनकोडर

Answer 4

उपरोक्त उत्तरों के अलावा, कंसोल आउटपुट में एक सूक्ष्म अंतर है - अर्थात् उल्टे अल्पविराम / उद्धरण चिह्नों की उपस्थिति / अनुपस्थिति - जो उपयोगी हो सकते हैं:

p "+++++"
>> "+++++"

puts "====="
>> =====

यदि आप एक साधारण प्रगति पट्टी बनाना चाहते हैं तो मुझे यह उपयोगी लगता है, उनके करीबी रिश्तेदार का उपयोग करके, प्रिंट करें :

array = [lots of objects to be processed]
array.size
>> 20

यह 100% प्रगति बार देता है:

puts "*" * array.size
>> ********************

और यह प्रत्येक पुनरावृत्ति पर एक वृद्धिशील * जोड़ता है:

array.each do |obj|
   print "*"
   obj.some_long_executing_process
end

# This increments nicely to give the dev some indication of progress / time until completion
>> ******

Answer 5

से माणिक 2.4.1 दस्तावेज़

डालता है

puts(obj, ...) → nil

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

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

आइए इसे आइबीआर पर आजमाएं

# always newline in the end 
>> puts # no arguments

=> nil # return nil and writes a newline
>> puts "sss\nsss\n" # newline in string
sss
sss
=> nil
>> puts "sss\nsss" # no newline in string
sss
sss
=> nil

# for multiple arguments and array
>> puts "a", "b"
a
b
=> nil
>> puts "a", "b", ["c", "d"]
a
b
c
d
=> nil

पी

p(obj) → obj click to toggle source
p(obj1, obj2, ...) → [obj, ...] p() → nil
प्रत्येक ऑब्जेक्ट के obj.inspectलिए, प्रोग्राम के मानक आउटपुट में एक नई पंक्ति के बाद सीधे लिखते हैं ।

in irb

# no arguments
>> p
=> nil # return nil, writes nothing
# one arguments
>> p "sss\nsss\n" 
"sss\nsss\n"
=> "aaa\naaa\n"
# multiple arguments and array
>> p "a", "b"
"a"
"b"
=> ["a", "b"] # return a array
>> p "a", "b", ["c", "d"]
"a"
"b"
["c", "d"]
=> ["a", "b", ["c", "d"]] # return a nested array

Answer 6

ये 2 बराबर हैं:

p "Hello World"  
puts "Hello World".inspect

( निरीक्षण to_s विधि की तुलना में वस्तु का अधिक शाब्दिक दृश्य देता है )

Comments

वे बराबर लगते हैं, लेकिन वे नहीं हैं। इसे आज़माएँ:(->{p "Hello World"}.call) == (-> {puts "Hello World".inspect}.call )

— लैकोस्टेनकोडर

Answer 7

यह उन प्रमुख अंतरों में से एक का वर्णन कर सकता है जो यह है कि जो pइसके लिए पारित किया गया है, उसका putsरिटर्न कहां है nil।

def foo_puts
  arr = ['foo', 'bar']
  puts arr
end

def foo_p
  arr = ['foo', 'bar']
  p arr
end

a = foo_puts
=>nil
a
=>nil

b = foo_p
=>['foo', 'bar']
b
['foo', 'bar']

बेंचमार्क शो putsधीमा है

require 'benchmark'
str = [*'a'..'z']
str = str*100
res = Benchmark.bm do |x|
  x.report(:a) { 10.times {p str} }
  x.report(:b) { 10.times {puts str} }
end
puts "#{"\n"*10}"
puts res

0.010000   0.000000   0.010000 (  0.047310)
0.140000   0.090000   0.230000 (  0.318393)