สตริงแทนที่กรณีที่ไม่สนใจ


214

ฉันมีสตริงชื่อ "สวัสดีโลก"

ฉันต้องการแทนที่คำว่า "โลก" เป็น "csharp"

สำหรับสิ่งนี้ฉันใช้:

string.Replace("World", "csharp");

แต่เป็นผลให้ฉันไม่ได้รับสายแทนที่ เหตุผลคือกรณีที่ไวต่อความรู้สึก สตริงเดิมมี "โลก" ในขณะที่ฉันพยายามแทนที่ "โลก"

มีวิธีใดบ้างที่จะหลีกเลี่ยงการแพ้ในกรณีนี้ใน string.Replace?


5
คุณจะพบปัญหาที่คล้ายกันได้ที่นี่
MichałKuliński

คำตอบ:


309

คุณสามารถใช้Regexและดำเนินการแทนที่ด้วยตัวพิมพ์เล็กและตัวพิมพ์เล็ก:

class Program
{
    static void Main()
    {
        string input = "hello WoRlD";
        string result = 
           Regex.Replace(input, "world", "csharp", RegexOptions.IgnoreCase);
        Console.WriteLine(result); // prints "hello csharp"
    }
}

19
ไม่สามารถใช้งานได้กับองค์ประกอบภาษา Regexดังนั้นจึงไม่ใช่วิธีสากล คำตอบของ Steve B ถูกต้อง
AsValeO

1
ดังนั้นคุณไม่ควรเขียนhello. world?หรืออื่น ๆ ที่มีตัวดำเนินการ regex
เซบาสเตียนมัค

ในกรณีที่ไม่มีใครอยากอ่านเพิ่มเติมนี่เป็นคำตอบที่ได้รับการยอมรับในปี 2011 และมีคะแนนโหวตเป็นจำนวนมาก วิธีนี้ใช้งานได้ดีถ้าคุณต้องแทนที่ตัวอักษรและตัวเลขเท่านั้น อย่างไรก็ตามหากคุณต้องแทนที่เครื่องหมายวรรคตอนใด ๆ คุณจะประสบปัญหาใหญ่ คำตอบของ Oleg Zarevennyi นั้นยอดเยี่ยม แต่มีเพียงไม่กี่โหวตเพราะโพสต์ในปี 2560
Tony Pulokas

115
var search = "world";
var replacement = "csharp";
string result = Regex.Replace(
    stringToLookInto,
    Regex.Escape(search), 
    replacement.Replace("$","$$"), 
    RegexOptions.IgnoreCase
);

Regex.Escapeเป็นประโยชน์ถ้าคุณพึ่งพาผู้ใช้ป้อนข้อมูลที่สามารถมีRegex องค์ประกอบภาษา

ปรับปรุง

ขอบคุณที่แสดงความคิดเห็นคุณไม่จำเป็นต้องหนีจากสตริงการแทนที่

นี่คือซอเล็ก ๆ ที่ทดสอบโค้ด :

using System;
using System.Text.RegularExpressions;           
public class Program
{
    public static void Main()
    {

        var tests = new[] {
            new { Input="abcdef", Search="abc", Replacement="xyz", Expected="xyzdef" },
            new { Input="ABCdef", Search="abc", Replacement="xyz", Expected="xyzdef" },
            new { Input="A*BCdef", Search="a*bc", Replacement="xyz", Expected="xyzdef" },
            new { Input="abcdef", Search="abc", Replacement="x*yz", Expected="x*yzdef" },       
            new { Input="abcdef", Search="abc", Replacement="$", Expected="$def" },
        };


        foreach(var test in tests){
            var result = ReplaceCaseInsensitive(test.Input, test.Search, test.Replacement);

            Console.WriteLine(
                "Success: {0}, Actual: {1}, {2}",
                result == test.Expected,
                result,
                test
            );

        }


    }

    private static string ReplaceCaseInsensitive(string input, string search, string replacement){
        string result = Regex.Replace(
            input,
            Regex.Escape(search), 
            replacement.Replace("$","$$"), 
            RegexOptions.IgnoreCase
        );
        return result;
    }
}

เอาท์พุทมันคือ:

Success: True, Actual: xyzdef, { Input = abcdef, Search = abc, Replacement = xyz, Expected = xyzdef } 
Success: True, Actual: xyzdef, { Input = ABCdef, Search = abc, Replacement = xyz, Expected = xyzdef }
Success: True, Actual: xyzdef, { Input = A*BCdef, Search = a*bc, Replacement = xyz, Expected = xyzdef } 
Success: True, Actual: x*yzdef, { Input = abcdef, Search = abc, Replacement = x*yz, Expected = x*yzdef} 
Success: True, Actual: $def, { Input = abcdef, Search = abc, Replacement = $, Expected = $def }

2
วิธีนี้จะล้มเหลวหากการแทนที่ = "! @ # $% ^ & * ()" คุณได้รับ "! @ \ # \ $% \ ^ & * ()" แทนที่
Kcoder

2
ที่สองRegex.Escapeไม่ดีมันจะนำหน้าอักขระพิเศษที่มีเครื่องหมายแบ็กสแลช ดูเหมือนว่าวิธีที่ดีที่สุดคือ. แทนที่ ("$", "$$") ซึ่งเป็นใบ้ครับ ( stackoverflow.com/a/10078353 )
Danny Tuppeny

1
@dannyTuppeny: ถูกต้อง ... ฉันอัพเดตคำตอบแล้ว
Steve B

54

2.5X วิธีที่เร็วและมีประสิทธิภาพมากที่สุดกว่าวิธีการแสดงออกปกติอื่น ๆ :

/// <summary>
/// Returns a new string in which all occurrences of a specified string in the current instance are replaced with another 
/// specified string according the type of search to use for the specified string.
/// </summary>
/// <param name="str">The string performing the replace method.</param>
/// <param name="oldValue">The string to be replaced.</param>
/// <param name="newValue">The string replace all occurrences of <paramref name="oldValue"/>. 
/// If value is equal to <c>null</c>, than all occurrences of <paramref name="oldValue"/> will be removed from the <paramref name="str"/>.</param>
/// <param name="comparisonType">One of the enumeration values that specifies the rules for the search.</param>
/// <returns>A string that is equivalent to the current string except that all instances of <paramref name="oldValue"/> are replaced with <paramref name="newValue"/>. 
/// If <paramref name="oldValue"/> is not found in the current instance, the method returns the current instance unchanged.</returns>
[DebuggerStepThrough]
public static string Replace(this string str,
    string oldValue, string @newValue,
    StringComparison comparisonType)
{

    // Check inputs.
    if (str == null)
    {
        // Same as original .NET C# string.Replace behavior.
        throw new ArgumentNullException(nameof(str));
    }
    if (str.Length == 0)
    {
        // Same as original .NET C# string.Replace behavior.
        return str;
    }
    if (oldValue == null)
    {
        // Same as original .NET C# string.Replace behavior.
        throw new ArgumentNullException(nameof(oldValue));
    }
    if (oldValue.Length == 0)
    {
        // Same as original .NET C# string.Replace behavior.
        throw new ArgumentException("String cannot be of zero length.");
    }


    //if (oldValue.Equals(newValue, comparisonType))
    //{
    //This condition has no sense
    //It will prevent method from replacesing: "Example", "ExAmPlE", "EXAMPLE" to "example"
    //return str;
    //}



    // Prepare string builder for storing the processed string.
    // Note: StringBuilder has a better performance than String by 30-40%.
    StringBuilder resultStringBuilder = new StringBuilder(str.Length);



    // Analyze the replacement: replace or remove.
    bool isReplacementNullOrEmpty = string.IsNullOrEmpty(@newValue);



    // Replace all values.
    const int valueNotFound = -1;
    int foundAt;
    int startSearchFromIndex = 0;
    while ((foundAt = str.IndexOf(oldValue, startSearchFromIndex, comparisonType)) != valueNotFound)
    {

        // Append all characters until the found replacement.
        int @charsUntilReplacment = foundAt - startSearchFromIndex;
        bool isNothingToAppend = @charsUntilReplacment == 0;
        if (!isNothingToAppend)
        {
            resultStringBuilder.Append(str, startSearchFromIndex, @charsUntilReplacment);
        }



        // Process the replacement.
        if (!isReplacementNullOrEmpty)
        {
            resultStringBuilder.Append(@newValue);
        }


        // Prepare start index for the next search.
        // This needed to prevent infinite loop, otherwise method always start search 
        // from the start of the string. For example: if an oldValue == "EXAMPLE", newValue == "example"
        // and comparisonType == "any ignore case" will conquer to replacing:
        // "EXAMPLE" to "example" to "example" to "example" … infinite loop.
        startSearchFromIndex = foundAt + oldValue.Length;
        if (startSearchFromIndex == str.Length)
        {
            // It is end of the input string: no more space for the next search.
            // The input string ends with a value that has already been replaced. 
            // Therefore, the string builder with the result is complete and no further action is required.
            return resultStringBuilder.ToString();
        }
    }


    // Append the last part to the result.
    int @charsUntilStringEnd = str.Length - startSearchFromIndex;
    resultStringBuilder.Append(str, startSearchFromIndex, @charsUntilStringEnd);


    return resultStringBuilder.ToString();

}

