क्या रूबी में एकल उद्धरण बनाम दोहरे उद्धरण चिह्नों का उपयोग करने में प्रदर्शन लाभ है?

Question

क्या आपको पता है कि माणिक में एकल उद्धरणों के बजाय दोहरे उद्धरण चिह्नों का उपयोग करने से माणिक 1.8 और 1.9 में किसी भी सार्थक तरीके से प्रदर्शन कम हो जाता है।

अगर मैं टाइप करता हूँ

question = 'my question'

क्या यह इससे तेज है

question = "my question"

मुझे लगता है कि रूबी यह पता लगाने की कोशिश करती है कि किसी चीज का मूल्यांकन किया जाना चाहिए, जब वह दोहरे उद्धरणों का सामना करती है और संभवत: कुछ चक्रों को खर्च करती है।

Comments

इसे डेढ़ लाख बार चलाएं और देखें। संभावना है, आपकी साइट को मामले में लगभग पर्याप्त ट्रैफ़िक नहीं मिलता है। समय-समय पर अनुकूलन आमतौर पर इसके लायक नहीं है।

— ceejayoz 22

क्यों बहुत से लोग रूबी को केवल वेब प्रोग्रामिंग के लिए इस्तेमाल करने की उम्मीद करते हैं?

— जोहान्स

मैं इस समयपूर्व अनुकूलन पर विचार नहीं करूंगा। आपके एप्लिकेशन के पूर्ण होने के बाद वापस जाने और "सिंगल या डबल 'के लिए अनुकूलन करने के बाद से एक" सर्वोत्तम अभ्यास "का एक बड़ा सिरदर्द होगा।

— उमर

मेरे लिए यह सिर्फ शैली है: मैं अन्य मामलों में 'स्टेटिक' स्ट्रिंग्स और डबल qoutes (या अन्य प्रक्षेपित स्ट्रिंग्स) के लिए सिंगल कोट्स का उपयोग करता हूं।

— बाघ

यदि आप एक समस्या है जो मौजूद नहीं है का अनुकूलन कर रहे हैं तो @Baddie: यह समयपूर्व अनुकूलन है।

— एंडी लेस्टर

Answer 1

$ ruby -v
ruby 1.9.3p0 (2011-10-30 revision 33570) [x86_64-darwin11.0.0]

$ cat benchmark_quotes.rb
# As of Ruby 1.9 Benchmark must be required
require 'benchmark'

n = 1000000
Benchmark.bm(15) do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
end

$ ruby benchmark_quotes.rb 

                      user     system      total        real
assign single     0.110000   0.000000   0.110000 (  0.116867)
assign double     0.120000   0.000000   0.120000 (  0.116761)
concat single     0.280000   0.000000   0.280000 (  0.276964)
concat double     0.270000   0.000000   0.270000 (  0.278146)

नोट: मैंने इसे नए रूबी संस्करणों के साथ काम करने के लिए इसे अपडेट किया है, और हेडर को साफ किया है, और एक तेज सिस्टम पर बेंचमार्क चलाता है।

यह उत्तर कुछ प्रमुख बिंदुओं को छोड़ देता है। विशेष रूप से प्रक्षेप के संबंध में इन अन्य उत्तरों को देखें और एकल बनाम दोहरे उद्धरण चिह्नों का उपयोग करते समय प्रदर्शन में कोई महत्वपूर्ण अंतर नहीं है ।

Comments

क्या मैं परिणामों की सही व्याख्या कर रहा हूं? दोहरे उद्धरण चिह्नों का उपयोग करना वास्तव में एकल की तुलना में तेज है? यह कैसे हो सकता है?

— बेतरतीब ढंग से

जाहिरा तौर पर हाँ, हालांकि अंतर मामूली है। जैसा कि क्यों - मुझे धड़कता है।

— zetetic

यदि यह संकलन समय के साथ-साथ निष्पादन समय भी लिया जाए तो यह बेंचमार्क बहुत अधिक सम्मोहक होगा।

— 3

मापा मतभेद सार्थक नहीं हैं। बस आदेश (कचरा संग्रह के कारण) महत्वपूर्ण अंतर ला सकता है। उनके बीच कोई रनटाइम अंतर नहीं है 'और "वे एक ही चीज़ के लिए तैयार हैं।

— मार्क-आंद्रे लाफ्यून

