Regex.Replace Método

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options);

public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options);

static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo tiene lugar de cada cadena coincidente. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se usa el método Replace(String, String, String, RegexOptions) para reemplazar los nombres de unidad y equipo local en una ruta de acceso UNC por una ruta de acceso del archivo local. La expresión regular usa la propiedad Environment.MachineName para incluir el nombre del equipo local y el método Environment.GetLogicalDrives para incluir los nombres de las unidades lógicas. Todas las comparaciones de cadenas de expresiones regulares no distinguen mayúsculas de minúsculas. Para ejecutar el ejemplo correctamente, debe reemplazar la cadena literal "MyMachine" por el nombre del equipo local.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

El patrón de expresión regular se define mediante la expresión siguiente:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

En la tabla siguiente se muestra cómo se interpreta el patrón de expresión regular.

El patrón de reemplazo $1 reemplaza toda la coincidencia por la primera subexpresión capturada. Es decir, reemplaza el equipo UNC y el nombre de unidad por la letra de unidad.

Comentarios

Los métodos de Replace estáticos son equivalentes a construir un objeto Regex con el patrón de expresión regular especificado y llamar al método de instancia Replace.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida. Si especifica RightToLeft para el parámetro options, la búsqueda de coincidencias comienza al final de la cadena de entrada y se mueve a la izquierda; De lo contrario, la búsqueda comienza al principio de la cadena de entrada y se mueve a la derecha.

El parámetro replacement especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones de . Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "a*" seguida de la subcadena que coincide con el grupo de captura test, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para reemplazar una coincidencia de patrón es Replace(String, String, String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

• RegexOptions
• sustituciones en expresiones regulares
• elementos del lenguaje de expresiones regulares

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions, matchTimeout As TimeSpan) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo tiene lugar de cada cadena coincidente. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se usa el método Replace(String, String, String, RegexOptions, TimeSpan) para reemplazar los nombres de unidad y equipo local en una ruta de acceso UNC por una ruta de acceso del archivo local. La expresión regular usa la propiedad Environment.MachineName para incluir el nombre del equipo local y el método Environment.GetLogicalDrives para incluir los nombres de las unidades lógicas. Todas las comparaciones de cadenas de expresiones regulares no distinguen mayúsculas de minúsculas y cualquier operación de reemplazo única agota el tiempo de espera si no se encuentra una coincidencia en 0,5 segundos. Para ejecutar el ejemplo correctamente, debe reemplazar la cadena literal "MyMachine" por el nombre del equipo local.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         string localPath = null;
         try {
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                      RegexOptions.IgnoreCase,
                                      TimeSpan.FromSeconds(0.5));
            Console.WriteLine("Returned string: " + localPath);
         }
         catch (RegexMatchTimeoutException) {
            Console.WriteLine("The replace operation timed out.");
            Console.WriteLine("Returned string: " + localPath);
            if (uncPath.Equals(localPath)) 
               Console.WriteLine("Equal to original path.");
            else
               Console.WriteLine("Original string: " + uncPath);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Dim localPath As String = Nothing
         Try
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                                               RegexOptions.IgnoreCase,
                                                               TimeSpan.FromSeconds(0.5))
            Console.WriteLine("Returned string: " + localPath)         
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("The replace operation timed out.")
            Console.WriteLine("Returned string: " + localPath)
            If uncPath.Equals(localPath) Then 
               Console.WriteLine("Equal to original path.")
            Else
               Console.WriteLine("Original string: " + uncPath)
            End If
         End Try         
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

El patrón de expresión regular se define mediante la expresión siguiente:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

En la tabla siguiente se muestra cómo se interpreta el patrón de expresión regular.

El patrón de reemplazo $1 reemplaza toda la coincidencia por la primera subexpresión capturada. Es decir, reemplaza el equipo UNC y el nombre de unidad por la letra de unidad.

Comentarios

Los métodos de Replace estáticos son equivalentes a construir un objeto Regex con el patrón de expresión regular especificado y llamar al método de instancia Replace.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida. Si especifica RightToLeft para el parámetro options, la búsqueda de coincidencias comienza al final de la cadena de entrada y se mueve a la izquierda; De lo contrario, la búsqueda comienza al principio de la cadena de entrada y se mueve a la derecha.

El parámetro replacement especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones de . Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "a*" seguida de la subcadena que coincide con el grupo de captura test, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