หมายเหตุ: ไม่สนใจกรณี == เป็นพารามิเตอร์สำหรับStringComparison.OrdinalIgnoreCase StringComparison comparisonTypeมันเป็นวิธีที่เร็วและไม่คำนึงถึงขนาดตัวพิมพ์เพื่อแทนที่ค่าทั้งหมด


ข้อดีของวิธีนี้:

  • CPU และ MEMORY ประสิทธิภาพสูง
  • มันเป็นทางออกที่เร็วที่สุดเร็วกว่าวิธีอื่น ๆ 2.5 เท่าด้วยนิพจน์ทั่วไป (พิสูจน์ในตอนท้าย)
  • เหมาะสำหรับการลบชิ้นส่วนออกจากสายป้อนข้อมูล (ตั้งค่าnewValueเป็น null) ปรับให้เหมาะสมสำหรับสิ่งนี้
  • เหมือนกับพฤติกรรมเดิม. NET C # string.Replace , ข้อยกเว้นเดียวกัน;
  • มีความเห็นดีเข้าใจง่าย
  • เรียบง่าย - ไม่มีการแสดงออกปกติ การแสดงออกปกติมักจะช้ากว่าเพราะมีความสามารถรอบตัว
  • วิธีนี้ได้รับการทดสอบอย่างดีและไม่มีข้อบกพร่องใด ๆ ที่ซ่อนเร้นอยู่เช่นเดียวกับ infinite loop ในคำตอบของผู้อื่นแม้จะได้รับการจัดอันดับสูง:

@AsValeO: ไม่ทำงานกับองค์ประกอบภาษา Regex ดังนั้นจึงไม่ใช่วิธีสากล

@ Mike Stillion: มีปัญหากับรหัสนี้ หากข้อความใหม่เป็นชุดข้อความที่เก่ากว่าสิ่งนี้สามารถสร้างวนซ้ำไม่รู้จบ


เบนช์มาร์ก - พิสูจน์ : โซลูชันนี้เร็วกว่า regex จาก@Steve B. 2.59เท่ารหัส:

// Results:
// 1/2. Regular expression solution: 4486 milliseconds
// 2/2. Current solution: 1727 milliseconds — 2.59X times FASTER! than regex!

// Notes: the test was started 5 times, the result is an average; release build.

