Regular Expressions
Sustituciones con expresiones regulares

Parámetros

Conceptos básicos de la sustitución

Una de las formas más comunes y útiles para reemplazar texto con expresiones regulares es mediante el uso de grupos de captura .
O incluso un grupo de captura con nombre , como referencia para almacenar o reemplazar los datos.

Hay dos términos bastante parecidos en los documentos de expresiones regulares, por lo que puede ser importante nunca mezclar sustituciones (es decir, $1 ) con referencias (es decir, \1 ). Los términos de sustitución se utilizan en un texto de reemplazo; Backreferences, en la expresión Regex pura. Aunque algunos lenguajes de programación aceptan ambas sustituciones, no es alentador.

Digamos que tenemos esta expresión regular: /hello(\s+)world/i . Cuando se hace referencia a $number (en este caso, $1 ), los espacios en blanco que coincidan con \s+ serán reemplazados en su lugar.
El mismo resultado se expondrá con la expresión regular: /hello(?<spaces>\s+)world/i . Y como tenemos un grupo nombrado aquí, también podemos usar ${spaces} .

En este mismo ejemplo, también podemos usar $0 o $& ( Nota: $& puede usarse como $+ lugar, lo que significa recuperar el último grupo de captura en otros motores de expresiones regulares), dependiendo del sabor de expresiones regulares con el que esté trabajando, para obtener todo el texto emparejado. (Es decir, $& devolverá hEllo woRld para la cadena: hEllo woRld of Regex! )

---

Eche un vistazo a este sencillo ejemplo de sustitución utilizando la cita adaptada de John Lennon utilizando el $number y la sintaxis ${name} :

Ejemplo de grupo de captura simple:

Ejemplo de grupo de captura con nombre:

Reemplazo avanzado

Algunos lenguajes de programación tienen sus propias peculiaridades Regex, por ejemplo, el término $+ (en C #, Perl, VB, etc.) que reemplaza el texto coincidente con el último grupo capturado.

Ejemplo:

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.

_{Ejemplo de la red de desarrolladores de Microsoft Official ^[1]}

---

Otros términos de sustitución raros son $` y $' :

$` = Reemplaza coincidencias con el texto antes de la cadena correspondiente
$' = Reemplaza coincidencias con el texto después de la cadena correspondiente

Debido a este hecho, estas cadenas de reemplazo deben hacer su trabajo así:

Regex: /part2/
Input: "part1part2part3"
Replacement: "$`"
Output: "part1part1part3" //Note that part2 was replaced with part1, due &` term
---------------------------------------------------------------------------------
Regex: /part2/
Input: "part1part2part3"
Replacement: "$'"
Output: "part1part3part3" //Note that part2 was replaced with part3, due &' term

Aquí hay un ejemplo de estas sustituciones trabajando en una pieza de javascript:

var rgx = /middle/;
var text = "Your story must have a beginning, middle, and end"
console.log(text.replace(rgx, "$`")); 
//Logs: "Your story must have a beginning, Your story must have a beginning, , and end"
console.log(text.replace(rgx, "$'"))
//Logs: "Your story must have a beginning, , and end, and end"

---

También está el término $_ que recupera todo el texto coincidente en su lugar:

Regex: /part2/
Input: "part1part2part3"
Replacement: "$_"
Output: "part1part1part2part3part3" //Note that part2 was replaced with part1part2part3,
                                                                         // due $_ term

Convertir esto a VB nos daría esto:

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

_{Ejemplo de la red de desarrolladores de Microsoft Official ^[2]}

---

Y el último término de sustitución, pero no menos importante, es $$ , que traducido a una expresión de expresión regular sería el mismo que \$ (una versión escapada del $ literal).

Si desea hacer coincidir una cadena como esta: USD: $3.99 por ejemplo, y desea almacenar la 3.99 , pero reemplazarla por $3.99 con una sola expresión regular, puede usar:

Regex: /USD:\s+\$([\d.]+)/
Input: "USD: $3.99"
Replacement: "$$$1"
To Store: "$1"
Output: "$3.99"
Stored: "3.99"

Si desea probar esto con Javascript, puede usar el código:

var rgx = /USD:\s+\$([\d.]+)/;
var text = "USD: $3.99";
var stored = parseFloat(rgx.exec(text)[1]);
console.log(stored); //Logs 3.99
console.log(text.replace(rgx, "$$$1")); //Logs $3.99

---

Referencias

[1]: Sustituyendo al último grupo capturado
[2]: Sustituyendo toda la cadena de entrada