El parámetro matchTimeout especifica cuánto tiempo un método de coincidencia de patrones debe intentar encontrar una coincidencia antes de que se agote el tiempo de espera. Si se establece un intervalo de tiempo de espera, se impide que las expresiones regulares que se basan en un retroceso excesivo aparezcan para dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea procedimientos recomendados de para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una excepción RegexMatchTimeoutException. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Se recomienda establecer el parámetro matchTimeout en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:

• Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.

• Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla eficazmente las coincidencias, las no coincide y las coincidencias cercanas.

• Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.

Consulte también

• RegexOptions
• sustituciones en expresiones regulares
• elementos del lenguaje de expresiones regulares
• retroceso en expresiones regulares
• procedimientos recomendados de para expresiones regulares en .NET

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count, int startat);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer, startat As Integer) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo tiene lugar de cada cadena coincidente. Si el patrón de expresión regular no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Comentarios

El método Regex.Replace(String, MatchEvaluator, Int32, Int32) es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:

• La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.
• La cadena de reemplazo da como resultado algún procesamiento realizado en la cadena coincidente.
• La cadena de reemplazo da como resultado el procesamiento condicional.

El método es equivalente a llamar al método Regex.Matches(String, Int32) y pasar los primeros objetos countMatch de la colección de MatchCollection devuelta al delegado de evaluator.

Para obtener más información sobre startat, vea la sección Comentarios de Match(String, Int32).

La expresión regular es el patrón definido por el constructor del objeto Regex actual.

El parámetro evaluator es el delegado de un método personalizado que defina y que examine cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el delegado de MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Consulte también

• MatchEvaluator
• sustituciones en expresiones regulares
• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo tiene lugar de cada cadena coincidente. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se usa una expresión regular para extraer las palabras individuales de una cadena y, a continuación, se usa un delegado de MatchEvaluator para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra. Para ello, el método WordScramble crea una matriz que contiene los caracteres de la coincidencia. También crea una matriz paralela que se rellena con números de punto flotante aleatorios. Las matrices se ordenan llamando al método Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) y la matriz ordenada se proporciona como argumento a un constructor de clase String. A continuación, el método WordScramble devuelve esta cadena recién creada. El patrón de expresión regular \w+ coincide con uno o varios caracteres de palabra; El motor de expresiones regulares seguirá agregando caracteres a la coincidencia hasta que encuentre un carácter que no sea de palabra, como un carácter de espacio en blanco. La llamada al método Replace(String, String, MatchEvaluator, RegexOptions) incluye la opción RegexOptions.IgnorePatternWhitespace para que el motor de expresiones regulares omita el comentario del patrón de expresión regular \w+ # Matches all the characters in a word..

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                      RegexOptions.IgnorePatternWhitespace));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                      RegexOptions.IgnorePatternWhitespace))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Comentarios

El método Regex.Replace(String, String, MatchEvaluator, RegexOptions) es útil para reemplazar una coincidencia de expresión regular en si se cumple alguna de las condiciones siguientes:

• La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

• La cadena de reemplazo da como resultado algún procesamiento realizado en la cadena coincidente.

• La cadena de reemplazo da como resultado el procesamiento condicional.

El método es equivalente a llamar al método Regex.Matches(String, String, RegexOptions) y pasar cada objeto Match en la colección de MatchCollection devuelta al delegado de evaluator.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

El parámetro evaluator es el delegado de un método personalizado que defina y que examine cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el delegado de MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.

Si especifica RightToLeft para el parámetro options, la búsqueda de coincidencias comienza al final de la cadena de entrada y se mueve a la izquierda; De lo contrario, la búsqueda comienza al principio de la cadena de entrada y se mueve a la derecha.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Consulte también

• MatchEvaluator
• RegexOptions
• sustituciones en expresiones regulares
• elementos del lenguaje de expresiones regulares

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions, matchTimeout As TimeSpan) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo tiene lugar de cada cadena coincidente. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se usa una expresión regular para extraer las palabras individuales de una cadena y, a continuación, se usa un delegado de MatchEvaluator para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra. Para ello, el método WordScramble crea una matriz que contiene los caracteres de la coincidencia. También crea una matriz paralela que se rellena con números de punto flotante aleatorios. Las matrices se ordenan llamando al método Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) y la matriz ordenada se proporciona como argumento a un constructor de clase String. A continuación, el método WordScramble devuelve esta cadena recién creada. El patrón de expresión regular \w+ coincide con uno o varios caracteres de palabra; El motor de expresiones regulares seguirá agregando caracteres a la coincidencia hasta que encuentre un carácter que no sea de palabra, como un carácter de espacio en blanco. La llamada al método Replace(String, String, MatchEvaluator, RegexOptions) incluye la opción RegexOptions.IgnorePatternWhitespace para que el motor de expresiones regulares omita el comentario del patrón de expresión regular \w+ # Matches all the characters in a word..

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      try {
         Console.WriteLine("Scrambled words:");
         Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)));      
      }
      catch (RegexMatchTimeoutException) {
         Console.WriteLine("Word Scramble operation timed out.");
         Console.WriteLine("Returned words:");
      }
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Try
         Console.WriteLine("Scrambled words:")
         Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)))      
      Catch e As RegexMatchTimeoutException
         Console.WriteLine("Word Scramble operation timed out.")
         Console.WriteLine("Returned words:")
      End Try   
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Comentarios