const int benchmarkIterations = 1000000;
const string sourceString = "aaaaddsdsdsdsdsd";
const string oldValue = "D";
const string newValue = "Fod";
long totalLenght = 0;

Stopwatch regexStopwatch = Stopwatch.StartNew();
string tempString1;
for (int i = 0; i < benchmarkIterations; i++)
{
    tempString1 = sourceString;
    tempString1 = ReplaceCaseInsensitive(tempString1, oldValue, newValue);

    totalLenght = totalLenght + tempString1.Length;
}
regexStopwatch.Stop();



Stopwatch currentSolutionStopwatch = Stopwatch.StartNew();
string tempString2;
for (int i = 0; i < benchmarkIterations; i++)
{
    tempString2 = sourceString;
    tempString2 = tempString2.Replace(oldValue, newValue,
        StringComparison.OrdinalIgnoreCase);

    totalLenght = totalLenght + tempString2.Length;
}
currentSolutionStopwatch.Stop();

แนวคิดดั้งเดิม - @ Darky711; @MinerR StringBuilderขอบคุณสำหรับ


5
ฉันพนันได้เลยว่าคุณจะทำได้เร็วกว่านี้ด้วยการใช้ StringBuilder แทนที่จะเป็นสตริง
MineR

1
@MineR คุณกำลังขวาฉันเดิมการปรับปรุงเพียง @ แก้ปัญหา Darky711 Stringโดยไม่ต้องห่วงไม่มีที่สิ้นสุดดังนั้นฉันใช้ อย่างไรก็ตามStringBuilderมันได้เร็วขึ้นโดย30-40%Stringกว่า ฉันได้อัพเดตโซลูชันแล้ว ขอบคุณ;)
Oleg Zarevennyi

2
แนวทางที่น่าสนใจ อาจดีกว่า (ดีกว่าของฉัน :)) เมื่อประสิทธิภาพการทำงานมีความสำคัญ โดยทั่วไปวิธีการในไลบรารีรหัสที่ใช้ร่วมกันทั่วไป
Steve B

2
การใช้นิพจน์ 'nameof' ทำให้ใช้งานได้กับ C # 6.0 ขึ้นไปเท่านั้น หากคุณอยู่ใน VS2013 คุณสามารถใช้งานได้โดยเพียงแค่ลบตัวถูกดำเนินการในข้อยกเว้น
LanchPad

สำหรับความคิดเห็นที่ออก "// if (oldValue.Equals (newValue, comparType))" แทนที่ replaceType ด้วย StringComparison.Ordinal?
Roger Willcocks

31

ส่วนขยายทำให้ชีวิตของเราง่ายขึ้น:

static public class StringExtensions
{
    static public string ReplaceInsensitive(this string str, string from, string to)
    {
        str = Regex.Replace(str, from, to, RegexOptions.IgnoreCase);
        return str;
    }
}

10
และการหลบหนีทำให้ชีวิตของเรามีค่าน้อยลง :-) คืนค่า Regex.Replace (อินพุต, Regex.Escape (ค้นหา), การแทนที่การแทนที่ ("$", "$$"), RegexOptions.IgnoreCase);
Vman

29

ข้อเสนอแนะจำนวนมากโดยใช้ Regex วิธีการเกี่ยวกับวิธีการขยายนี้โดยไม่ได้:

public static string Replace(this string str, string old, string @new, StringComparison comparison)
{
    @new = @new ?? "";
    if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(old) || old.Equals(@new, comparison))
        return str;
    int foundAt = 0;
    while ((foundAt = str.IndexOf(old, foundAt, comparison)) != -1)
    {
        str = str.Remove(foundAt, old.Length).Insert(foundAt, @new);
        foundAt += @new.Length;
    }
    return str;
}

โปรดทราบว่าอาร์กิวเมนต์การเปรียบเทียบไม่ได้ถูกใช้เพื่อทำการแทนที่จริง (มันไม่คำนึงถึงขนาดตัวพิมพ์เสมอ)
Bolo

