स्ट्रिंग ऑपरेटरों के बीच अंतर + और << रूबी

Question

मैं रूबी और इस साइट पर नया हूं।

निम्नलिखित दो कार्य भिन्न हैं, एक फ़ंक्शन के बाहर चर बदलता है और कोई नहीं करता है।

def m1 (x) 
    x << "4" 
end 

def m2 (x) 
    x = x + "4" 
end 


str="123" 

m2(str) #str remains unchanged 123 

m1(str) #str is changed to 1234 

मुझे यकीन है कि मैं इस सही ढंग से समझ बनाने के लिए चाहते हैं -

जब एम 1 कहा जाता है, str के संदर्भ में की नकल की और समारोह जो इसे एक्स के रूप में देखता है के लिए पारित किया गया है। ऑपरेटर < < एक्स बदलता है जो मूल स्ट्रिंग का संदर्भ देता है इसलिए इस ऑपरेशन द्वारा स्ट्र को बदल दिया जाता है।

जब एम 2 कहा जाता है, तो स्ट्र के संदर्भ की प्रतिलिपि बनाई जाती है और इसे फ़ंक्शन में पास किया जाता है जो इसे x के रूप में देखता है। ऑपरेटर + एक नई स्ट्रिंग बनाता है, और असाइनमेंट x = x + "4" बस मूल स्ट्रैर को छूने वाले नए स्ट्रिंग पर एक्स को रीडायरेक्ट करता है।

सही?

धन्यवाद

Answer 1

String#+ :: other_strstr को श्रेणीबद्ध वाली एक नई स्ट्रिंग str + other_str → new_str कड़ी-देता है।

String#<< :: str << integer → str: दिए गए ऑब्जेक्ट को str पर संलग्न करें।

<< नई वस्तु बनाने नहीं करता है, + करता है जहां के रूप में।

a = "str" 
#=> "str" 
a.object_id 
#=> 14469636 
b = a << "ing" 
#=> "string" 
a.object_id 
#=> 14469636 
b.object_id 
#=> 14469636 

a= "str" 
#=> "str" 
b = a + "ing" 
#=> "string" 
a.object_id 
#=> 16666584 
b.object_id 
#=> 17528916 

संपादित

अपनी टिप्पणी से, अपनी बात मिल गया। नीचे देखें: के रूप में आप विधि m2() अंदर मान प्रदान किया

def m1 (x) 
x << "4" 
end 
#=> nil 
def m2 (x) 
x = x + "4" 
end 
#=> nil 

str="123" 
#=> "123" 

m2(str) 
#=> "1234" 

str 
#=> "123" 

यहाँ str परिवर्तन नहीं किया, तो सभी परिवर्तन से ऊपर प्रति कॉल के रूप में विधि करने के लिए स्थानीय। इस प्रकार str से नीचे यह परिवर्तन नहीं दिख रहा है। परिवर्तन देखने के लिए आपको इसे नीचे कॉल करना होगा।

str = m2(str) 
#=> "1234" 

str 
#=> "1234" 

या

आप नीचे के रूप में सामान कर सकता है: - मैं कहाँ str के संदर्भ पता पारित नहीं किया लेकिन मूल्य।

str = "abc" 
#=> "abc" 
str.object_id 
#=> 16250484 
ObjectSpace._id2ref(16250484) 
#=> "abc" 
def m1 (x) 
ObjectSpace._id2ref(x) << "4" 
end 
#=> nil 
m1(16250484) 
#=> "abc4" 
str 
#=> "abc4" 

यह भावना :)

चीयर्स बनाने आशा है!

Answer 2

<< concatenate ऑपरेटर एक स्ट्रिंग के लिए विनाशकारी है।इसका अर्थ यह है कि यह उस चर के कुशलता में हेरफेर करेगा जो यह कार्य करता है, न केवल अभिव्यक्ति का परिणाम लौटाता है।

उदाहरण:

str = "abc" 
puts str + "d" # "abcd" 

puts str # "abc" 

puts str << "d" # "abcd" 

puts str # "abcd" 

Answer 3

निम्नलिखित दो कार्य अलग हैं, एक समारोह के बाहर चर बदल देता है और एक ऐसा नहीं करता।

यह गलत है। दो विधियों के (वे विधियां हैं, बीटीडब्ल्यू, फ़ंक्शन नहीं हैं, रुबी में फ़ंक्शन नहीं हैं; एक मौलिक अंतर है) str चर बदलता है। m1 ऑब्जेक्ट को अंक पर संशोधित करता है, लेकिन यह चर स्वयं को संशोधित करने से बिल्कुल अलग है।