Comment remplacer la * première instance * d'une chaîne dans .NET?

Question

Je souhaite remplacer la première occurrence d'une chaîne donnée.

Comment puis-je accomplir cela dans .NET?

Answer 1

Jetez un oeil à Regex.Replace.

Answer 2

Regex.Replace, en particulier Regex.Replace (string, string, int), est probablement ce que vous cherchez. Cela ou String.IndexOf qui vous donnera l'index et ensuite vous pouvez couper et reconstruire la chaîne avec le nouveau texte que vous voulez.

Un exemple illustrant cette dernière (comme première mise en évidence par @David Humpohl):

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); 
} 

Exemple:

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

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

EDIT: Comme @itsmatt mentioned, il y a aussi Regex.Replace (String, String, Int32), qui peut faire la même chose, mais est probablement plus cher à l'exécution, car il utilise une fonctionnalité complète analyseur où ma méthode fait une recherche et trois concaténations de chaîne.

EDIT2: Si cela est une tâche commune, vous voudrez peut-être faire la méthode une méthode d'extension:

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

En utilisant l'exemple ci-dessus, il est maintenant possible d'écrire:

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

Answer 4

En syntaxe C#:

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

Answer 5

Méthode d'extension C# fera ceci:

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);  
    } 
} 

Profitez

Answer 6

Et parce qu'il ya aussi VB.NET à considérer, je voudrais offrir:

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

Comme itsmatt dit Regex.Replace est un bon choix pour ce faire cependant sa réponse plus complète, je vais le remplir avec un exemple de code:

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

Le troisième paramètre, défini sur 1 dans ce cas, est le nombre d'occurrences du modèle d'expression régulière que vous souhaitez remplacer dans la chaîne d'entrée à partir du début de la chaîne.

J'espérais que cela pourrait être fait avec une surcharge statique Regex.Replace mais malheureusement, il semble que vous ayez besoin d'une instance de Regex pour l'accomplir.

Answer 8

using System.Text.RegularExpressions; 

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

trouvera d'abord dans FInputString et le remplacer par R.

Answer 9

Prendre la "première que" compte, peut-être:

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

?

Ou plus généralement:

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); 
} 

Puis:

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

Answer 10

Suppose que AA ne doit être remplacée si elle est au début de la chaîne:

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

Si vous devez remplacer la première occurrence de AA, aiguiser elle la chaîne commence avec ou pas, aller avec la solution de Marc.

Answer 11

string abc = "AAAAX1"; 

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

Answer 12

L'une des surcharges de Regex.Replace prend un int pour « Le nombre maximum de fois que le remplacement peut se produire ». De toute évidence, à l'aide Regex.Replace pour le remplacement de texte brut peut sembler exagéré, mais il est certainement concis:

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

Answer 13

Cet exemple fait abstraction des sous-chaînes (mais est plus lent), mais elle est probablement beaucoup plus rapide qu'un RegEx:

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

Answer 14

pour tous ceux qui ne me dérange pas une référence à Microsoft.VisualBasic, il est le Replace Method:

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