Answer 2

सारांश: कोई गति अंतर नहीं; यह महान सहयोगी रूबी शैली गाइड संगत होने की सलाह देता है। मैं अब उपयोग करता हूं 'string'जब तक कि प्रक्षेप की आवश्यकता नहीं होती है (गाइड में विकल्प ए) और इसे पसंद करते हैं, लेकिन आप आमतौर पर अधिक कोड देखेंगे "string"।

विवरण:

सैद्धांतिक रूप से, यह तब फर्क कर सकता है जब आपका कोड पार्स हो , लेकिन न केवल आपको सामान्य रूप से पार्स समय की परवाह नहीं करनी चाहिए (निष्पादन समय की तुलना में नगण्य), आप इस मामले में एक महत्वपूर्ण अंतर नहीं पा सकेंगे।

महत्वपूर्ण बात यह है कि जब निष्पादित किया जाता है तो यह बिल्कुल वैसा ही होगा ।

बेंचमार्किंग केवल यह समझने की कमी दिखाती है कि रूबी कैसे काम करती है। दोनों मामलों में, तार एक tSTRING_CONTENT( स्रोतparse.y देखें ) में पार्स हो जाएगा । दूसरे शब्दों में, सीपीयू जब बनाने में ठीक उसी संचालन के माध्यम से जाना होगा 'string'या "string"। ठीक उसी बिट्स को ठीक उसी तरह से फ्लिप किया जाएगा। बेंचमार्किंग यह केवल उन अंतरों को दिखाएगा जो महत्वपूर्ण नहीं हैं और अन्य कारकों (जीसी किकिंग आदि) के कारण हैं; याद रखें, इस मामले में कोई अंतर नहीं हो सकता है! इन जैसे माइक्रो बेंचमार्क सही होना मुश्किल है। इसके fruityलिए एक अच्छे उपकरण के लिए मेरा रत्न देखें ।

ध्यान दें कि यदि फॉर्म का इंटरपोलेशन है "...#{...}...", तो यह एक tSTRING_DBEGए और फाइनल tSTRING_DVARमें प्रत्येक एक्सप्रेशन के लिए , एक पार्स हो जाता है । यह केवल तभी होता है जब प्रक्षेप होता है, हालांकि, जो ओपी के बारे में नहीं है।#{...}tSTRING_DEND

