Wie ersetze ich die * erste Instanz * einer Zeichenfolge in .NET?

Question

Ich möchte das erste Vorkommen in einer gegebenen Zeichenfolge ersetzen.

Wie kann ich dies in .NET erreichen?

Answer 1

Werfen Sie einen Blick auf Regex.Replace.

Answer 2

Regex.Replace, vor allem RegEx.Replace (string, string, int), ist wahrscheinlich das, wonach Sie suchen. That oder String.IndexOf, die Ihnen den Index geben und dann können Sie die Zeichenfolge mit dem neuen Text, den Sie möchten, ausschneiden und neu erstellen.

Ein Beispiel der letzteren demonstrieren (wie zuerst von @David Humpohl gezeigt):

string str = "Hello WorldWorld"; 

str = ReplaceFirst(str, "World", "StackOverflow "); 

... 

string ReplaceFirst(string text, string search, string replace) 
{ 
    int pos = text.IndexOf(search); 
    if (pos >= 0) 
    { 
     return text.Substring(0, pos) + replace + text.Substring(pos + search.Length); 
    } 
    return text; 
} 

Answer 3

string ReplaceFirst(string text, string search, string replace) 
{ 
    int pos = text.IndexOf(search); 
    if (pos < 0) 
    { 
    return text; 
    } 
    return text.Substring(0, pos) + replace + text.Substring(pos + search.Length); 
} 

Beispiel:

string str = "The brown brown fox jumps over the lazy dog"; 

str = ReplaceFirst(str, "brown", "quick"); 

EDIT: Als @itsmatt mentioned, gibt es auch Regex.Replace (String, String, Int32), die das gleiche tun können, aber zur Laufzeit wahrscheinlich teurer ist, da es ein voll funktionsfähiges verwendet Parser, wo meine Methode findet und drei String-Verkettungen.

EDIT2:

public static class StringExtension 
{ 
    public static string ReplaceFirst(this string text, string search, string replace) 
    { 
    // ...same as above... 
    } 
} 

Im obigen Beispiel ist es nun möglich, schreiben: Ist dies eine gemeinsame Aufgabe ist, könnte man die Methode eine Erweiterung Methode machen wollen

str = str.ReplaceFirst("brown", "quick"); 

Answer 4

In C# Syntax:

int loc = original.IndexOf(oldValue); 
if(loc < 0) { 
    return original; 
} 
return original.Remove(loc, oldValue.Length).Insert(loc, newValue); 

Answer 5

C# Erweiterung Methode, die wird dies tun:

public static class StringExt 
{ 
    public static string ReplaceFirstOccurrence(this string s, string oldValue, string newValue) 
    { 
     int i = s.IndexOf(oldValue); 
     return s.Remove(i, oldValue.Length).Insert(i, newValue);  
    } 
} 

Genießen

Answer 6

Und weil es auch ich würde, zu prüfen, VB.NET ist wie bis bieten:

Private Function ReplaceFirst(ByVal text As String, ByVal search As String, ByVal replace As String) As String 
    Dim pos As Integer = text.IndexOf(search) 
    If pos >= 0 Then 
     Return text.Substring(0, pos) + replace + text.Substring(pos + search.Length) 
    End If 
    Return text 
End Function 

Answer 7

Als itsmatt sagte Regex.Replace ein gut Um dies jedoch zu vervollständigen, fülle ich ihn mit einem Codebeispiel aus:

using System.Text.RegularExpressions; 
... 
Regex regex = new Regex("foo"); 
string result = regex.Replace("foo1 foo2 foo3 foo4", "bar", 1);    
// result = "bar1 foo2 foo3 foo4" 

Der dritte Parameter, in diesem Fall auf 1 gesetzt, ist die Anzahl der Vorkommen des Regex-Musters, das in der Eingabezeichenfolge vom Anfang der Zeichenfolge ersetzt werden soll.

Ich hatte gehofft, dass dies mit einer statischen Regex.Replace Überladung getan werden könnte, aber leider scheint es, dass Sie eine Regex-Instanz benötigen, um es zu erreichen.

Answer 8

using System.Text.RegularExpressions; 

RegEx MyRegEx = new RegEx("F"); 
string result = MyRegex.Replace(InputString, "R", 1); 

zuerst F in InputString und ersetzen sie durch R finden.

Answer 9

die "zunächst nur" Unter Berücksichtigung vielleicht:

int index = input.IndexOf("AA"); 
if (index >= 0) output = input.Substring(0, index) + "XQ" + 
    input.Substring(index + 2); 

?

Oder allgemeiner:

public static string ReplaceFirstInstance(this string source, 
    string find, string replace) 
{ 
    int index = source.IndexOf(find); 
    return index < 0 ? source : source.Substring(0, index) + replace + 
     source.Substring(index + find.Length); 
} 

Dann:

string output = input.ReplaceFirstInstance("AA", "XQ"); 

Answer 10

Geht davon aus, dass AA nur ersetzt werden muss, wenn es ganz am Anfang des Strings ist:

var newString; 
if(myString.StartsWith("AA")) 
{ 
    newString ="XQ" + myString.Substring(2); 
} 

Wenn Sie das erste Auftreten von AA ersetzen müssen, whet sie beginnt mit der string oder nicht, geh mit der lösung von Marc.

Answer 11

string abc = "AAAAX1"; 

      if(abc.IndexOf("AA") == 0) 
      { 
       abc.Remove(0, 2); 
       abc = "XQ" + abc; 
      } 

Answer 12

Einer der Überlastung von Regex.Replace nimmt eine int für „Die maximale Anzahl von Malen kann der Austausch stattfinden“. Offensichtlich kann mit Regex.Replace für Klartext Ersatz wie übertrieben erscheinen, aber es ist sicherlich prägnant:

string output = (new Regex("AA")).Replace(input, "XQ", 1); 

Answer 13

dieses Beispiel wird den Teil abstrahiert (aber langsamer), aber es ist wahrscheinlich viel schneller als ein RegEx:

var parts = contents.ToString().Split(new string[] { "needle" }, 2, StringSplitOptions.None); 
return parts[0] + "replacement" + parts[1]; 

Answer 14

Für alle, die keinen Verweis auf Microsoft.VisualBasic hat nichts dagegen, gibt es die Replace Method:

string result = Microsoft.VisualBasic.Strings.Replace("111", "1", "0", 2, 1); // "101"