parte Come sostituire la*prima istanza*di una stringa in.NET?




vb net sostituire caratteri in una stringa (12)

Voglio sostituire la prima occorrenza in una determinata stringa.

Come posso realizzare questo in .NET?


string abc = "AAAAX1";

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

Per tutti coloro a cui non importa un riferimento a Microsoft.VisualBasic , c'è il metodo di Replace :

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

Uno degli overload di Regex.Replace richiede un int per "Il numero massimo di volte che la sostituzione può verificarsi". Ovviamente, l'utilizzo di Regex.Replace per la sostituzione del testo normale può sembrare eccessivo, ma è certamente conciso:

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

Regex.Replace , in particolare RegEx.Replace (string, string, int), è probabilmente quello che stai cercando. Quello o String.IndexOf che ti darà l'indice e quindi puoi tagliare e ricostruire la stringa con il nuovo testo che vuoi.

Un esempio che dimostra il secondo (come dimostrato da @David Humpohl ):

string str = "Hello WorldWorld";

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

...

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

Metodo di estensione C # che farà questo:

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

Godere


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

Esempio:

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

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

EDIT : come mentioned @itsmatt, c'è anche Regex.Replace (String, String, Int32), che può fare lo stesso, ma è probabilmente più costoso in fase di esecuzione, poiché utilizza un parser completo in cui il mio metodo trova una stringa e tre stringhe concatenazioni.

EDIT2 : se questa è un'attività comune, potresti voler rendere il metodo un metodo di estensione:

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

Utilizzando l'esempio sopra è ora possibile scrivere:

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

Prendendo in considerazione il "primo solo", forse:

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

?

O più in generale:

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

Poi:

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

using System.Text.RegularExpressions;

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

troverà il primo F in InputString e lo sostituirà con R


Questo esempio astrae le sottostringhe (ma è più lento), ma è probabilmente molto più veloce di una RegEx:

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

Suppone che AA debba essere sostituito solo se si trova all'inizio della stringa:

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

Se è necessario sostituire la prima occorrenza di AA , se la stringa inizia con o meno, andare con la soluzione di Marc.



Come ha detto il suo Regex.Replace è una buona scelta per questo, tuttavia, per rendere la sua risposta più completa, la compilerò con un esempio di codice:

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

Il terzo parametro, impostato su 1 in questo caso, è il numero di occorrenze del modello regex che si desidera sostituire nella stringa di input dall'inizio della stringa.

Speravo che questo potesse essere fatto con un sovraccarico di Regex.Replace statico, ma sfortunatamente sembra che tu abbia bisogno di un'istanza Regex per realizzarlo.





replace