मैं आपको हर जगह दोहरे उद्धरण चिह्नों का उपयोग करने का सुझाव देता था ( #{some_var}बाद में इसे वास्तव में जोड़ना आसान बनाता है ), लेकिन मैं अब एकल उद्धरणों का उपयोग करता हूं जब तक कि मुझे प्रक्षेप की आवश्यकता नहीं होती है \n, आदि ... मुझे यह नेत्रहीन पसंद है और यह थोड़ा अधिक स्पष्ट है, क्योंकि वहाँ कोई नहीं है यह देखने के लिए स्ट्रिंग को पार्स करने की आवश्यकता है कि क्या इसमें कोई अभिव्यक्ति है।

Comments

लगता है कि मिनट के प्रदर्शन में अंतर अधिक महत्वपूर्ण है। डबल उद्धरण यह है!

— वेंकट डी।

आपके जवाब पर मुझे इशारा करने के लिए धन्यवाद। क्या आप स्पष्ट कर सकते हैं कि आप क्यों कह रहे हैं कि यह मानदंड भ्रामक है? मैं मानता हूं कि मतभेद शायद नगण्य हैं लेकिन क्या बेंचमार्क किसी तरह गलत है? (किसी ने पहले ही हाइलाइट कर दिया #{n}होगा-नंबर रूपांतरण कर रहा होगा)। क्या यह पार्सिंग में अंतर नहीं दिखा रहा है?

— 21

स्टाइल गाइड से जोड़ने के लिए धन्यवाद। विश्वास नहीं कर सकता कि मैं इससे पहले नहीं आया था।

— 21

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

— philtr

दोहरे उद्धरण चिह्नों का उपयोग करें। प्रोग्रामिंग कठिन है। सिंटेक्स स्वाभाविक रूप से जटिल है। डबल कोट्स का अर्थ है कभी भी गलती न करना या किसी स्ट्रिंग को गतिशील बनाते समय त्रुटि के साथ समय बर्बाद करना। दोहरे उद्धरण चिह्नों के साथ, आपके पास सोचने के लिए एक कम चीज है।

— केल्सी हन्नान

Answer 3

हालांकि किसी ने संघनन बनाम प्रक्षेप को मापने के लिए नहीं हुआ:

$ ruby -v
ruby 1.8.7 (2008-08-11 patchlevel 72) [i686-darwin9.6.2]
$ cat benchmark_quotes.rb
require 'benchmark'
n = 1000000
Benchmark.bm do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("assign interp") { n.times do; c = "a string #{'b string'}"; end}
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
end

$ ruby -w benchmark_quotes.rb 
      user     system      total        real
assign single  2.600000   1.060000   3.660000 (  3.720909)
assign double  2.590000   1.050000   3.640000 (  3.675082)
assign interp  2.620000   1.050000   3.670000 (  3.704218)
concat single  3.760000   1.080000   4.840000 (  4.888394)
concat double  3.700000   1.070000   4.770000 (  4.818794)

विशेष रूप से, नोट assign interp = 2.62बनाम concat single = 3.76। केक पर टुकड़े के रूप में, मैं 'a' + var + 'b'विशेष रूप से रिक्त स्थान के संबंध में अधिक पठनीय होने के लिए प्रक्षेप का पता लगाता हूं ।

Comments

+1। यह एकमात्र प्रक्षेप बेंचमार्क है जो सेब के साथ सेब की तुलना कर रहा है।

— मार्क थॉमस

बेंचमार्किंग भ्रामक हो सकती है; क्यों के लिए मेरा जवाब देखें। समवर्ती और प्रक्षेप के बीच तुलना के लिए, यह स्पष्ट होना चाहिए कि प्रक्षेप, संघनन की तुलना में धीमा नहीं हो सकता है। किसी भी मामले में, यह वास्तव में सवाल का हिस्सा नहीं है!

— मार्क-आंद्रे लाफ्यून

क्या आप इस परीक्षण में << जोड़ सकते हैं?

— निक

Answer 4

कोई अंतर नहीं - जब तक आप #{some_var}स्टाइल स्ट्रिंग इंटरपोलेशन का उपयोग नहीं कर रहे हैं । लेकिन आप केवल प्रदर्शन हिट प्राप्त करते हैं यदि आप वास्तव में ऐसा करते हैं।

Zetetic के उदाहरण से संशोधित :

require 'benchmark'
n = 1000000
Benchmark.bm do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("assign interp") { n.times do; c = "a #{n} string"; end}  
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
  x.report("concat interp") { n.times do; "a #{n} string " + "b #{n} string"; end}
end

उत्पादन

               user       system     total    real
assign single  0.370000   0.000000   0.370000 (  0.374599)
assign double  0.360000   0.000000   0.360000 (  0.366636)
assign interp  1.540000   0.010000   1.550000 (  1.577638)
concat single  1.100000   0.010000   1.110000 (  1.119720)
concat double  1.090000   0.000000   1.090000 (  1.116240)
concat interp  3.460000   0.020000   3.480000 (  3.535724)

Comments

दिलचस्प। प्रक्षेप अधिक महंगा लगता है। क्या यह 1.8 था? यह देखना अच्छा होगा कि 1.9 कुछ बदलता है या नहीं।

— ज़ेटैटिक

zetetic - यूप। यह रूबी

— १. mad.

इंटरप वर्जन इंटरपोलिंग और कॉन्कैटनेटिंग प्लस है जो एक संख्या को दो बार स्ट्रिंग में परिवर्तित करता है। यदि आप परिणाम समान बनाते हैं तो इंटरपोलेशन जीत जाता है। Gist.github.com/810463 देखें । वास्तविक टेकअवे को एकल या दोहरे उद्धरण चिह्नों के बारे में अधिक चिंता करना है।

— ब्रायन डिटर्जिंग

बेंचमार्किंग केवल यह भ्रामक हो सकती है और रूबी के काम करने की गलतफहमी को दर्शाता है। मेरा जवाब देखिए।

— मार्क-आंद्रे लैफट्यून

Answer 5

सिंगल कोट्स दोहरे उद्धरण चिह्नों की तुलना में बहुत तेज़ हो सकते हैं क्योंकि लेक्सर को #{}प्रक्षेप मार्करों के लिए जांचना नहीं है । कार्यान्वयन पर निर्भर करता है, आदि ध्यान दें कि यह एक पार्स-टाइम लागत है, न कि रन-टाइम लागत।

उस ने कहा, वास्तविक प्रश्न यह था कि क्या दोहरे उद्धरण चिह्नों का उपयोग करने से "किसी भी सार्थक तरीके से प्रदर्शन में कमी आती है", जिसका उत्तर निर्णायक "नहीं" है। प्रदर्शन में अंतर इतना अविश्वसनीय रूप से छोटा है कि यह किसी भी वास्तविक प्रदर्शन चिंताओं की तुलना में पूरी तरह से महत्वहीन है। अपना समय बर्बाद मत करो।

वास्तविक प्रक्षेप निश्चित रूप से एक अलग कहानी है। 'foo'की तुलना में लगभग 1 सेकंड तेज होगा "#{sleep 1; nil}foo"।

Comments

+1 यह ध्यान देने के लिए कि लागत संकलित समय पर है, न कि रन समय पर, इसलिए ऊपर दिया गया अत्यधिक बेंचमार्क-आधारित उत्तर गलत संदेश दे रहे हैं।

— 20

"यह एक पार्स-टाइम कॉस्ट है, रन-टाइम कॉस्ट नहीं।" प्रमुख वाक्यांश है।

— टीन मैन

Answer 6

सिंगल कोट्स की तुलना में डबल कोट्स कई महत्वपूर्ण स्ट्राइक लेते हैं। मैं हमेशा जल्दी में हूं। मैं सिंगल कोट्स का इस्तेमाल करता हूं। :) और हाँ, मुझे लगता है कि एक "प्रदर्शन लाभ"। :)