El método Regex.Replace(String, String, MatchEvaluator, RegexOptions) es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:

• Si la cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

• Si la cadena de reemplazo da como resultado algún procesamiento realizado en la cadena coincidente.

• Si la cadena de reemplazo resulta del procesamiento condicional.

El método es equivalente a llamar al método Regex.Matches(String, String, RegexOptions) y pasar cada objeto Match en la colección de MatchCollection devuelta al delegado de evaluator.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

El parámetro evaluator es el delegado de un método personalizado que defina y que examine cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el delegado de MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.

Si especifica RightToLeft para el parámetro options, la búsqueda de coincidencias comienza al final de la cadena de entrada y se mueve a la izquierda; De lo contrario, la búsqueda comienza al principio de la cadena de entrada y se mueve a la derecha.

El parámetro matchTimeout especifica cuánto tiempo un método de coincidencia de patrones debe intentar encontrar una coincidencia antes de que se agote el tiempo de espera. Establecer un intervalo de tiempo de espera impide que las expresiones regulares que dependen del retroceso excesivo aparezcan como "dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea procedimientos recomendados de para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una excepción RegexMatchTimeoutException. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Se recomienda establecer el parámetro matchTimeout en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:

• Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.

• Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla eficazmente las coincidencias, las no coincide y las coincidencias cercanas.

• Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.

Consulte también

• RegexOptions
• sustituciones en expresiones regulares
• elementos del lenguaje de expresiones regulares
• retroceso en expresiones regulares
• procedimientos recomendados de para expresiones regulares en .NET

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count, int startat);

public string Replace (string input, string replacement, int count, int startat);

member this.Replace : string * string * int * int -> string

Public Function Replace (input As String, replacement As String, count As Integer, startat As Integer) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo tiene lugar de cada cadena coincidente. Si el patrón de expresión regular no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se duplican todos los espacios, pero la primera línea de una cadena. Define un patrón de expresión regular, ^.*$, que coincide con una línea de texto, llama al método Match(String) para que coincida con la primera línea de la cadena y usa las propiedades Match.Index y Match.Count para determinar la posición inicial de la segunda línea.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Instantiating a New Type\n" +
                     "Generally, there are two ways that an\n" + 
                     "instance of a class or structure can\n" +
                     "be instantiated. ";
      string pattern = "^.*$";
      string replacement = "\n$&";
      Regex rgx = new Regex(pattern, RegexOptions.Multiline);
      string result = String.Empty; 
      
      Match match = rgx.Match(input);
      // Double space all but the first line.
      if (match.Success) 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1);

      Console.WriteLine(result);                     
   }
}
// The example displays the following output:
//       Instantiating a New Type
//       
//       Generally, there are two ways that an
//       
//       instance of a class or structure can
//       
//       be instntiated.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Instantiating a New Type" + vbCrLf + _
                            "Generally, there are two ways that an" + vbCrLf + _
                            "instance of a class or structure can" + vbCrLf + _
                            "be instantiated. "
      Dim pattern As String = "^.*$"
      Dim replacement As String = vbCrLf + "$&"
      Dim rgx As New Regex(pattern, RegexOptions.Multiline)
      Dim result As String = String.Empty 
      
      Dim match As Match = rgx.Match(input)
      ' Double space all but the first line.
      If match.Success Then 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1)
      End If
      Console.WriteLine(result)                      
   End Sub
End Module
' The example displays the following output:
'       Instantiating a New Type
'       
'       Generally, there are two ways that an
'       
'       instance of a class or structure can
'       
'       be instntiated.

El patrón de expresión regular ^.*$ se define como se muestra en la tabla siguiente.