2
มีปัญหากับรหัสนี้ หากข้อความใหม่เป็นชุดข้อความที่เก่ากว่าสิ่งนี้สามารถสร้างวนซ้ำไม่รู้จบ เมื่อใหม่จะถูกแทรกที่FoundAtค่าของFoundAtจะต้องมีขั้นสูงโดยความยาวของใหม่
Mike Stillion

comparisonควรใช้พารามิเตอร์IndexOfแทนStringComparison.CurrentCultureIgnoreCase
Maxence

@Bolo ฉันได้แก้ไขเพื่อใช้อาร์กิวเมนต์การเปรียบเทียบ (อาจใช้เวลาสักครู่เพื่อให้เพื่อนตรวจสอบ)
bradlis7

2
ฉันจะแยกเงื่อนไขนี้เพื่อคืนสตริงใหม่: if(old.Equals(@new, comparison)) return @new;เนื่องจากสตริงใหม่อาจแตกต่างกันเป็นตัวพิมพ์ใหญ่ / ตัวพิมพ์เล็ก
sɐunıɔןɐqɐp

13

คุณสามารถใช้เนมสเปซMicrosoft.VisualBasicเพื่อค้นหาฟังก์ชันตัวช่วยนี้:

Replace(sourceString, "replacethis", "withthis", , , CompareMethod.Text)

ฉันภูมิใจในคำตอบของฉันจนกว่าฉันจะเห็นสิ่งนี้ซึ่งเป็นคำตอบที่ดีกว่าเพราะสร้างขึ้นมาแล้ว Ex: Strings.Replace ("TeStInG123", "t", "z", 1, -1, CompareMethod.Text) ส่งคืน " zeSzInG123"
Bolo

คำเตือน Strings.Replace ส่งคืนค่า null หากสตริงที่กำลังค้นหาเป็นสตริงว่าง
Mafu Josh

1
ใน. Net 4.7.2 คุณต้องเพิ่มการอ้างอิงไปยัง Microsoft.VisualBasic เพื่อให้สิ่งนี้ใช้งานได้ ใน. Net Core คลาส Microsoft.VisualBasic.Strings (ในเวอร์ชัน 10.3.0 ต่อไป) จะไม่ปรากฏขึ้นเพื่อใช้ฟังก์ชั่นแทนที่ สิ่งนี้ใช้ได้ใน Powershell เช่นกันหากคุณเพิ่มระดับ -AssemblyName Microsoft.VisualBasic ก่อน
Prof Von Lemongargle

6

