रूबी

Question

में स्ट्रिंग कॉन्सटेनेशन बनाम इंटरपोलेशन मैं रूबी (पहली बार प्रोग्रामिंग) सीखना शुरू कर रहा हूं, और चर के संबंध में मूलभूत वाक्य रचनात्मक प्रश्न है, और कोड लिखने के विभिन्न तरीकों से संबंधित है।

क्रिस पाइन के "कार्यक्रम के लिए जानें" मुझे सिखाया इस तरह एक बुनियादी प्रोग्राम लिखने के लिए ...

num_cars_again= 2 
puts 'I own ' + num_cars_again.to_s + ' cars.' 

यह ठीक है, लेकिन फिर मैं ruby.learncodethehardway.com पर ट्यूटोरियल भर में ठोकर खाई है, और था इस तरह एक ही सटीक प्रोग्राम लिखने के लिए ... सिखाया

num_cars= 2 
puts "I own #{num_cars} cars." 

वे दोनों उत्पादन एक ही बात है, लेकिन स्पष्ट रूप से विकल्प 2 यह करने के लिए एक बहुत छोटे तरीका है।

क्या कोई विशेष कारण है कि मुझे दूसरे प्रारूप में एक प्रारूप का उपयोग क्यों करना चाहिए?

Answer 1

जब भी टिमटोटीडी (इसे करने के एक से अधिक तरीके हैं), तो आपको पेशेवरों और विपक्ष की तलाश करनी चाहिए।

पेशेवरों: "स्ट्रिंग संयोजन" (प्रथम) के बजाय "स्ट्रिंग प्रक्षेप" (द्वितीय) का उपयोग करना

• है कम
• टाइपिंग के लिए स्वत आप
• अधिक मुहावरेदार to_s कॉल रुबी समुदाय के भीतर
• रनटाइम

के दौरान पूरा करने के लिए तेज़

विपक्ष:

• स्वचालित रूप से आप के लिए to_s (हो सकता है आप सोचा कि आप एक स्ट्रिंग था, और to_s प्रतिनिधित्व जैसे आप चाहते हैं नहीं है, और तथ्य यह है कि यह एक स्ट्रिंग नहीं था खाल) कॉल
• " उपयोग करने के लिए अपने स्ट्रिंग परिसीमित करने के लिए के बजाय ' की आवश्यकता होती है (शायद आप ' का उपयोग कर की आदत है, या आपने पहले कि और केवल बाद में स्ट्रिंग प्रक्षेप का उपयोग करने के लिए आवश्यक का उपयोग कर एक स्ट्रिंग टाइप किया)

Answer 2

@ user1181898 - IMHO, ऐसा इसलिए है क्योंकि यह देखना आसान है कि क्या हो रहा है। @ Phrogz के बिंदु पर, स्ट्रिंग इंटरपोलेशन स्वचालित रूप से आपके लिए to_s को कॉल करता है। शुरुआत के रूप में, आपको यह देखने की ज़रूरत है कि "हुड के नीचे" क्या हो रहा है ताकि आप अवधारणा को सीख सकें क्योंकि केवल रोटे से सीखने के विरोध में।

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

Answer 3

इंटरपोलेशन और संगतता दोनों की अपनी ताकत और कमजोरी है। नीचे मैंने एक बेंचमार्क दिया जो स्पष्ट रूप से प्रदर्शित करता है कि संगतता का उपयोग कहां किया जाए और इंटरपोलेशन का उपयोग कहां किया जाए।

require 'benchmark' 

iterations = 1_00_000 
firstname = 'soundarapandian' 
middlename = 'rathinasamy' 
lastname = 'arumugam' 

puts 'With dynamic new strings' 
puts '====================================================' 
5.times do 
    Benchmark.bm(10) do |benchmark| 
    benchmark.report('concatination') do 
     iterations.times do 
     'Mr. ' + firstname + middlename + lastname + ' aka soundar' 
     end 
    end 

    benchmark.report('interpolaton') do 
     iterations.times do 
     "Mr. #{firstname} #{middlename} #{lastname} aka soundar" 
     end 
    end 
    end 
    puts '--------------------------------------------------' 
end 

puts 'With predefined strings' 
puts '====================================================' 
5.times do 
    Benchmark.bm(10) do |benchmark| 
    benchmark.report('concatination') do 
     iterations.times do 
     firstname + middlename + lastname 
     end 
    end 

    benchmark.report('interpolaton') do 
     iterations.times do 
     "#{firstname} #{middlename} #{lastname}" 
     end 
    end 
    end 
    puts '--------------------------------------------------' 