Comments

दोहरे उद्धरण 2x को प्रमुख हमले क्यों कहेंगे? वे दोनों एक ही कुंजी द्वारा दर्शाए गए हैं। इसके अतिरिक्त, कई IDE समापन उद्धरण (ओं) को स्वचालित रूप से जोड़ते हैं।

— मैट ड्रेसल

भले ही आईडीई स्वचालित रूप से बोली बंद कर देता है, दोहरे उद्धरण चिह्नों को अभी भी 100% अधिक महत्वपूर्ण स्ट्राइक की आवश्यकता होती है। ;-)

— क्लिंट पाच

मैट ड्रेसल: डबल कोट्स को दो बार कुंजी स्ट्राइक की आवश्यकता होती है क्योंकि आपको शिफ्ट की भी स्ट्राइक करनी होती है। ओह: :) बस अगर आप इसे मेरी मूल टिप्पणी में चूक गए। :) कॉर्डेड कुंजियों को निष्पादित करने के लिए अधिक प्रयास और यकीनन, अधिक समय की आवश्यकता होती है। :)

— aqn

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

— हालिल Özgür

"मैं जल्दी में एक आदमी हूं" - जब तक आप शिफ्ट और 2 दबाते हैं (या जो कभी अन्य कुंजी होती है) एक के बाद एक आप किसी भी समय किसी भी समय को एकल उद्धरण का उपयोग करके नहीं बचाते हैं।

— मचिसुइजी

Answer 7

मैंने सोचा कि मैं 1.8.7 और 1.9.2 की तुलना जोड़ूंगा। मैंने उन्हें कुछ बार दौड़ाया। वेरिएंट + -0.01 के बारे में था।

require 'benchmark'
n = 1000000
Benchmark.bm do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("assign interp") { n.times do; c = "a #{n} string"; end}
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
  x.report("concat interp") { n.times do; "a #{n} string " + "b #{n} string"; end}
end

रूबी 1.8.7 (2010-08-16 पैचवेल 302) [x86_64-linux]

assign single  0.180000   0.000000   0.180000 (  0.187233)
assign double  0.180000   0.000000   0.180000 (  0.187566)
assign interp  0.880000   0.000000   0.880000 (  0.877584)
concat single  0.550000   0.020000   0.570000 (  0.567285)
concat double  0.570000   0.000000   0.570000 (  0.570644)
concat interp  1.800000   0.010000   1.810000 (  1.816955)

---

माणिक 1.9.2p0 (2010-08-18 संशोधन 29036) [x86_64-linux]

  user          system      total      real
