Replace() मेथड एक स्ट्रिंग मेथड है। यह मेथड वर्तमान स्ट्रिंग ऑब्जेक्ट से सभी निर्दिष्ट यूनिकोड कैरेक्टर्स या निर्दिष्ट स्ट्रिंग को प्रतिस्थापित करने के लिए उपयोग किया जाता है और एक नया संशोधित स्ट्रिंग लौटाता है। यह मेथड केस-सेंसिटिव है।
समस्या: केस-सेंसिटिव रिप्लेसमेंट
string str = "Cricket Team";
Console.WriteLine(str.Replace('e', 'E')); // केवल लोअरकेस 'e' को प्रतिस्थापित करता है
// आउटपुट: CrickEt TEam (अपरकेस 'E' अपरिवर्तित रहता है)
समाधान: Regex के साथ केस-इनसेंसिटिव रिप्लेसमेंट
रेगुलर एक्सप्रेशन्स टेक्स्ट प्रोसेसिंग के लिए शक्तिशाली, लचीला और कुशल मेथड प्रदान करते हैं।
using System.Text.RegularExpressions;
static string CaseInsensitiveReplace(string originalString, string oldValue, string newValue)
{
// RegexOptions.IgnoreCase केस-इनसेंसिटिव मिलान के लिए
// RegexOptions.Multiline मल्टीलाइन स्ट्रिंग्स के लिए
Regex regEx = new Regex(Regex.Escape(oldValue), RegexOptions.IgnoreCase | RegexOptions.Multiline);
return regEx.Replace(originalString, newValue);
}
static void Main(string[] args)
{
string str = "Cricket Team";
Console.WriteLine("OldString: " + str);
Console.WriteLine("NewString: " + CaseInsensitiveReplace("Cricket Team", "t", "b"));
Console.WriteLine("OldString: " + str); // मूल अपरिवर्तित
Console.ReadLine();
}
आउटपुट
OldString: Cricket Team
NewString: Crickeb beam
OldString: Cricket Team
उन्नत: पुन: प्रयोज्य एक्सटेंशन मेथड
public static class StringExtensions
{
public static string ReplaceIgnoreCase(this string source, string oldValue, string newValue)
{
if (string.IsNullOrEmpty(source) || string.IsNullOrEmpty(oldValue))
return source;
return Regex.Replace(source, Regex.Escape(oldValue), newValue, RegexOptions.IgnoreCase);
}
public static string ReplaceIgnoreCase(this string source, char oldChar, char newChar)
{
return source.ReplaceIgnoreCase(oldChar.ToString(), newChar.ToString());
}
}
// उपयोग
string text = "Hello World";
Console.WriteLine(text.ReplaceIgnoreCase("world", "Universe")); // Hello Universe
Console.WriteLine(text.ReplaceIgnoreCase('l', 'X')); // HeXXo WorXd
प्रदर्शन विचार
| विधि | प्रदर्शन | केस-इनसेंसिटिव |
|---|---|---|
string.Replace | सबसे तेज़ | नहीं |
Regex.Replace | धीमा (पैटर्न पार्सिंग) | हाँ |
StringBuilder + IndexOf | मध्यम | मैन्युअल कार्यान्वयन |
उच्च-प्रदर्शन मैन्युअल कार्यान्वयन
public static string ReplaceIgnoreCaseFast(this string source, string oldValue, string newValue)
{
if (string.IsNullOrEmpty(source) || string.IsNullOrEmpty(oldValue))
return source;
var sb = new StringBuilder();
int startIndex = 0;
int index;
while ((index = source.IndexOf(oldValue, startIndex, StringComparison.OrdinalIgnoreCase)) >= 0)
{
sb.Append(source, startIndex, index - startIndex);
sb.Append(newValue);
startIndex = index + oldValue.Length;
}
sb.Append(source, startIndex, source.Length - startIndex);
return sb.ToString();
}
Regex.Escape का महत्व
// बिना Escape - विशेष रेजेक्स कैरेक्टर्स समस्या पैदा करते हैं
string pattern = "a.b"; // "a" + कोई भी कैरेक्टर + "b" से मेल खाता है
Regex.Replace("aXb", pattern, "Y"); // "aYb" - गलत!
// साथ Escape - शाब्दिक मिलान
string safePattern = Regex.Escape("a.b"); // "a\.b"
Regex.Replace("a.b", safePattern, "Y"); // "Y" - सही!
सारांश
सरल केस-इनसेंसिटिव रिप्लेसमेंट के लिए:Regex.Replace(input, Regex.Escape(oldVal), newVal, RegexOptions.IgnoreCase)
प्रदर्शन-महत्वपूर्ण कोड के लिए:StringComparison.OrdinalIgnoreCaseके साथ मैन्युअल StringBuilder कार्यान्वयन का उपयोग करें