Modificare il contenuto della stringa in C#

Tip

Questo articolo fa parte della sezione Nozioni fondamentali per gli sviluppatori che già conoscono almeno un linguaggio di programmazione e stanno imparando C#. Se non si ha familiarità con la programmazione, iniziare prima con le esercitazioni introduttive .

Venire da un'altra lingua? Come Java e JavaScript, le stringhe C# sono immutabili: metodi come Replace e Trim restituiscono una nuova stringa anziché modificare l'originale. Gli schemi qui sono paralleli ai metodi String in quei linguaggi.

Un C# stringnon è modificabile, il che significa che il relativo contenuto non cambia mai dopo averlo creato. Ogni metodo che sembra modificare una stringa restituisce effettivamente un nuovo string con le modifiche, lasciando intatto l'originale. Gli esempi in questo articolo archiviano ogni risultato in una nuova variabile in modo da poter visualizzare sia l'origine che il valore modificato.

Scegliere la tecnica corrispondente allo scenario: sostituire il testo noto, tagliare gli spazi vuoti, rimuovere un intervallo di caratteri, sostituire il testo che corrisponde a un criterio o modificare singoli caratteri.

Sostituire il testo noto

Il String.Replace metodo sostituisce ogni occorrenza di una stringa con un'altra e restituisce il risultato come nuova stringa:

string source = "The mountains are behind the clouds today.";

// Replace returns a new string; the original is unchanged.
string updated = source.Replace("mountains", "peaks");

Console.WriteLine(source);
// => The mountains are behind the clouds today.
Console.WriteLine(updated);
// => The peaks are behind the clouds today.

La stringa originale è invariata, che dimostra l'immutabilità: Replace crea una nuova stringa con la sostituzione.

Replace ha anche un sovraccarico che scambia singoli caratteri. L'esempio seguente sostituisce ogni spazio con un carattere di sottolineatura:

string source = "The mountains are behind the clouds today.";

// Replace every occurrence of one character with another.
string updated = source.Replace(' ', '_');

Console.WriteLine(updated);
// => The_mountains_are_behind_the_clouds_today.

Entrambi i sovraccarichi sostituiscono ogni corrispondenza nella stringa, non solo la prima. Sia che passi un singolo carattere o una stringa, Replace sostituisce tutte le occorrenze in una sola chiamata.

Tagliare gli spazi vuoti

Usare String.Trim, String.TrimStarte String.TrimEnd per rimuovere spazi vuoti iniziali o finali. Ogni metodo restituisce una nuova stringa:

string source = "    I'm wider than I need to be.      ";

// Each method returns a new string with whitespace removed.
Console.WriteLine($"<{source.Trim()}>");
// => <I'm wider than I need to be.>
Console.WriteLine($"<{source.TrimStart()}>");
// => <I'm wider than I need to be.      >
Console.WriteLine($"<{source.TrimEnd()}>");
// => <    I'm wider than I need to be.>

Rimuovere un intervallo di caratteri

Il String.Remove metodo elimina un numero di caratteri a partire da un indice. Combinarlo con String.IndexOf per individuare il testo da rimuovere:

string source = "Many mountains are behind many clouds today.";
string toRemove = "many ";

// Find the text, then remove that span by index and length.
int index = source.IndexOf(toRemove);
string result = index >= 0
    ? source.Remove(index, toRemove.Length)
    : source;

Console.WriteLine(result);
// => Many mountains are behind clouds today.

Sostituire il testo che corrisponde a un criterio

Quando è necessario sostituire il testo che segue un criterio anziché una stringa esatta, usare espressioni regolari. Il Regex.Replace metodo accetta una funzione che calcola ogni sostituzione, in modo da poter mantenere i dettagli, ad esempio la maiuscola originale. Il modello the\s corrisponde a "the" seguito da un carattere di spaziatura, il che impedisce che corrisponda a "there":

string source = "The mountains are still there behind the clouds today.";

// Replace "the" or "The" followed by whitespace, preserving the original case.
// The \s in the pattern keeps "there" from matching.
string result = Regex.Replace(
    source,
    """the\s""",
    match => char.IsUpper(match.Value[0]) ? "Many " : "many ",
    RegexOptions.IgnoreCase);

Console.WriteLine(result);
// => Many mountains are still there behind many clouds today.

Per la ricerca basata su criteri anziché la sostituzione, vedere Cercare stringhe in C#. Per la sintassi delle espressioni regolari, vedere Informazioni di riferimento rapido sul linguaggio delle espressioni regolari.

Modificare i singoli caratteri

Per modificare i caratteri in base alla posizione, copiare la stringa in un Span<T> di caratteri, modificare l'intervallo e quindi crearne una nuova. L'esempio seguente trova la parola "fox" e la sostituisce con "cat":

string phrase = "The quick brown fox jumps over the fence.";

// A string is immutable, so copy it into a Span<char> to edit in place.
Span<char> characters = stackalloc char[phrase.Length];
phrase.CopyTo(characters);
int index = phrase.IndexOf("fox");
if (index != -1)
{
    characters[index] = 'c';
    characters[index + 1] = 'a';
    characters[index + 2] = 't';
}

// Build a new string from the modified characters.
string updated = new string(characters);
Console.WriteLine(updated);
// => The quick brown cat jumps over the fence.

Per scenari ad alte prestazioni che evitano allocazioni intermedie, il runtime fornisce API di livello inferiore, String.Createad esempio . Queste tecniche sono avanzate; per il codice quotidiano, i metodi in questo articolo sono la scelta giusta.

Vedere anche

  • Last updated on