assign single  0.140000   0.000000   0.140000 (  0.144076)
assign double  0.130000   0.000000   0.130000 (  0.142316)
assign interp  0.650000   0.000000   0.650000 (  0.656088)
concat single  0.370000   0.000000   0.370000 (  0.370663)
concat double  0.370000   0.000000   0.370000 (  0.370076)
concat interp  1.420000   0.000000   1.420000 (  1.412210)

Comments

Interp को स्ट्रिंग रूपांतरण के लिए नंबर करना है। Gist.github.com/810463 देखें ।

— ब्रायन डिटर्जिंग

मेरा जवाब देखें कि आपको ये नंबर क्यों मिले।

— मार्क-एंड्रे लाफ्यून

Interp पर अच्छी बात है। मैंने अभी पिछले उत्तर को एक आधार के रूप में कॉपी किया है। वह मुझे सिखा देंगे।

— फिल्ट

Answer 8

दोनों दिशाओं में कोई महत्वपूर्ण अंतर नहीं है। यह बात के लिए यह बहुत बड़ा होगा।

ऐसे समय को छोड़कर जब आप सुनिश्चित हों कि समय के साथ कोई वास्तविक समस्या है, प्रोग्रामर मेंटेनेंस के लिए ऑप्टिमाइज़ करें।

मशीन के समय की लागत बहुत कम है। कोड लिखने और इसे बनाए रखने के लिए प्रोग्रामर समय की लागत बहुत बड़ी है।

सेकेंड बचाने के लिए ऑप्टिमाइज़ेशन कितना अच्छा है, हजारों रन के मिनट भी अगर इसका मतलब है कि कोड बनाए रखना मुश्किल है?

एक शैली के साथ चुनें और उसके साथ रहें लेकिन रनटाइम के सांख्यिकीय महत्वहीन मिलीसेकंड के आधार पर उस शैली को न चुनें।

Answer 9

मुझे भी लगा कि रूबी के लिए सिंगल कोटेड स्ट्रिंग्स पार्स करने की जल्दी हो सकती है। यह मामला प्रतीत नहीं होता है।

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

generate.rb: 
10000.times do
  ('a'..'z').to_a.each {|v| print "#{v}='This is a test string.'\n" }
end

#Generate sample ruby code with lots of strings to parse
$ ruby generate.rb > single_q.rb
#Get the double quote version
$ tr \' \" < single_q.rb > double_q.rb

#Compare execution times
$ time ruby single_q.rb 

real    0m0.978s
user    0m0.920s
sys     0m0.048s
$ time ruby double_q.rb 

real    0m0.994s
user    0m0.940s
sys     0m0.044s

बार-बार रन बनाने से ज्यादा फर्क नहीं पड़ता। यह अभी भी स्ट्रिंग के किसी भी संस्करण को पार्स करने के लिए बहुत अधिक समय लेता है।

Answer 10

यह कार्यान्वयन के आधार पर निश्चित रूप से संभव है, लेकिन दुभाषिया के स्कैनिंग भाग को केवल प्रत्येक चरित्र को एक बार देखना चाहिए। इसे # {} ब्लॉकों को संभालने के लिए बस एक अतिरिक्त राज्य (या राज्यों के संभावित सेट) और संक्रमण की आवश्यकता होगी।

एक टेबल आधारित स्कैनर में, संक्रमण को निर्धारित करने के लिए एक ही लुकअप होने जा रहा है, और प्रत्येक चरित्र वैसे भी हो रहा होगा।

जब पार्सर को स्कैनर आउटपुट प्राप्त होता है, तो यह पहले से ही ज्ञात है कि इसे ब्लॉक में कोड को विकसित करना होगा। इसलिए ओवरहेड वास्तव में # {} ब्लॉक को संभालने के लिए स्कैनर / पार्सर में केवल मेमोरी ओवरहेड है, जिसे आप किसी भी तरह से भुगतान करते हैं।

जब तक मैं कुछ याद कर रहा हूँ (या संकलक निर्माण विवरण को गलत बता रहा है), जो निश्चित रूप से संभव है :)

Answer 11

~ > ruby -v   
jruby 1.6.7 (ruby-1.8.7-p357) (2012-02-22 3e82bc8) (Java HotSpot(TM) 64-Bit Server VM 1.6.0_37) [darwin-x86_64-java]
~ > cat qu.rb 
require 'benchmark'

