`Gsub` 'gsub' से अलग कैसे होता है जब हैश कुंजी का उपयोग अपने मूल्यों को प्रतिस्थापित करने के लिए पैटर्न के रूप में करते हैं? [बंद] - रूबी, रेगेक्स, हैश

मैंनें इस्तेमाल किया gsub! अपने हैश मान के साथ हैश कुंजी के साथ एक मैच को बदलने के लिए। उदाहरण के लिए:

def replace_string(string = "@ReplaceMe[xyz]@@ReplaceMe[123]@Hello")
generator_replacements = {
"@ReplaceMe[xyz]@" => "Time",
"@ReplaceMe[123]@" => "Date"
}
generator_replacements.each{
|generator, replacement|
string = string.gsub!(generator.to_s, replacement.to_s)
puts string
}
end

replace_string

आउटपुट:

1. TimeDateHello
2. TimeDateHello

मुझे समझ में नहीं आता क्यों gsub! हर पुनरावृत्ति के बजाय एक बार में सभी हैश कुंजी प्रतिस्थापित। जब मैं प्रयोग करके देखता हूं gsub, यह हर पुनरावृत्ति के साथ स्थानापन्न करता है:

1. Time@ReplaceMe[123]@Hello
2. TimeDateHello

क्या कोई समझा सकता है कि ऐसा क्यों होता है?

उत्तर:

उत्तर № 1 के लिए 1

उस संबंध में कोई अंतर नहीं है। each पाश को तत्व द्वारा निष्पादित किया जाता है और न ही gsub न gsub! भविष्य का अनुमान लगा सकते हैं।

यह कोड:

replacements = { "foo" => "hello", "bar" => "world" }
string = "foo bar!"
replacements.each do |placeholder, value|
string = string.gsub(placeholder, value)
end
string #=> "hello world!"

के बराबर है:

string = "foo bar!"
string = string.gsub("foo", "hello") #=> "hello bar!"
string = string.gsub("bar", "world") #=> "hello world!"
string #=> "hello world!"

साथ में gsub! आप लिख सकते हैं:

string = "foo bar!"
string.gsub!("foo", "hello") #=> "hello bar!"
string.gsub!("bar", "world") #=> "hello world!"
string #=> "hello world!"

मुख्य अंतर यह है कि gsub! रिसीवर को इन-प्लेस बदलता है, जबकि gsub एक नया स्ट्रिंग लौटाता है (इसलिए इसे वापस असाइन करने की आवश्यकता है string)।

एक साथ कई प्रतिस्थापन करने के लिए, आप एक हैश को पास कर सकते हैं gsub:

string = "foo bar!"
string.gsub(/foo|bar/, { "foo" => "hello", "bar" => "world" })
#=> "hello world!"

नियमित अभिव्यक्ति को प्रोग्रामेटिक रूप से भी उत्पन्न किया जा सकता है:

replacements = { "foo" => "hello", "bar" => "world" }
string = "foo bar!"
string.gsub(Regexp.union(replacements.keys), replacements)
#=> "hello world!"

---

जवाब के लिए 0 № 2

मैंने आपका कोड संपादित कर दिया है ताकि यह नीचे दिखाए अनुसार काम करे:

def replace_string(generated_string = "@ReplaceMe[xyz]@@ReplaceMe[123]@Hello")
generator_replacements = {
"@ReplaceMe[xyz]@" => "Time",
"@ReplaceMe[123]@" => "Date"
}
generator_replacements.each do |generator, replacement|
string = generated_string.gsub(generator.to_s, replacement.to_s)
puts string
end
end

इस कोड का उपयोग करने के साथ gsub मुझे मिला:

Time@ReplaceMe[123]@Hello
@ReplaceMe[xyz]@DateHello

और साथ gsub! मुझे मिला:

Time@ReplaceMe[123]@Hello
TimeDateHello

इसका कारण यह है कि gsub! जहाँ मौजूदा स्ट्रिंग को संशोधित करता है gsub मौजूदा स्ट्रिंग को संशोधित नहीं करता है। क्या यह आपके प्रश्न का उत्तर देने में मदद करता है?

---