Como modificar o conteúdo da cadeia de caracteres em C#

Artigo
03/05/2024

Este artigo demonstra várias técnicas para produzir um modificando um string arquivo string. Todas as técnicas demonstradas retornam o resultado das modificações como um novo string objeto. Para demonstrar que as cadeias de caracteres originais e modificadas são instâncias distintas, os exemplos armazenam o resultado em uma nova variável. Você pode examinar o original string e o novo, modificados string ao executar cada exemplo.

Nota

Os exemplos de C# neste artigo são executados no Try.NET corredor de código embutido e playground. Selecione o botão Executar para executar um exemplo em uma janela interativa. Depois de executar o código, você pode modificá-lo e executar o código modificado selecionando Executar novamente. O código modificado é executado na janela interativa ou, se a compilação falhar, a janela interativa exibe todas as mensagens de erro do compilador C#.

Existem várias técnicas demonstradas neste artigo. Você pode substituir o texto existente. Você pode pesquisar padrões e substituir o texto correspondente por outro texto. Você pode tratar uma cadeia de caracteres como uma sequência de caracteres. Você também pode usar métodos de conveniência que removem o espaço em branco. Escolha as técnicas que mais se aproximam do seu cenário.

Substituir texto

O código a seguir cria uma nova cadeia de caracteres substituindo o texto existente por um substituto.

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

O código anterior demonstra essa propriedade imutável de strings. Você pode ver no exemplo anterior que a cadeia de caracteres original, source, não é modificada. O String.Replace método cria um novo string contendo as modificações.

O Replace método pode substituir cadeias de caracteres ou caracteres únicos. Em ambos os casos, todas as ocorrências do texto solicitado são substituídas. O exemplo a seguir substitui todos os caracteres ' ' por '_':

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

A cadeia de caracteres de origem permanece inalterada e uma nova cadeia de caracteres é retornada com a substituição.

Cortar espaço em branco

Você pode usar os String.Trimmétodos , String.TrimStarte para String.TrimEnd remover qualquer espaço em branco à esquerda ou à direita. O código a seguir mostra um exemplo de cada um. A cadeia de caracteres de origem não é alterada; Esses métodos retornam uma nova cadeia de caracteres com o conteúdo modificado.

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

Remover texto

Você pode remover texto de uma cadeia de caracteres usando o String.Remove método. Este método remove um número de caracteres começando em um índice específico. O exemplo a seguir mostra como usar String.IndexOf seguido por Remove para remover texto de uma cadeia de caracteres:

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

Substituir padrões correspondentes

Você pode usar expressões regulares para substituir padrões de correspondência de texto por um novo texto, possivelmente definido por um padrão. O exemplo a seguir usa a System.Text.RegularExpressions.Regex classe para localizar um padrão em uma cadeia de caracteres de origem e substituí-lo por maiúsculas adequadas. O Regex.Replace(String, String, MatchEvaluator, RegexOptions) método assume uma função que fornece a lógica da substituição como um dos seus argumentos. Neste exemplo, LocalReplaceMatchCase essa função é uma função local declarada dentro do método de amostra. LocalReplaceMatchCase usa a System.Text.StringBuilder classe para criar a cadeia de caracteres de substituição com maiúsculas adequadas.

As expressões regulares são mais úteis para pesquisar e substituir texto que segue um padrão, em vez de texto conhecido. Para obter mais informações, consulte Como pesquisar cadeias de caracteres. O padrão de pesquisa, "the\s" procura a palavra "the" seguida por um caractere de espaço em branco. Essa parte do padrão garante que ele não corresponda "lá" na cadeia de caracteres de origem. Para obter mais informações sobre elementos de linguagem de expressão regular, consulte Linguagem de expressão regular - referência rápida.

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

O StringBuilder.ToString método retorna uma cadeia de caracteres imutável com o conteúdo no StringBuilder objeto.

Modificando caracteres individuais

Você pode produzir uma matriz de caracteres a partir de uma cadeia de caracteres, modificar o conteúdo da matriz e, em seguida, criar uma nova cadeia de caracteres a partir do conteúdo modificado da matriz.

O exemplo a seguir mostra como substituir um conjunto de caracteres em uma cadeia de caracteres. Primeiro, ele usa o String.ToCharArray() método para criar uma matriz de caracteres. Ele usa o IndexOf método para encontrar o índice inicial da palavra "raposa". Os três caracteres seguintes são substituídos por uma palavra diferente. Finalmente, uma nova cadeia de caracteres é construída a partir da matriz de caracteres atualizada.

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

Construa programaticamente conteúdo de cadeia de caracteres

Como as cadeias de caracteres são imutáveis, todos os exemplos anteriores criam cadeias de caracteres temporárias ou matrizes de caracteres. Em cenários de alto desempenho, pode ser desejável evitar essas alocações de heap. O .NET Core fornece um String.Create método que permite preencher programaticamente o conteúdo de caracteres de uma cadeia de caracteres por meio de um retorno de chamada, evitando as alocações temporárias intermediárias de cadeia de caracteres.

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

Você pode modificar uma cadeia de caracteres em um bloco fixo com código não seguro, mas é fortemente desencorajado modificar o conteúdo da cadeia de caracteres depois que uma cadeia de caracteres é criada. Fazê-lo irá quebrar as coisas de formas imprevisíveis. Por exemplo, se alguém estagiar uma cadeia de caracteres que tenha o mesmo conteúdo que a sua, receberá sua cópia e não esperará que você esteja modificando a cadeia de caracteres.

Partilhar via