La cadena de reemplazo (vbCrLf + "$&" en Visual Basic, "\n$&" en C#) agrega una nueva línea antes de la cadena coincidente. Tenga en cuenta que \n en el ejemplo de C# se interpreta como el carácter de nueva línea del compilador de C#; no representa un escape de caracteres de expresión regular.

Comentarios

La búsqueda de coincidencias se inicia en la cadena input en la posición especificada por el parámetro startat. La expresión regular es el patrón definido por el constructor del objeto Regex actual. Si count es negativo, los reemplazos continúan hasta el final de la cadena. Si count supera el número de coincidencias, se reemplazan todas las coincidencias.

Para obtener más información sobre startat, vea la sección Comentarios de Match(String, Int32).

El parámetro replacement especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones de . Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "a*" seguida de la subcadena que coincide con el grupo de captura test, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Consulte también

• sustituciones en expresiones regulares
• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement);

public static string Replace (string input, string pattern, string replacement);

static member Replace : string * string * string -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo tiene lugar de cada cadena coincidente. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se define una expresión regular, \s+, que coincide con uno o varios caracteres de espacio en blanco. La cadena de reemplazo, " ", las reemplaza por un solo carácter de espacio.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      string result = Regex.Replace(input, pattern, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim result As String = Regex.Replace(input, pattern, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

En el ejemplo siguiente se usa el método Replace(String, String, String) para reemplazar los nombres de unidad y equipo local en una ruta de acceso UNC por una ruta de acceso del archivo local. La expresión regular usa la propiedad Environment.MachineName para incluir el nombre del equipo local y el método Environment.GetLogicalDrives para incluir los nombres de las unidades lógicas. Para ejecutar el ejemplo correctamente, debe reemplazar la cadena literal "MyMachine" por el nombre del equipo local.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\(?i:" + Environment.MachineName + @")(?:\.\w+)*\\((?i:[" + driveNames + @"]))\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

El patrón de expresión regular se define mediante la expresión siguiente:

"\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

En la tabla siguiente se muestra cómo se interpreta el patrón de expresión regular.

El patrón de reemplazo $1 reemplaza toda la coincidencia por la primera subexpresión capturada. Es decir, reemplaza el equipo UNC y el nombre de unidad por la letra de unidad.

Comentarios

Los métodos de Replace estáticos son equivalentes a construir un objeto Regex con el patrón de expresión regular especificado y llamar al método de instancia Replace.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida. La búsqueda de coincidencias comienza al principio de la cadena de input.

El parámetro replacement especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones de . Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "a*" seguida de la subcadena que coincide con el grupo de captura test, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para reemplazar una coincidencia de patrón es Replace(String, String, String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

• sustituciones en expresiones regulares
• elementos del lenguaje de expresiones regulares

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo tiene lugar de cada cadena coincidente. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se usa una expresión regular para extraer las palabras individuales de una cadena y, a continuación, se usa un delegado de MatchEvaluator para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra. Para ello, el método WordScramble crea una matriz que contiene los caracteres de la coincidencia. También crea una matriz paralela que se rellena con números de punto flotante aleatorios. Las matrices se ordenan llamando al método Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) y la matriz ordenada se proporciona como argumento a un constructor de clase String. A continuación, el método WordScramble devuelve esta cadena recién creada. El patrón de expresión regular \w+ coincide con uno o varios caracteres de palabra; El motor de expresiones regulares seguirá agregando caracteres a la coincidencia hasta que encuentre un carácter que no sea de palabra, como un carácter de espacio en blanco.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+"                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Comentarios

El método Regex.Replace(String, String, MatchEvaluator) es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:

• La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

• La cadena de reemplazo da como resultado algún procesamiento realizado en la cadena coincidente.

• La cadena de reemplazo da como resultado el procesamiento condicional.

El método es equivalente a llamar al método Regex.Matches(String, String) y pasar cada objeto Match en la colección de MatchCollection devuelta al delegado de evaluator.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

El parámetro evaluator es el delegado de un método personalizado que defina y que examine cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el delegado de MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para evaluar y reemplazar una coincidencia de patrón es Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

• MatchEvaluator
• sustituciones en expresiones regulares
• elementos del lenguaje de expresiones regulares

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count);

public string Replace (string input, string replacement, int count);

member this.Replace : string * string * int -> string

Public Function Replace (input As String, replacement As String, count As Integer) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo tiene lugar de cada cadena coincidente. Si el patrón de expresión regular no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se reemplazan las cinco primeras apariciones de caracteres duplicados por un solo carácter. El patrón de expresión regular (\w)\1 coincide con las apariciones consecutivas de un solo carácter y asigna la primera aparición al primer grupo de captura. El patrón de reemplazo $1 reemplaza toda la coincidencia por el primer grupo capturado.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string str = "aabccdeefgghiijkklmm";
      string pattern = "(\\w)\\1"; 
      string replacement = "$1"; 
      Regex rgx = new Regex(pattern);

      string result = rgx.Replace(str, replacement, 5);
      Console.WriteLine("Original String:    '{0}'", str);
      Console.WriteLine("Replacement String: '{0}'", result); 
   }
}
// The example displays the following output:
//       Original String:    'aabccdeefgghiijkklmm'
//       Replacement String: 'abcdefghijkklmm'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim str As String = "aabccdeefgghiijkklmm"
      Dim pattern As String = "(\w)\1" 
      Dim replacement As String = "$1" 
      Dim rgx As New Regex(pattern)

      Dim result As String = rgx.Replace(str, replacement, 5)
      Console.WriteLine("Original String:    '{0}'", str)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    'aabccdeefgghiijkklmm'