( แก้ไขแล้ว:ไม่ทราบถึงปัญหา `ลิงก์เปลือย 'ขออภัยเกี่ยวกับเรื่องนี้)

นำมาจากที่นี่ :

string myString = "find Me and replace ME";
string strReplace = "me";
myString = Regex.Replace(myString, "me", strReplace, RegexOptions.IgnoreCase);

ดูเหมือนว่าคุณไม่ใช่คนแรกที่บ่นเรื่องการขาดสตริงตัวพิมพ์เล็กและใหญ่แทนที่


5

คำตอบของ Modified @ Darky711 เพื่อใช้ประเภทการส่งผ่านในแบบเปรียบเทียบและจับคู่เฟรมเวิร์กแทนที่การตั้งชื่อและข้อคิดเห็น xml ให้ใกล้เคียงที่สุด

/// <summary>
/// Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.
/// </summary>
/// <param name="str">The string performing the replace method.</param>
/// <param name="oldValue">The string to be replaced.</param>
/// <param name="newValue">The string replace all occurrances of oldValue.</param>
/// <param name="comparisonType">Type of the comparison.</param>
/// <returns></returns>
public static string Replace(this string str, string oldValue, string @newValue, StringComparison comparisonType)
{
    @newValue = @newValue ?? string.Empty;
    if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(oldValue) || oldValue.Equals(@newValue, comparisonType))
    {
        return str;
    }
    int foundAt;
    while ((foundAt = str.IndexOf(oldValue, 0, comparisonType)) != -1)
    {
        str = str.Remove(foundAt, oldValue.Length).Insert(foundAt, @newValue);
    }
    return str;
}

2

ฉันได้เขียนวิธีการขยาย:

public static string ReplaceIgnoreCase(this string source, string oldVale, string newVale)
    {
        if (source.IsNullOrEmpty() || oldVale.IsNullOrEmpty())
            return source;

        var stringBuilder = new StringBuilder();
        string result = source;

        int index = result.IndexOf(oldVale, StringComparison.InvariantCultureIgnoreCase);

        while (index >= 0)
        {
            if (index > 0)
                stringBuilder.Append(result.Substring(0, index));

            if (newVale.IsNullOrEmpty().IsNot())
                stringBuilder.Append(newVale);

            stringBuilder.Append(result.Substring(index + oldVale.Length));

            result = stringBuilder.ToString();

            index = result.IndexOf(oldVale, StringComparison.InvariantCultureIgnoreCase);
        }

        return result;
    }

ฉันใช้วิธีส่วนขยายเพิ่มเติมสองวิธีสำหรับวิธีส่วนขยายก่อนหน้า:

    public static bool IsNullOrEmpty(this string value)
    {
        return string.IsNullOrEmpty(value);
    }

    public static bool IsNot(this bool val)
    {
        return val == false;
    }

2
upvoted แต่IsNotคือการส่วนขยายอย่างจริงจังเกินไป :)
Nawfal

น่าผิดหวังนี่ไม่สามารถใช้ได้กับทุกสถานการณ์ ฉันกำลังผ่านชื่อที่แตกต่างและมันจะต่อท้ายจนกว่าสตริงจะมีความยาวหนึ่งล้านตัวอักษรและหน่วยความจำหมดแล้ว
Bbb

ทางเลือกที่นำเสนอด้านล่างที่แก้ไขปัญหาของฉัน
Bbb

ฉันชอบจริงๆ.IsNot
ttugates

1

การขยายคำตอบของPetrucioRegex.Escapeในสตริงการค้นหาและหลีกเลี่ยงกลุ่มที่ตรงกันตามคำแนะนำในคำตอบของSteve B (และการเปลี่ยนแปลงเล็กน้อยในรสนิยมของฉัน):

public static class StringExtensions
{
    public static string ReplaceIgnoreCase(this string str, string from, string to)
    {
        return Regex.Replace(str, Regex.Escape(from), to.Replace("$", "$$"), RegexOptions.IgnoreCase);
    }
}

ซึ่งจะให้ผลลัพธ์ที่คาดหวังต่อไปนี้:

Console.WriteLine("(heLLo) wOrld".ReplaceIgnoreCase("(hello) world", "Hi $1 Universe")); // Hi $1 Universe
Console.WriteLine("heLLo wOrld".ReplaceIgnoreCase("(hello) world", "Hi $1 Universe"));   // heLLo wOrld

อย่างไรก็ตามหากไม่มีการหลบหนีคุณจะได้รับสิ่งต่อไปนี้ซึ่งไม่ใช่พฤติกรรมที่คาดหวังจากตัวอักษรString.Replaceที่ไม่ตรงตามตัวพิมพ์ใหญ่ - เล็ก:

Console.WriteLine("(heLLo) wOrld".ReplaceIgnoreCase_NoEscaping("(hello) world", "Hi $1 Universe")); // (heLLo) wOrld
Console.WriteLine("heLLo wOrld".ReplaceIgnoreCase_NoEscaping("(hello) world", "Hi $1 Universe"));   // Hi heLLo Universe

1

ใช้งานไม่ได้: ฉันลาดเทถ่ายภาพสิ่งอื่นใดเร็วหรือง่ายกว่ามาก

public static class ExtensionMethodsString
{
    public static string Replace(this String thisString, string oldValue, string newValue, StringComparison stringComparison)
    {
        string working = thisString;
        int index = working.IndexOf(oldValue, stringComparison);
        while (index != -1)
        {
            working = working.Remove(index, oldValue.Length);
            working = working.Insert(index, newValue);
            index = index + newValue.Length;
            index = working.IndexOf(oldValue, index, stringComparison);
        }
        return working;
    }
}

ฉันไม่ทราบว่ามันเร็วขึ้น แต่กระชับไม่ใช้ค่าใช้จ่าย regex และปัญหาที่อาจเกิดขึ้นและใช้ StringComparison ในตัว
fvlinden

0

ฟังก์ชั่นด้านล่างคือการลบคำที่ตรงทั้งหมดเช่น (นี้) ออกจากชุดสตริง โดย Ravikant Sonare

private static void myfun()
{
    string mystring = "thiTHISThiss This THIS THis tThishiThiss. Box";
    var regex = new Regex("this", RegexOptions.IgnoreCase);
    mystring = regex.Replace(mystring, "");
    string[] str = mystring.Split(' ');
    for (int i = 0; i < str.Length; i++)
    {
        if (regex.IsMatch(str[i].ToString()))
        {
            mystring = mystring.Replace(str[i].ToString(), string.Empty);

        }
    }
    Console.WriteLine(mystring);
}

ฟังก์ชั่นนี้จะแทนที่สตริงทั้งหมดจากชุดสตริง ... โดย Ravikant Sonare,
Ravikant Sonare

0

ใช้ @Georgy Batalov ฉันมีปัญหาเมื่อใช้ตัวอย่างต่อไปนี้

สตริง original = "blah, DC = bleh, DC = blih, DC = bloh, DC = com"; สตริงที่ถูกแทนที่ = original.ReplaceIgnoreCase (", DC =", ".")

ด้านล่างเป็นวิธีที่ฉันเขียนส่วนขยายของเขาอีกครั้ง

public static string ReplaceIgnoreCase(this string source, string oldVale, 
string newVale)
    {
        if (source.IsNullOrEmpty() || oldVale.IsNullOrEmpty())
            return source;

        var stringBuilder = new StringBuilder();
        string result = source;

        int index = result.IndexOf(oldVale, StringComparison.InvariantCultureIgnoreCase);
        bool initialRun = true;

        while (index >= 0)
        {
            string substr = result.Substring(0, index);
            substr = substr + newVale;
            result = result.Remove(0, index);
            result = result.Remove(0, oldVale.Length);

            stringBuilder.Append(substr);

            index = result.IndexOf(oldVale, StringComparison.InvariantCultureIgnoreCase);
        }

        if (result.Length > 0)
        {
            stringBuilder.Append(result);
        }

        return stringBuilder.ToString();
    }

0

ด้านล่างเป็นทางเลือกในการแทนที่ตัวอักษรโดยไม่สนใจสตริงตัวอักษร

String thisString = "hello world"; 
String replaceString = "World";

//thisString.Replace("World", "csharp"); 
//below is the alternative to replace string ignoring character case

int start = StringUtils.indexOfIgnoreCase(thisString,replaceString);
String searchKey = thisString.substring(start, start+replaceString.length());
thisString= thisString.replaceAll(searchKey ,replaceString );
System.out.println(thisString);

//prints hello World

0

คุณสามารถลองRegexชั้นเรียนได้ด้วย

var regex = new Regex( "camel", RegexOptions.IgnoreCase ); var newSentence = regex.Replace( sentence, "horse" );


-3

ฉันชอบสิ่งนี้ - "Hello World". ToLower (). แทนที่ ("world", "csharp");


1
สิ่งนี้จะเป็นตัวพิมพ์เล็กทุกอย่างแม้แต่คำที่ไม่ควรเปลี่ยน
JJJ

เห็นได้ชัดว่าคุณสามารถใช้สิ่งนี้เฉพาะในกรณีที่คุณไม่ใส่ใจกับคดี
Harshal
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.