n = 1000000
Benchmark.bm do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
end
~ > ruby qu.rb
      user     system      total        real
assign single  0.186000   0.000000   0.186000 (  0.151000)
assign double  0.062000   0.000000   0.062000 (  0.062000)
concat single  0.156000   0.000000   0.156000 (  0.156000)
concat double  0.124000   0.000000   0.124000 (  0.124000)

Answer 12

एक तुम सब छूट गए।

यहां डॉ

इसे इस्तेमाल करे

require 'benchmark'
mark = <<EOS
a string
EOS
n = 1000000
Benchmark.bm do |x|
  x.report("assign here doc") {n.times do;  mark; end}
end

इससे मुझे मिला

`asign here doc  0.141000   0.000000   0.141000 (  0.140625)`

तथा

'concat single quotes  1.813000   0.000000   1.813000 (  1.843750)'
'concat double quotes  1.812000   0.000000   1.812000 (  1.828125)'

इसलिए यह निश्चित रूप से उन सभी पुट को लिखने और लिखने से बेहतर है।

मैं रूबी को एक दस्तावेज़ हेरफेर भाषा की तर्ज पर अधिक पढ़ाया जाना चाहूंगा।

आखिरकार, क्या हम वास्तव में रेल, सिनात्रा और रनिंग टेस्ट में ऐसा नहीं करते हैं?

Answer 13

मैंने टिम स्नोहाइट का जवाब दिया।

require 'benchmark'
n = 1000000
attr_accessor = :a_str_single, :b_str_single, :a_str_double, :b_str_double
@a_str_single = 'a string'
@b_str_single = 'b string'
@a_str_double = "a string"
@b_str_double = "b string"
@did_print = false
def reset!
    @a_str_single = 'a string'
    @b_str_single = 'b string'
    @a_str_double = "a string"
    @b_str_double = "b string"
end
Benchmark.bm do |x|
    x.report('assign single       ') { n.times do; c = 'a string'; end}
    x.report('assign via << single') { c =''; n.times do; c << 'a string'; end}
    x.report('assign double       ') { n.times do; c = "a string"; end}
    x.report('assing interp       ') { n.times do; c = "a string #{'b string'}"; end}
    x.report('concat single       ') { n.times do; 'a string ' + 'b string'; end}
    x.report('concat double       ') { n.times do; "a string " + "b string"; end}
    x.report('concat single interp') { n.times do; "#{@a_str_single}#{@b_str_single}"; end}
    x.report('concat single <<    ') { n.times do; @a_str_single << @b_str_single; end}
    reset!
    # unless @did_print
    #   @did_print = true
    #   puts @a_str_single.length 
    #   puts " a_str_single: #{@a_str_single} , b_str_single: #{@b_str_single} !!"
    # end
    x.report('concat double interp') { n.times do; "#{@a_str_double}#{@b_str_double}"; end}
    x.report('concat double <<    ') { n.times do; @a_str_double << @b_str_double; end}
end

परिणाम:

jruby 1.7.4 (1.9.3p392) 2013-05-16 2390d3b on Java HotSpot(TM) 64-Bit Server VM 1.7.0_10-b18 [darwin-x86_64]
       user     system      total        real
assign single         0.220000   0.010000   0.230000 (  0.108000)
assign via << single  0.280000   0.010000   0.290000 (  0.138000)
assign double         0.050000   0.000000   0.050000 (  0.047000)
assing interp         0.100000   0.010000   0.110000 (  0.056000)
concat single         0.230000   0.010000   0.240000 (  0.159000)
concat double         0.150000   0.010000   0.160000 (  0.101000)
concat single interp  0.170000   0.000000   0.170000 (  0.121000)
concat single <<      0.100000   0.000000   0.100000 (  0.076000)
concat double interp  0.160000   0.000000   0.160000 (  0.108000)
concat double <<      0.100000   0.000000   0.100000 (  0.074000)

ruby 1.9.3p429 (2013-05-15 revision 40747) [x86_64-darwin12.4.0]
       user     system      total        real
