Como: Modificar o conteúdo de uma cadeia de caracteres em C#How to: Modify string contents in C#

Este artigo demonstra várias técnicas para produzir um string modificando um string existente.This article demonstrates several techniques to produce a string by modifying an existing string. Todas as técnicas demonstradas retornam o resultado das modificações como um novo objeto string.All the techniques demonstrated return the result of the modifications as a new string object. Para demonstrar isso claramente, todos os exemplos armazenam o resultado em uma nova variável.To clearly demonstrate this, the examples all store the result in a new variable. Em seguida, você pode examinar o string original e o string resultante da modificação quando você executa cada exemplo.You can then examine both the original string and the string resulting from the modification when you run each example.

Observação

Os exemplos de C# neste artigo são executados no executador de código embutido Try.NET e no playground.The C# examples in this article run in the Try.NET inline code runner and playground. Clique no botão Executar para executar um exemplo em uma janela interativa.Select the Run button to run an example in an interactive window. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente.Once you execute the code, you can modify it and run the modified code by selecting Run again. O código modificado será executado na janela interativa ou, se a compilação falhar, a janela interativa exibirá todos as mensagens de erro do compilador C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Há várias técnicas demonstradas neste artigo.There are several techniques demonstrated in this article. Você pode substituir o texto existente.You can replace existing text. Você pode procurar padrões e substituir o texto correspondente com outro texto.You can search for patterns and replace matching text with other text. Você pode tratar uma cadeia de caracteres como uma sequência de caracteres.You can treat a string as a sequence of characters. Você também pode usar métodos de conveniência que removem o espaço em branco.You can also use convenience methods that remove white space. Você deve escolher as técnicas que mais se aproximam do seu cenário.You should choose the techniques that most closely match your scenario.

Substituir textoReplace text

O código a seguir cria uma nova cadeia de caracteres, substituindo o texto existente por um substituto.The following code creates a new string by replacing existing text with a substitute.

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 immutable de cadeias de caracteres.The preceding code demonstrates this immutable property of strings. Você pode ver no exemplo anterior que a cadeia de caracteres original, source, não é modificada.You can see in the preceding example that the original string, source, is not modified. O método String.Replace cria uma nova string contendo as modificações.The String.Replace method creates a new string containing the modifications.

O método Replace pode substituir cadeias de caracteres ou caracteres únicos.The Replace method can replace either strings or single characters. Em ambos os casos, todas as ocorrências do texto pesquisado são substituídas.In both cases, every occurrence of the sought text is replaced. O exemplo a seguir substitui todos os caracteres ' ' com '_':The following example replaces all ' ' characters with '_':

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 não é alterada e uma nova cadeia de caracteres é retornada com a substituição.The source string is unchanged, and a new string is returned with the replacement.

Cortar espaço em brancoTrim white space

Você pode usar os métodos String.Trim, String.TrimStart e String.TrimEnd para remover espaços em branco à esquerda ou à direita.You can use the String.Trim, String.TrimStart, and String.TrimEnd methods to remove any leading or trailing white space. O código a seguir mostra um exemplo de cada um desses casos.The following code shows an example of each. A cadeia de caracteres de origem não é alterada; esses métodos retornam uma nova cadeia de caracteres com o conteúdo modificado.The source string does not change; these methods return a new string with the modified contents.

// 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 textoRemove text

Você pode remover texto de uma cadeia de caracteres usando o método String.Remove.You can remove text from a string using the String.Remove method. Esse método remove um número de caracteres começando em um índice específico.This method removes a number of characters starting at a specific index. O exemplo a seguir mostra como usar String.IndexOf seguido por Remove para remover texto de uma cadeia de caracteres:The following example shows how to use String.IndexOf followed by Remove to remove text from a string:

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 correspondentesReplace matching patterns

Você pode usar expressões regulares para substituir padrões correspondentes de texto com um novo texto, possivelmente definido por um padrão.You can use regular expressions to replace text matching patterns with new text, possibly defined by a pattern. O exemplo a seguir usa a classe System.Text.RegularExpressions.Regex para localizar um padrão em uma cadeia de caracteres de origem e substituí-lo pela capitalização correta.The following example uses the System.Text.RegularExpressions.Regex class to find a pattern in a source string and replace it with proper capitalization. O método Regex.Replace(String, String, MatchEvaluator, RegexOptions) usa uma função que fornece a lógica de substituição como um de seus argumentos.The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method takes a function that provides the logic of the replacement as one of its arguments. Neste exemplo, essa função LocalReplaceMatchCase é uma função local declarada dentro do método de exemplo.In this example, that function, LocalReplaceMatchCase is a local function declared inside the sample method. LocalReplaceMatchCase usa a classe System.Text.StringBuilder para criar a cadeia de caracteres de substituição com a capitalização correta.LocalReplaceMatchCase uses the System.Text.StringBuilder class to build the replacement string with proper capitalization.

