Partilhar via

Como modificar o conteúdo da cadeia em C#

Este artigo demonstra várias técnicas para produzir um string modificando um existente string. Todas as técnicas demonstradas retornam o resultado das modificações como um novo string objeto. Para demonstrar que as cadeias original e modificada são instâncias distintas, os exemplos armazenam o resultado numa nova variável. Pode examinar o original string e o novo, modificados string ao executar cada exemplo.

Existem várias técnicas demonstradas neste artigo. Podes substituir o texto existente. Podes procurar padrões e substituir texto correspondente por outro texto. Podes tratar uma cadeia como uma sequência de caracteres. Também pode usar métodos de conveniência que eliminam espaços em branco. Escolha as técnicas que mais se adequam ao seu cenário.

Substituir texto

O código seguinte cria uma nova cadeia ao substituir 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 esta propriedade imutável das cadeias. Podes ver no exemplo anterior que a cadeia original, source, não está modificada. O String.Replace método cria um novo string que contém as modificações.

O Replace método pode substituir sequências ou caracteres individuais. Em ambos os casos, todas as ocorrências do texto solicitado são substituídas. O exemplo seguinte 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 origem mantém-se inalterada, e uma nova cadeia é devolvida com a substituição.

Remover espaço branco

Pode usar os String.Trimmétodos , String.TrimStart, e String.TrimEnd para remover qualquer espaço em branco inicial ou posterior. O código a seguir mostra um exemplo de cada um. A cadeia de origem não muda; estes métodos retornam uma nova cadeia 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

Podes remover texto de uma cadeia usando o String.Remove método. Este método remove o número especificado de caracteres começando num índice específico. O exemplo seguinte mostra como usar String.IndexOf seguido de Remove para remover texto de uma cadeia:

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

Pode usar expressões regulares para substituir padrões de correspondência de texto por texto novo, possivelmente definidos por um padrão. O exemplo seguinte usa a System.Text.RegularExpressions.Regex classe para encontrar um padrão numa sequência de origem e substituí-lo por uma capitalização correta. O Regex.Replace(String, String, MatchEvaluator, RegexOptions) método toma uma função que fornece a lógica da substituição como um dos seus argumentos. Neste exemplo, essa função LocalReplaceMatchCase é uma função local declarada dentro do método da amostra. LocalReplaceMatchCase usa a classe System.Text.StringBuilder para construir a cadeia de substituição com a capitalização adequada.

As expressões regulares são mais úteis para pesquisar e substituir texto que segue um padrão, em vez de texto conhecido. Para mais informações, veja Como pesquisar cadeias de caracteres. O padrão de pesquisa, "the\s", procura a palavra "the" seguida de um espaço em branco. Essa parte do padrão garante que não corresponde "ali" na cadeia de origem. Para mais informações sobre elementos de linguagem de expressão regular, veja Linguagem de Expressões Regulares - 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 devolve uma cadeia imutável com o conteúdo do StringBuilder objeto.

Modificação de personagens individuais

Pode produzir um array de caracteres a partir de uma string, modificar o conteúdo do array e depois criar uma nova string a partir do conteúdo modificado do array.

O exemplo seguinte mostra como substituir um conjunto de caracteres numa cadeia. Primeiro, utiliza o String.ToCharArray() método para criar um array de caracteres. Utiliza 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, é construída uma nova cadeia a partir do array de caracteres atualizado.

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

Gerar programaticamente conteúdos de cadeias de caracteres

Como as cadeias são imutáveis, os exemplos anteriores criam todos cadeias temporárias ou arrays de caracteres. Em cenários de alto desempenho, é recomendável evitar estas alocações de heap. O .NET fornece um String.Create método que permite preencher programaticamente o conteúdo de caracteres de uma cadeia através de um callback, evitando as alocações temporárias intermédias de cadeias.

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

Podes modificar uma string num bloco fixo com código inseguro, mas é fortemente desaconselhado modificar o conteúdo da string depois de esta ser criada. Fazer isso causa bugs imprevisíveis. Por exemplo, se alguém internar uma string com o mesmo conteúdo que a tua, recebe a tua cópia e não esperava que estivesses a modificar essa string.

Consulte também

  • Last updated on