'       Replacement String: 'abcdefghijkklmm'

Comentarios

La búsqueda de coincidencias comienza al principio de la cadena de input. La expresión regular es el patrón definido por el constructor para el objeto Regex actual. Si count es negativo, los reemplazos continúan hasta el final de la cadena. Si count supera el número de coincidencias, se reemplazan todas las coincidencias.

El parámetro replacement especifica la cadena que se va a reemplazar el primer count coincide en input. replacement puede constar de cualquier combinación de texto literal y sustituciones de . Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "a*" seguida de la subcadena que coincide con el grupo de captura test, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Consulte también

• lenguaje de expresiones regulares: de referencia rápida
• sustituciones en expresiones regulares

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Function Replace (input As String, evaluator As MatchEvaluator) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo tiene lugar de cada cadena coincidente. Si el patrón de expresión regular no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo de código siguiente se muestra una cadena original, que coincide con cada palabra de la cadena original, se convierte el primer carácter de cada coincidencia en mayúsculas y, a continuación, se muestra la cadena convertida.

using System;
using System.Text.RegularExpressions;

class RegExSample
{
    static string CapText(Match m)
    {
        // Get the matched string.
        string x = m.ToString();
        // If the first char is lower case...
        if (char.IsLower(x[0]))
        {
            // Capitalize it.
            return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
        }
        return x;
    }

    static void Main()
    {
        string text = "four score and seven years ago";

        Console.WriteLine($"text=[{text}]");

        Regex rx = new Regex(@"\w+");

        string result = rx.Replace(text, new MatchEvaluator(RegExSample.CapText));

        Console.WriteLine($"result=[{result}]");
    }
}
// The example displays the following output:
//       text=[four score and seven years ago]
//       result=[Four Score And Seven Years Ago]

Imports System.Text.RegularExpressions

Module RegExSample
    Function CapText(ByVal m As Match) As String
        ' Get the matched string.
        Dim x As String = m.ToString()
        ' If the first char is lower case...
        If Char.IsLower(x.Chars(0)) Then
            ' Capitalize it.
            Return Char.ToUpper(x.Chars(0)) & x.Substring(1, x.Length - 1)
        End If
        Return x
    End Function

    Sub Main()
        Dim text As String = "four score and seven years ago"

        Console.WriteLine($"text=[{text}]")

        Dim rx As New Regex("\w+")

        Dim result As String = rx.Replace(text, AddressOf RegExSample.CapText)

        Console.WriteLine($"result=[{result}]")
    End Sub
End Module
' The example displays the following output:
'       text=[four score and seven years ago]
'       result=[Four Score And Seven Years Ago]

Comentarios

El método Regex.Replace(String, MatchEvaluator) es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:

• La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

• La cadena de reemplazo da como resultado algún procesamiento realizado en la cadena coincidente.

• La cadena de reemplazo da como resultado el procesamiento condicional.

El método es equivalente a llamar al método Regex.Matches(String) y pasar cada objeto Match en la colección de MatchCollection devuelta al delegado de evaluator.

La expresión regular es el patrón definido por el constructor del objeto Regex actual.

El parámetro evaluator es el delegado de un método personalizado que defina y que examine cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el delegado de MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Consulte también

• MatchEvaluator
• sustituciones en expresiones regulares
• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement);

public string Replace (string input, string replacement);

member this.Replace : string * string -> string

