Jak upravit obsah řetězce v jazyce C#

Tento článek ukazuje několik technik, jak úpravou existujícího string vytvořit string. Všechny techniky demonstrovaly vrácení výsledku úprav jako nového string objektu. Abychom si ukázali, že původní a změněné řetězce jsou odlišné instance, příklady ukládají výsledek do nové proměnné. Při každém spuštění každého příkladu můžete zkontrolovat původní string a nový, upravený string .

V tomto článku je znázorněno několik technik. Existující text můžete nahradit. Můžete vyhledat vzory a nahradit odpovídající text jiným textem. Řetězec můžete považovat za posloupnost znaků. Můžete také použít metody usnadnění, které odeberou prázdné znaky. Vyberte techniky, které nejlépe odpovídají vašemu scénáři.

Nahradit text

Následující kód vytvoří nový řetězec nahrazením existujícího textu náhradou.

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

// Replace one substring with another with String.Replace.
// Only exact matches are supported.
var replacement = source.Replace("mountains", "peaks");
Console.WriteLine($"The source string is <{source}>");
Console.WriteLine($"The updated string is <{replacement}>");

Předchozí kód ukazuje tuto neměnnou vlastnost řetězců. V předchozím příkladu můžete vidět, že původní řetězec source není změněn. Metoda String.Replace vytvoří novou string obsahující úpravy.

Metoda Replace může nahradit řetězce nebo jednotlivé znaky. V obou případech se nahradí každý výskyt požadovaného textu. Následující příklad nahrazuje všechny znaky ' ' znakem '_':

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

// Replace all occurrences of one char with another.
var replacement = source.Replace(' ', '_');
Console.WriteLine(source);
Console.WriteLine(replacement);

Zdrojový řetězec se nezmění a nový řetězec se vrátí s nahrazením.

Oříznout prázdné znaky

Pomocí metod String.Trim, String.TrimStart a String.TrimEnd můžete odebrat jakékoli počáteční nebo koncové prázdné znaky. Následující kód ukazuje příklad každého z nich. Zdrojový řetězec se nezmění; tyto metody vrátí nový řetězec s upraveným obsahem.

// Remove trailing and leading white space.
string source = "    I'm wider than I need to be.      ";
// Store the results in a new string variable.
var trimmedResult = source.Trim();
var trimLeading = source.TrimStart();
var trimTrailing = source.TrimEnd();
Console.WriteLine($"<{source}>");
Console.WriteLine($"<{trimmedResult}>");
Console.WriteLine($"<{trimLeading}>");
Console.WriteLine($"<{trimTrailing}>");

Odebrání textu

Text z řetězce můžete odebrat pomocí String.Remove metody. Tato metoda odebere zadaný počet znaků začínajících určitým indexem. Následující příklad ukazuje, jak použít String.IndexOf následovaný Remove odebráním textu z řetězce:

string source = "Many mountains are behind many clouds today.";
// Remove a substring from the middle of the string.
string toRemove = "many ";
string result = string.Empty;
int i = source.IndexOf(toRemove);
if (i >= 0)
{
    result= source.Remove(i, toRemove.Length);
}
Console.WriteLine(source);
Console.WriteLine(result);

Nahrazení odpovídajících vzorů

Regulární výrazy můžete použít k nahrazení vzorů porovnávání textu novým textem, případně definovaným vzorem. Následující příklad používá System.Text.RegularExpressions.Regex ke hledání vzoru ve zdrojovém řetězci a jeho nahrazení správným kapitalizací. Metoda Regex.Replace(String, String, MatchEvaluator, RegexOptions) přebírá funkci, která poskytuje logiku nahrazení jako jeden z jejích argumentů. V tomto příkladu je tato funkce LocalReplaceMatchCasemístní funkce deklarovaná uvnitř ukázkové metody. LocalReplaceMatchCase používá třídu System.Text.StringBuilder k sestavení náhradního řetězce se správnou kapitalizací.