end 

और नीचे बेंचमार्क परिणाम है

Without predefined strings 
==================================================== 
       user  system  total  real 
concatination 0.170000 0.000000 0.170000 ( 0.165821) 
interpolaton 0.130000 0.010000 0.140000 ( 0.133665) 
-------------------------------------------------- 
       user  system  total  real 
concatination 0.180000 0.000000 0.180000 ( 0.180410) 
interpolaton 0.120000 0.000000 0.120000 ( 0.125051) 
-------------------------------------------------- 
       user  system  total  real 
concatination 0.140000 0.000000 0.140000 ( 0.134256) 
interpolaton 0.110000 0.000000 0.110000 ( 0.111427) 
-------------------------------------------------- 
       user  system  total  real 
concatination 0.130000 0.000000 0.130000 ( 0.132047) 
interpolaton 0.120000 0.000000 0.120000 ( 0.120443) 
-------------------------------------------------- 
       user  system  total  real 
concatination 0.170000 0.000000 0.170000 ( 0.170394) 
interpolaton 0.150000 0.000000 0.150000 ( 0.149601) 
-------------------------------------------------- 
With predefined strings 
==================================================== 
       user  system  total  real 
concatination 0.070000 0.000000 0.070000 ( 0.067735) 
interpolaton 0.100000 0.000000 0.100000 ( 0.099335) 
-------------------------------------------------- 
       user  system  total  real 
concatination 0.060000 0.000000 0.060000 ( 0.061955) 
interpolaton 0.130000 0.000000 0.130000 ( 0.127011) 
-------------------------------------------------- 
       user  system  total  real 
concatination 0.090000 0.000000 0.090000 ( 0.092136) 
interpolaton 0.110000 0.000000 0.110000 ( 0.110224) 
-------------------------------------------------- 
       user  system  total  real 
concatination 0.080000 0.000000 0.080000 ( 0.077587) 
interpolaton 0.110000 0.000000 0.110000 ( 0.112975) 
-------------------------------------------------- 
       user  system  total  real 
concatination 0.090000 0.000000 0.090000 ( 0.088154) 
interpolaton 0.140000 0.000000 0.140000 ( 0.135349) 
-------------------------------------------------- 

निष्कर्ष

तार पहले से परिभाषित और यह सुनिश्चित करें अगर वे कभी नहीं होगा और कुछ नहीं के बराबर उपयोग concatination interpolation.Use उचित एक का उपयोग करें जो परिणाम होगा एक से बेहतर प्रदर्शन में जो इंडेंट करना आसान है।

Answer 4

यदि आप एक बफर के रूप में एक स्ट्रिंग का उपयोग कर रहे हैं, तो मैंने पाया कि concatenation (String#concat) का उपयोग तेजी से होने के लिए किया जाता है।

require 'benchmark/ips' 

puts "Ruby #{RUBY_VERSION} at #{Time.now}" 
puts 

firstname = 'soundarapandian' 
middlename = 'rathinasamy' 
lastname = 'arumugam' 

Benchmark.ips do |x| 
    x.report("String\#<<") do |i| 
     buffer = String.new 

     while (i -= 1) > 0 
      buffer << 'Mr. ' << firstname << middlename << lastname << ' aka soundar' 
     end 
    end 

    x.report("String interpolate") do |i| 
     buffer = String.new 

     while (i -= 1) > 0 
      buffer << "Mr. #{firstname} #{middlename} #{lastname} aka soundar" 
     end 
    end 

    x.compare! 
end 

परिणाम:

Ruby 2.3.1 at 2016-11-15 15:03:57 +1300 

Warming up -------------------------------------- 
      String#<< 230.615k i/100ms 
    String interpolate 234.274k i/100ms 
Calculating ------------------------------------- 
      String#<<  2.345M (± 7.2%) i/s -  11.761M in 5.041164s 
    String interpolate  1.242M (± 5.4%) i/s -  6.325M in 5.108324s 

Comparison: 
      String#<<: 2344530.4 i/s 
    String interpolate: 1241784.9 i/s - 1.89x slower 

एक अनुमान में, मैं कहता था कि प्रक्षेप एक अस्थायी स्ट्रिंग है, इसीलिए उसे धीमी है उत्पन्न करता है।