Public Function Replace (input As String, replacement As String) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo tiene lugar de cada cadena coincidente. Si el patrón de expresión regular no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se define una expresión regular, \s+, que coincide con uno o varios caracteres de espacio en blanco. La cadena de reemplazo, " ", las reemplaza por un solo carácter de espacio.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

En el ejemplo siguiente se define una expresión regular, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?y un patrón de reemplazo, $2, que quita un símbolo de moneda inicial o final de un valor numérico.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern =  @"(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?";
      string input = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17";
      string replacement = "$2";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);

      Console.WriteLine("Original String:    '{0}'", input);
      Console.WriteLine("Replacement String: '{0}'", result);                             
   }
}
// The example displays the following output:
//       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
//       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String =  "(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?"
      Dim input As String = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17"
      Dim replacement As String = "$2"
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)

      Console.WriteLine("Original String:    '{0}'", input)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
'       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

La expresión regular se interpreta como se muestra en la tabla siguiente.

Comentarios

La búsqueda de coincidencias comienza al principio de la cadena de input. La expresión regular es el patrón definido por el constructor del objeto Regex actual.

El parámetro replacement especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones de . Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "a*" seguida de la subcadena que coincide con el grupo de captura test, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Consulte también

• lenguaje de expresiones regulares: de referencia rápida
• sustituciones en expresiones regulares

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer) As String

Parámetros

Devoluciones

Nueva cadena que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo tiene lugar de cada cadena coincidente. Si el patrón de expresión regular no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

Ejemplos

En el ejemplo siguiente se usa una expresión regular para omitir deliberadamente la mitad de las palabras de una lista. Usa la expresión regular \w*(ie|ei)\w* para hacer coincidir palabras que incluyan los caracteres "ie" o "ei". Pasa la primera mitad de las palabras coincidentes al método ReverseLetter, que, a su vez, usa el método Replace(String, String, String, RegexOptions) para invertir "i" y "e" en la cadena coincidente. Las palabras restantes permanecen sin cambios.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "deceive relieve achieve belief fierce receive";
      string pattern = @"\w*(ie|ei)\w*";
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
      Console.WriteLine("Original string: " + input);
      
      string result = rgx.Replace(input, new MatchEvaluator(Example.ReverseLetter), 
                                  input.Split(' ').Length / 2);
      Console.WriteLine("Returned string: " + result);
   }

   static string ReverseLetter(Match match)
   {
      return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase);            
   }
}
// The example displays the following output:
//    Original string: deceive relieve achieve belief fierce receive
//    Returned string: decieve releive acheive belief fierce receive

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "deceive relieve achieve belief fierce receive"
      Dim pattern As String = "\w*(ie|ei)\w*"
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
      Console.WriteLine("Original string: " + input)
      
      Dim result As String = rgx.Replace(input, AddressOf ReverseLetter, 
                                           input.Split(" "c).Length \ 2)
      Console.WriteLine("Returned string: " + result)
   End Sub

   Public Function ReverseLetter(match As Match) As String
      Return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase)            
   End Function
End Module
' The example displays the following output:
'    Original string: deceive relieve achieve belief fierce receive
'    Returned string: decieve releive acheive belief fierce receive

La expresión regular \w*(ie|ei)\w* se define como se muestra en la tabla siguiente.

El patrón de expresión regular ([ie])([ie]) en el método ReverseLetter coincide con el primer "i" o "e" en la diphthong "ie" o "ei" y asigna la letra al primer grupo de captura. Coincide con el segundo "i" o "e" y asigna la letra al segundo grupo de captura. Los dos caracteres se invierten llamando al método Replace(String, String, String) con el patrón de reemplazo $2$1.

Comentarios

El método Regex.Replace(String, MatchEvaluator, Int32) es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:

• La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

• La cadena de reemplazo da como resultado algún procesamiento realizado en la cadena coincidente.

• La cadena de reemplazo da como resultado el procesamiento condicional.

El método es equivalente a llamar al método Regex.Matches(String) y pasar los primeros objetos countMatch de la colección de MatchCollection devuelta al delegado de evaluator.

La expresión regular es el patrón definido por el constructor del objeto Regex actual.

El parámetro evaluator es el delegado de un método personalizado que defina y que examine cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el delegado de MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el método Object.ReferenceEquals para determinar si el método ha realizado reemplazos en la cadena de entrada.

Consulte también

• MatchEvaluator
• sustituciones en expresiones regulares
• lenguaje de expresiones regulares: de referencia rápida