Regulární výrazy jsou nejužitečnější pro vyhledávání a nahrazování textu, který se řídí vzorem, nikoli známým textem. Další informace naleznete v tématu Jak hledat řetězce. Hledaný vzor "the\s" vyhledá slovo "the" následované prázdným znakem. Tato část vzoru zajišťuje, že se ve zdrojovém řetězci neshoduje s "there". Další informace o elementech jazyka regulárních výrazů naleznete v tématu Jazyk regulárních výrazů – stručná referenční dokumentace.

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

// Use Regex.Replace for more flexibility.
// Replace "the" or "The" with "many" or "Many".
// using System.Text.RegularExpressions
string replaceWith = "many ";
source = System.Text.RegularExpressions.Regex.Replace(source, """the\s""", LocalReplaceMatchCase,
    System.Text.RegularExpressions.RegexOptions.IgnoreCase);
Console.WriteLine(source);

string LocalReplaceMatchCase(System.Text.RegularExpressions.Match matchExpression)
{
    // Test whether the match is capitalized
    if (Char.IsUpper(matchExpression.Value[0]))
    {
        // Capitalize the replacement string
        System.Text.StringBuilder replacementBuilder = new System.Text.StringBuilder(replaceWith);
        replacementBuilder[0] = Char.ToUpper(replacementBuilder[0]);
        return replacementBuilder.ToString();
    }
    else
    {
        return replaceWith;
    }
}

Metoda StringBuilder.ToString vrátí neměnný řetězec s obsahem objektu StringBuilder .

Úprava jednotlivých znaků

Z řetězce můžete vytvořit znakovou matici, upravit obsah pole a pak vytvořit nový řetězec z upraveného obsahu pole.

Následující příklad ukazuje, jak nahradit sadu znaků v řetězci. Nejprve použije metodu String.ToCharArray() k vytvoření pole znaků. Používá metodu IndexOf k nalezení počátečního indexu slova "fox". Další tři znaky se nahradí jiným slovem. Nakonec se vytvoří nový řetězec z aktualizovaného pole znaků.

string phrase = "The quick brown fox jumps over the fence";
Console.WriteLine(phrase);

char[] phraseAsChars = phrase.ToCharArray();
int animalIndex = phrase.IndexOf("fox");
if (animalIndex != -1)
{
    phraseAsChars[animalIndex++] = 'c';
    phraseAsChars[animalIndex++] = 'a';
    phraseAsChars[animalIndex] = 't';
}

string updatedPhrase = new string(phraseAsChars);
Console.WriteLine(updatedPhrase);

Vytváření obsahu řetězců prostřednictvím kódu programu

Vzhledem k tomu, že řetězce jsou neměnné, všechny předchozí příklady vytvářejí dočasné řetězce nebo pole znaků. Ve scénářích s vysokým výkonem je žádoucí se těmto přidělením haldy vyhnout. .NET poskytuje metodu String.Create, která umožňuje programově vyplnit znakový obsah řetězce prostřednictvím zpětného volání a vyhnout se dočasným přidělováním paměti pro řetězce.

// constructing a string from a char array, prefix it with some additional characters
char[] chars = [ 'a', 'b', 'c', 'd', '\0' ];
int length = chars.Length + 2;
string result = string.Create(length, chars, (Span<char> strContent, char[] charArray) =>
{
        strContent[0] = '0';
        strContent[1] = '1';
        for (int i = 0; i < charArray.Length; i++)
        {
            strContent[i + 2] = charArray[i];
        }
});

Console.WriteLine(result);

Řetězec můžete upravit v pevném bloku s nebezpečným kódem, ale důrazně nedoporučujeme upravovat obsah řetězce po vytvoření řetězce. Tím dojde k nepředvídatelným chybám. Pokud například někdo provládá řetězec, který má stejný obsah jako váš, získá vaši kopii a neočekává, že upravujete jeho řetězec.

Viz také

  • Last updated on