Expressões regulares são mais úteis para localizar e substituir texto que segue um padrão, em vez de texto conhecido.Regular expressions are most useful for searching and replacing text that follows a pattern, rather than known text. Consulte Como pesquisar cadeias de caracteres para obter mais detalhes.See How to: search strings for more details. O padrão de pesquisa "the\s" procura a palavra "the" seguida por um caractere de espaço em branco.The search pattern, "the\s" searches for the word "the" followed by a white-space character. Essa parte do padrão garante que isso não corresponda a "there" na cadeia de caracteres de origem.That part of the pattern ensures that it doesn't match "there" in the source string. Para obter mais informações sobre elementos de linguagem de expressão regular, consulte Linguagem de expressão regular – referência rápida.For more information on regular expression language elements, see Regular Expression Language - Quick Reference.

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 método StringBuilder.ToString retorna uma cadeia de caracteres imutável com o conteúdo no objeto StringBuilder.The StringBuilder.ToString method returns an immutable string with the contents in the StringBuilder object.

Modificar caracteres individuaisModifying individual characters

Você pode produzir uma matriz de caracteres de uma cadeia de caracteres, modificar o conteúdo da matriz e, em seguida, criar uma nova cadeia de caracteres com base no conteúdo modificado da matriz.You can produce a character array from a string, modify the contents of the array, and then create a new string from the modified contents of the array.

O exemplo a seguir mostra como substituir um conjunto de caracteres em uma cadeia de caracteres.The following example shows how to replace a set of characters in a string. Primeiro, ele usa o método ToCharArray() para criar uma matriz de caracteres.First, it uses the ToCharArray() method to create an array of characters. Ele usa o método IndexOf para localizar o índice inicial da palavra "fox".It uses the IndexOf method to find the starting index of the word "fox." Os próximos três caracteres são substituídos por uma palavra diferente.The next three characters are replaced with a different word. Por fim, uma nova cadeia de caracteres é construída com a matriz de caracteres atualizada.Finally, a new string is constructed from the updated character array.

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

Modificações não seguras à cadeia de caracteresUnsafe modifications to string

Usando código não seguro, é possível modificar uma cadeia de caracteres "no local" depois que ela é criada.Using unsafe code, you can modify a string "in place" after it has been created. Código não seguro usa muitos dos recursos do .NET projetados para minimizar determinados tipos de bugs no código.Unsafe code bypasses many of the features of .NET designed to minimize certain types of bugs in code. Você precisa usar o código não seguro para modificar uma cadeia de caracteres em vigor porque a classe de cadeia de caracteres foi projetada como um tipo immutable.You need to use unsafe code to modify a string in place because the string class is designed as an immutable type. Depois de ela ser criada, seu valor não é alterado.Once it has been created, its value does not change. O código não seguro contorna a essa propriedade, acessando e modificando a memória usada por um string sem usar métodos string normais.Unsafe code circumvents this property by accessing and modifying the memory used by a string without using normal string methods. O exemplo a seguir é fornecido para as raras situações em que você deseja modificar uma cadeia de caracteres no local usando código não seguro.The following example is provided for those rare situations where you want to modify a string in-place using unsafe code. O exemplo mostra como usar a palavra-chave fixed.The example shows how to use the fixed keyword. A palavra-chave fixed impede que o GC (coletor de lixo) mova o objeto de cadeia de caracteres na memória enquanto o código acessa a memória usando o ponteiro não seguro.The fixed keyword prevents the garbage collector (GC) from moving the string object in memory while code accesses the memory using the unsafe pointer. Ele também demonstra um possível efeito colateral das operações não seguras em cadeias de caracteres, que resultam da forma com que o compilador C# armazena (interna) as cadeias de caracteres internamente.It also demonstrates one possible side effect of unsafe operations on strings that results from the way that the C# compiler stores (interns) strings internally. Em geral, você não deve usar essa técnica, a menos que seja absolutamente necessário.In general, you shouldn't use this technique unless it is absolutely necessary. É possível aprender mais sobre não seguro e fixo nos artigos.You can learn more in the articles on unsafe and fixed. A referência à API para Intern inclui informações sobre centralização de cadeia de caracteres.The API reference for Intern includes information on string interning.

unsafe
{
    // Compiler will store (intern) 
    // these strings in same location.
    string helloOne = "Hello";
    string helloTwo = "Hello";

    // Change one string using unsafe code.
    fixed (char* p = helloOne)
    {
        p[0] = 'C';
    }

    //  Both strings have changed.
    Console.WriteLine(helloOne);
    Console.WriteLine(helloTwo);
}

Você pode experimentar estes exemplos examinando o código em nosso repositório GitHub.You can try these samples by looking at the code in our GitHub repository. Ou então, você pode baixar os exemplos como um arquivo zip.Or you can download the samples as a zip file.

Consulte tambémSee also