assign single         0.100000   0.000000   0.100000 (  0.103326)
assign via << single  0.160000   0.000000   0.160000 (  0.163442)
assign double         0.100000   0.000000   0.100000 (  0.102212)
assing interp         0.110000   0.000000   0.110000 (  0.104671)
concat single         0.240000   0.000000   0.240000 (  0.242592)
concat double         0.250000   0.000000   0.250000 (  0.244666)
concat single interp  0.180000   0.000000   0.180000 (  0.182263)
concat single <<      0.120000   0.000000   0.120000 (  0.126582)
concat double interp  0.180000   0.000000   0.180000 (  0.181035)
concat double <<      0.130000   0.010000   0.140000 (  0.128731)

Answer 14

मैंने निम्नलिखित कोशिश की:

def measure(t)
  single_measures = []
  double_measures = []
  double_quoted_string = ""
  single_quoted_string = ''
  single_quoted = 0
  double_quoted = 0

  t.times do |i|
    t1 = Time.now
    single_quoted_string << 'a'
    t1 = Time.now - t1
    single_measures << t1

    t2 = Time.now
    double_quoted_string << "a"
    t2 = Time.now - t2
    double_measures << t2

    if t1 > t2 
      single_quoted += 1
    else
      double_quoted += 1
    end
  end
  puts "Single quoted did took longer in #{((single_quoted.to_f/t.to_f) * 100).round(2)} percent of the cases"
  puts "Double quoted did took longer in #{((double_quoted.to_f/t.to_f) * 100).round(2)} percent of the cases"

  single_measures_avg = single_measures.inject{ |sum, el| sum + el }.to_f / t
  double_measures_avg = double_measures.inject{ |sum, el| sum + el }.to_f / t
  puts "Single did took an average of #{single_measures_avg} seconds"
  puts "Double did took an average of #{double_measures_avg} seconds"
    puts "\n"
end
both = 10.times do |i|
  measure(1000000)
end

और ये आउटपुट हैं:

1।

Single quoted did took longer in 32.33 percent of the cases
Double quoted did took longer in 67.67 percent of the cases
Single did took an average of 5.032084099982639e-07 seconds
Double did took an average of 5.171539549983464e-07 seconds

2।

Single quoted did took longer in 26.9 percent of the cases
Double quoted did took longer in 73.1 percent of the cases
Single did took an average of 4.998066229983696e-07 seconds
Double did took an average of 5.223457359986066e-07 seconds

3।

Single quoted did took longer in 26.44 percent of the cases
Double quoted did took longer in 73.56 percent of the cases
Single did took an average of 4.97640888998877e-07 seconds
Double did took an average of 5.132918459987151e-07 seconds

4।

Single quoted did took longer in 26.57 percent of the cases
Double quoted did took longer in 73.43 percent of the cases
Single did took an average of 5.017136069985988e-07 seconds
Double did took an average of 5.004514459988143e-07 seconds

5।

Single quoted did took longer in 26.03 percent of the cases
Double quoted did took longer in 73.97 percent of the cases
Single did took an average of 5.059069689983285e-07 seconds
Double did took an average of 5.028807639983705e-07 seconds

6।

Single quoted did took longer in 25.78 percent of the cases
Double quoted did took longer in 74.22 percent of the cases
Single did took an average of 5.107472039991399e-07 seconds
Double did took an average of 5.216212339990241e-07 seconds

7।

Single quoted did took longer in 26.48 percent of the cases
Double quoted did took longer in 73.52 percent of the cases
Single did took an average of 5.082368429989468e-07 seconds
Double did took an average of 5.076817109989933e-07 seconds

8।

Single quoted did took longer in 25.97 percent of the cases
Double quoted did took longer in 74.03 percent of the cases
Single did took an average of 5.077162969990005e-07 seconds
Double did took an average of 5.108381859991112e-07 seconds

9।

Single quoted did took longer in 26.28 percent of the cases
Double quoted did took longer in 73.72 percent of the cases
Single did took an average of 5.148080479983138e-07 seconds
Double did took an average of 5.165793929982176e-07 seconds

10।

Single quoted did took longer in 25.03 percent of the cases
Double quoted did took longer in 74.97 percent of the cases
Single did took an average of 5.227828659989748e-07 seconds
Double did took an average of 5.218296609988378e-07 seconds

अगर मैंने कोई गलती नहीं की, तो मुझे लगता है कि दोनों लगभग एक ही समय लेते हैं, भले ही एकल उद्धृत अधिकांश मामलों में थोड़ा तेज हो।