Substituições em expressões regulares
As substituições são elementos de linguagem que são reconhecidos apenas dentro de padrões de substituição. Eles usam um padrão de expressão regular para definir todo ou parte do texto que deve substituir o texto correspondente na cadeia de caracteres de entrada. O padrão de substituição pode consistir em uma ou mais substituições juntamente com caracteres literais. Os padrões de substituição são fornecidos para sobrecargas do Regex.Replace método que têm um replacement parâmetro e para o Match.Result método. Os métodos substituem o padrão correspondente pelo padrão definido pelo replacement parâmetro.
O .NET define os elementos de substituição listados na tabela a seguir.
| Substituição | Description |
|---|---|
| $ número | Inclui a última substring correspondida pelo grupo de captura identificado por número, onde number é um valor decimal, na string de substituição. Para obter mais informações, consulte Substituindo um grupo numerado. |
| ${ nome } | Inclui a última subcadeia de caracteres correspondida pelo grupo nomeado designado pelo (?<nome> ) na cadeia de caracteres de substituição. Para obter mais informações, consulte Substituindo um grupo nomeado. |
| $$ | Inclui um único literal "$" na cadeia de caracteres de substituição. Para obter mais informações, consulte Substituindo um símbolo "$". |
| $& | Inclui uma cópia de toda a correspondência na cadeia de caracteres de substituição. Para obter mais informações, consulte Substituindo a correspondência inteira. |
| $` | Inclui todo o texto da cadeia de caracteres de entrada antes da correspondência na cadeia de caracteres de substituição. Para obter mais informações, consulte Substituindo o texto antes da correspondência. |
| $' | Inclui todo o texto da cadeia de caracteres de entrada após a correspondência na cadeia de caracteres de substituição. Para obter mais informações, consulte Substituindo o texto após a correspondência. |
| $+ | Inclui o último grupo capturado na cadeia de caracteres de substituição. Para obter mais informações, consulte Substituindo o último grupo capturado. |
| $_ | Inclui toda a cadeia de caracteres de entrada na cadeia de caracteres de substituição. Para obter mais informações, consulte Substituindo toda a cadeia de caracteres de entrada. |
Elementos de substituição e padrões de substituição
As substituições são as únicas construções especiais reconhecidas em um padrão de substituição. Nenhum dos outros elementos de linguagem de expressão regular, incluindo escapes de caracteres e o ponto (.), que corresponde a qualquer caractere, é suportado. Da mesma forma, os elementos da linguagem de substituição são reconhecidos apenas em padrões de substituição e nunca são válidos em padrões de expressão regular.
O único caractere que pode aparecer em um padrão de expressão regular ou em uma substituição é o $ caractere, embora tenha um significado diferente em cada contexto. Em um padrão de expressão regular, $ é uma âncora que corresponde ao final da cadeia de caracteres. Em um padrão de substituição, $ indica o início de uma substituição.
Nota
Para funcionalidade semelhante a um padrão de substituição dentro de uma expressão regular, use uma referência de retorno. Para obter mais informações sobre backreferences, consulte Construções de backreference.
Substituindo um grupo numerado
O $elemento de linguagem numérica inclui a última substring correspondida pelo grupo de captura de número na cadeia de caracteres de substituição, onde number é o índice do grupo de captura. Por exemplo, o padrão $1 de substituição indica que a substring correspondente deve ser substituída pelo primeiro grupo capturado. Para obter mais informações sobre grupos de captura numerados, consulte Agrupando construções.
Todos os dígitos que se seguem $ são interpretados como pertencentes ao grupo numérico . Se essa não for a sua intenção, você pode substituir um grupo nomeado. Por exemplo, você pode usar a cadeia de caracteres ${1}1 de substituição em vez de $11 definir a cadeia de caracteres de substituição como o valor do primeiro grupo capturado junto com o número "1". Para obter mais informações, consulte Substituindo um grupo nomeado.
A captura de grupos que não são explicitamente atribuídos nomes usando a sintaxe de nome>) é numerada da esquerda para a direita, (?<começando em um. Os grupos nomeados também são numerados da esquerda para a direita, começando em um maior do que o índice do último grupo sem nome. Por exemplo, na expressão (\w)(?<digit>\d)regular , o índice do digit grupo nomeado é 2.
Se number não especificar um grupo de captura válido definido no padrão de expressão regular, $number será interpretado como uma sequência de caracteres literal usada para substituir cada correspondência.
O exemplo a seguir usa a $substituição de número para remover o símbolo de moeda de um valor decimal. Ele remove símbolos de moeda encontrados no início ou no final de um valor monetário e reconhece os dois separadores decimais mais comuns ("." e ",").
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*";
string replacement = "$1";
string input = "$16.32 12.19 £16.29 €18.29 €18,29";
string result = Regex.Replace(input, pattern, replacement);
Console.WriteLine(result);
}
}
// The example displays the following output:
// 16.32 12.19 16.29 18.29 18,29
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*"
Dim replacement As String = "$1"
Dim input As String = "$16.32 12.19 £16.29 €18.29 €18,29"
Dim result As String = Regex.Replace(input, pattern, replacement)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16.32 12.19 16.29 18.29 18,29
O padrão \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* de expressão regular é definido conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\p{Sc}* |
Corresponder a zero ou mais caracteres de símbolo de moeda. |
\s? |
Corresponder a zero ou a um caractere de espaço em branco. |
\d+ |
Corresponder a um ou mais dígitos decimais. |
[.,]? |
Corresponder a zero ou a um ponto ou vírgula. |
\d* |
Corresponder a zero ou mais dígitos decimais. |
(\s?\d+[.,]?\d*) |
Corresponder a um espaço em branco seguido por um ou mais dígitos decimais, seguido por zero ou um ponto ou vírgula, seguido por zero ou mais dígitos decimais. Este é o primeiro grupo de captura. Como o padrão de substituição é $1, a chamada para o Regex.Replace método substitui toda a substring correspondente por esse grupo capturado. |
Substituindo um grupo nomeado
O ${elemento name} language substitui a última substring correspondida pelo grupo de captura de nome, onde name é o nome de um grupo de captura definido pelo>)(?<elemento name language. Para obter mais informações sobre grupos de captura nomeados, consulte Agrupando construções.
Se name não especificar um grupo de captura nomeado válido definido no padrão de expressão regular, mas consistir em dígitos, ${name} será interpretado como um grupo numerado.
Se name não especificar um grupo de captura nomeado válido nem um grupo de captura numerado válido definido no padrão de expressão regular, ${name} será interpretado como uma sequência de caracteres literal usada para substituir cada correspondência.
O exemplo a seguir usa a ${substituição de nome} para remover o símbolo de moeda de um valor decimal. Ele remove símbolos de moeda encontrados no início ou no final de um valor monetário e reconhece os dois separadores decimais mais comuns ("." e ",").
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*";
string replacement = "${amount}";
string input = "$16.32 12.19 £16.29 €18.29 €18,29";
string result = Regex.Replace(input, pattern, replacement);
Console.WriteLine(result);
}
}
// The example displays the following output:
// 16.32 12.19 16.29 18.29 18,29
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*"
Dim replacement As String = "${amount}"
Dim input As String = "$16.32 12.19 £16.29 €18.29 €18,29"
Dim result As String = Regex.Replace(input, pattern, replacement)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16.32 12.19 16.29 18.29 18,29
O padrão \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* de expressão regular é definido conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\p{Sc}* |
Corresponder a zero ou mais caracteres de símbolo de moeda. |
\s? |
Corresponder a zero ou a um caractere de espaço em branco. |
\d+ |
Corresponder a um ou mais dígitos decimais. |
[.,]? |
Corresponder a zero ou a um ponto ou vírgula. |
\d* |
Corresponder a zero ou mais dígitos decimais. |
(?<amount>\s?\d[.,]?\d*) |
Corresponder a um espaço em branco, seguido por um ou mais dígitos decimais, seguido por zero ou um ponto ou vírgula, seguido por zero ou mais dígitos decimais. Este é o grupo de captura chamado amount. Como o padrão de substituição é ${amount}, a chamada para o Regex.Replace método substitui toda a substring correspondente por esse grupo capturado. |
Substituindo um caractere "$"
A $$ substituição insere um caractere "$" literal na cadeia de caracteres substituída.
O exemplo a seguir usa o NumberFormatInfo objeto para determinar o símbolo de moeda da cultura atual e seu posicionamento em uma cadeia de caracteres de moeda. Em seguida, ele cria um padrão de expressão regular e um padrão de substituição dinamicamente. Se o exemplo for executado em um computador cuja cultura atual é en-US, ele gerará o padrão \b(\d+)(\.(\d+))? de expressão regular e o padrão $$ $1$2de substituição. O padrão de substituição substitui o texto correspondente por um símbolo de moeda e um espaço seguido pelo primeiro e segundo grupos capturados.
using System;
using System.Globalization;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
// Define array of decimal values.
string[] values= { "16.35", "19.72", "1234", "0.99"};
// Determine whether currency precedes (True) or follows (False) number.
bool precedes = NumberFormatInfo.CurrentInfo.CurrencyPositivePattern % 2 == 0;
// Get decimal separator.
string cSeparator = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator;
// Get currency symbol.
string symbol = NumberFormatInfo.CurrentInfo.CurrencySymbol;
// If symbol is a "$", add an extra "$".
if (symbol == "$") symbol = "$$";
// Define regular expression pattern and replacement string.
string pattern = @"\b(\d+)(" + cSeparator + @"(\d+))?";
string replacement = "$1$2";
replacement = precedes ? symbol + " " + replacement : replacement + " " + symbol;
foreach (string value in values)
Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement));
}
}
// The example displays the following output:
// 16.35 --> $ 16.35
// 19.72 --> $ 19.72
// 1234 --> $ 1234
// 0.99 --> $ 0.99
Imports System.Globalization
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
' Define array of decimal values.
Dim values() As String = {"16.35", "19.72", "1234", "0.99"}
' Determine whether currency precedes (True) or follows (False) number.
Dim precedes As Boolean = (NumberFormatInfo.CurrentInfo.CurrencyPositivePattern Mod 2 = 0)
' Get decimal separator.
Dim cSeparator As String = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator
' Get currency symbol.
Dim symbol As String = NumberFormatInfo.CurrentInfo.CurrencySymbol
' If symbol is a "$", add an extra "$".
If symbol = "$" Then symbol = "$$"
' Define regular expression pattern and replacement string.
Dim pattern As String = "\b(\d+)(" + cSeparator + "(\d+))?"
Dim replacement As String = "$1$2"
replacement = If(precedes, symbol + " " + replacement, replacement + " " + symbol)
For Each value In values
Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement))
Next
End Sub
End Module
' The example displays the following output:
' 16.35 --> $ 16.35
' 19.72 --> $ 19.72
' 1234 --> $ 1234
' 0.99 --> $ 0.99
O padrão \b(\d+)(\.(\d+))? de expressão regular é definido conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Inicie a partida no início de um limite de palavras. |
(\d+) |
Corresponder a um ou mais dígitos decimais. Este é o primeiro grupo de captura. |
\. |
Corresponder a um ponto (o separador decimal). |
(\d+) |
Corresponder a um ou mais dígitos decimais. Este é o terceiro grupo de captura. |
(\.(\d+))? |
Corresponder a zero ou a uma ocorrência de um ponto seguido de um ou mais dígitos decimais. Este é o segundo grupo de captura. |
Substituindo toda a partida
A $& substituição inclui toda a partida na sequência de substituição. Muitas vezes, ele é usado para adicionar uma substring ao início ou ao fim da cadeia de caracteres correspondente. Por exemplo, o ($&) padrão de substituição adiciona parênteses ao início e ao fim de cada correspondência. Se não houver correspondência, a substituição não surtiu $& efeito.
O exemplo a seguir usa a $& substituição para adicionar aspas no início e no final dos títulos de livros armazenados em uma matriz de cadeia de caracteres.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"^(\w+\s?)+$";
string[] titles = { "A Tale of Two Cities",
"The Hound of the Baskervilles",
"The Protestant Ethic and the Spirit of Capitalism",
"The Origin of Species" };
string replacement = "\"$&\"";
foreach (string title in titles)
Console.WriteLine(Regex.Replace(title, pattern, replacement));
}
}
// The example displays the following output:
// "A Tale of Two Cities"
// "The Hound of the Baskervilles"
// "The Protestant Ethic and the Spirit of Capitalism"
// "The Origin of Species"
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^(\w+\s?)+$"
Dim titles() As String = {"A Tale of Two Cities", _
"The Hound of the Baskervilles", _
"The Protestant Ethic and the Spirit of Capitalism", _
"The Origin of Species"}
Dim replacement As String = """$&"""
For Each title As String In titles
Console.WriteLine(Regex.Replace(title, pattern, replacement))
Next
End Sub
End Module
' The example displays the following output:
' "A Tale of Two Cities"
' "The Hound of the Baskervilles"
' "The Protestant Ethic and the Spirit of Capitalism"
' "The Origin of Species"
O padrão ^(\w+\s?)+$ de expressão regular é definido conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
^ |
Inicie a correspondência no início da cadeia de caracteres de entrada. |
(\w+\s?)+ |
Corresponder ao padrão de um ou mais caracteres de palavra seguidos por zero ou um caractere de espaço em branco uma ou mais vezes. |
$ |
Corresponder ao final da cadeia de caracteres de entrada. |
O "$&" padrão de substituição adiciona aspas literais ao início e ao fim de cada partida.
Substituindo o texto antes da partida
A $` substituição substitui a string correspondente pela string de entrada inteira antes da partida. Ou seja, ele duplica a cadeia de caracteres de entrada até a correspondência enquanto remove o texto correspondente. Qualquer texto que siga o texto correspondente não será alterado na cadeia de caracteres de resultado. Se houver várias correspondências em uma cadeia de caracteres de entrada, o texto de substituição será derivado da cadeia de caracteres de entrada original, em vez da cadeia de caracteres na qual o texto foi substituído por correspondências anteriores. (O exemplo fornece uma ilustração.) Se não houver correspondência, a substituição não surtiu $` efeito.
O exemplo a seguir usa o padrão \d+ de expressão regular para corresponder a uma sequência de um ou mais dígitos decimais na cadeia de caracteres de entrada. A cadeia de caracteres $` de substituição substitui esses dígitos pelo texto que precede a correspondência.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "aa1bb2cc3dd4ee5";
string pattern = @"\d+";
string substitution = "$`";
Console.WriteLine("Matches:");
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
Console.WriteLine("Input string: {0}", input);
Console.WriteLine("Output string: " +
Regex.Replace(input, pattern, substitution));
}
}
// The example displays the following output:
// Matches:
// 1 at position 2
// 2 at position 5
// 3 at position 8
// 4 at position 11
// 5 at position 14
// Input string: aa1bb2cc3dd4ee5
// Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "aa1bb2cc3dd4ee5"
Dim pattern As String = "\d+"
Dim substitution As String = "$`"
Console.WriteLine("Matches:")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
Console.WriteLine("Input string: {0}", input)
Console.WriteLine("Output string: " + _
Regex.Replace(input, pattern, substitution))
End Sub
End Module
' The example displays the following output:
' Matches:
' 1 at position 2
' 2 at position 5
' 3 at position 8
' 4 at position 11
' 5 at position 14
' Input string: aa1bb2cc3dd4ee5
' Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee
Neste exemplo, a cadeia de caracteres "aa1bb2cc3dd4ee5" de entrada contém cinco correspondências. A tabela a seguir ilustra como a $` substituição faz com que o mecanismo de expressão regular substitua cada correspondência na cadeia de caracteres de entrada. O texto inserido é mostrado em negrito na coluna de resultados.
| Match | Position | String antes da partida | Seqüência de resultados |
|---|---|---|---|
| 1 | 2 | AA | aaaabb2cc3dd4ee5 |
| 2 | 5 | AA1BB | AAAABBAA1BBCC3DD4EE5 |
| 3 | 8 | AA1BB2CC | aaaabbaa1bbcc aa1bb2ccdd4ee5 |
| 4 | 11 | AA1BB2CC3DD | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5 |
| 5 | 14 | aa1bb2cc3dd4ee | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee |
Substituindo o texto após a correspondência
A $' substituição substitui a string correspondente pela string de entrada inteira após a correspondência. Ou seja, ele duplica a cadeia de caracteres de entrada após a correspondência enquanto remove o texto correspondente. Qualquer texto que precede o texto correspondente permanece inalterado na cadeia de caracteres de resultado. Se não houver correspondência, a substituição não surtiu $' efeito.
O exemplo a seguir usa o padrão \d+ de expressão regular para corresponder a uma sequência de um ou mais dígitos decimais na cadeia de caracteres de entrada. A cadeia de caracteres $' de substituição substitui esses dígitos pelo texto que segue a correspondência.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "aa1bb2cc3dd4ee5";
string pattern = @"\d+";
string substitution = "$'";
Console.WriteLine("Matches:");
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
Console.WriteLine("Input string: {0}", input);
Console.WriteLine("Output string: " +
Regex.Replace(input, pattern, substitution));
}
}
// The example displays the following output:
// Matches:
// 1 at position 2
// 2 at position 5
// 3 at position 8
// 4 at position 11
// 5 at position 14
// Input string: aa1bb2cc3dd4ee5
// Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "aa1bb2cc3dd4ee5"
Dim pattern As String = "\d+"
Dim substitution As String = "$'"
Console.WriteLine("Matches:")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
Console.WriteLine("Input string: {0}", input)
Console.WriteLine("Output string: " + _
Regex.Replace(input, pattern, substitution))
End Sub
End Module
' The example displays the following output:
' Matches:
' 1 at position 2
' 2 at position 5
' 3 at position 8
' 4 at position 11
' 5 at position 14
' Input string: aa1bb2cc3dd4ee5
' Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee
Neste exemplo, a cadeia de caracteres "aa1bb2cc3dd4ee5" de entrada contém cinco correspondências. A tabela a seguir ilustra como a $' substituição faz com que o mecanismo de expressão regular substitua cada correspondência na cadeia de caracteres de entrada. O texto inserido é mostrado em negrito na coluna de resultados.
| Match | Position | String após a partida | Seqüência de resultados |
|---|---|---|---|
| 1 | 2 | BB2CC3DD4EE5 | aabb2cc3dd4ee5bb2cc3dd4ee5 |
| 2 | 5 | CC3DD4EE5 | aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5 |
| 3 | 8 | DD4EE5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5 |
| 4 | 11 | EE5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5 |
| 5 | 14 | String.Empty | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee |
Substituindo o último grupo capturado
A $+ substituição substitui a cadeia de caracteres correspondente pelo último grupo capturado. Se não houver grupos capturados ou se o valor do último grupo capturado for String.Empty, a $+ substituição não terá efeito.
O exemplo a seguir identifica palavras duplicadas em uma cadeia de caracteres e usa a $+ substituição para substituí-las por uma única ocorrência da palavra. A RegexOptions.IgnoreCase opção é usada para garantir que palavras diferentes em maiúsculas e minúsculas, mas que são idênticas de outra forma, sejam consideradas duplicadas.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\w+)\s\1\b";
string substitution = "$+";
string input = "The the dog jumped over the fence fence.";
Console.WriteLine(Regex.Replace(input, pattern, substitution,
RegexOptions.IgnoreCase));
}
}
// The example displays the following output:
// The dog jumped over the fence.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\w+)\s\1\b"
Dim substitution As String = "$+"
Dim input As String = "The the dog jumped over the fence fence."
Console.WriteLine(Regex.Replace(input, pattern, substitution, _
RegexOptions.IgnoreCase))
End Sub
End Module
' The example displays the following output:
' The dog jumped over the fence.
O padrão \b(\w+)\s\1\b de expressão regular é definido conforme mostrado na tabela a seguir.
| Padrão | Description |
|---|---|
\b |
Comece a partida com um limite de palavras. |
(\w+) |
Corresponder a um ou mais caracteres de palavra. Este é o primeiro grupo de captura. |
\s |
Corresponder a um caractere de espaço em branco. |
\1 |
Corresponder ao primeiro grupo capturado. |
\b |
Termine a partida com um limite de palavras. |
Substituindo toda a cadeia de caracteres de entrada
A $_ substituição substitui a cadeia de caracteres correspondente por toda a cadeia de entrada. Ou seja, remove o texto correspondente e substitui-o por toda a cadeia de caracteres, incluindo o texto correspondente.
O exemplo a seguir corresponde a um ou mais dígitos decimais na cadeia de caracteres de entrada. Ele usa a $_ substituição para substituí-los por toda a cadeia de caracteres de entrada.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "ABC123DEF456";
string pattern = @"\d+";
string substitution = "$_";
Console.WriteLine("Original string: {0}", input);
Console.WriteLine("String with substitution: {0}",
Regex.Replace(input, pattern, substitution));
}
}
// The example displays the following output:
// Original string: ABC123DEF456
// String with substitution: ABCABC123DEF456DEFABC123DEF456
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "ABC123DEF456"
Dim pattern As String = "\d+"
Dim substitution As String = "$_"
Console.WriteLine("Original string: {0}", input)
Console.WriteLine("String with substitution: {0}", _
Regex.Replace(input, pattern, substitution))
End Sub
End Module
' The example displays the following output:
' Original string: ABC123DEF456
' String with substitution: ABCABC123DEF456DEFABC123DEF456
Neste exemplo, a cadeia de caracteres "ABC123DEF456" de entrada contém duas correspondências. A tabela a seguir ilustra como a $_ substituição faz com que o mecanismo de expressão regular substitua cada correspondência na cadeia de caracteres de entrada. O texto inserido é mostrado em negrito na coluna de resultados.
| Match | Position | Match | Seqüência de resultados |
|---|---|---|---|
| 1 | 3 | 123 | ABCABC123DEF456DEF456 |
| 2 | 5 | 456 | ABCABC123DEF456DEF ABC123DEF456 |
Consulte também
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários