activities
latest
false
Importante :
Este contenido se ha localizado parcialmente a partir de un sistema de traducción automática.
UiPath logo, featuring letters U and I in white
Actividades del flujo de trabajo
Last updated 6 de dic. de 2024

VerificarEquivalenciaDeTexto

Verifica si dos textos son equivalentes, utilizando múltiples opciones de comparación, incluidos los siguientes tipos de comparación:
  • Comparar palabras.
  • Comparar líneas.
  • Comparando caracteres como variables char .

VerifyTextEquivalence(string, string, ComparisonType, ComparisonOptions)

VerifyTextEquivalence(
    string baselineText,
    string targetText,
    [ComparisonType comparisonType],
    [ComparisonOptions opts]
)VerifyTextEquivalence(
    string baselineText,
    string targetText,
    [ComparisonType comparisonType],
    [ComparisonOptions opts]
)
baselineText Cadena
El texto base que se utiliza como referencia para la comparación.
targetText Cadena
El texto que se compara con el texto base.
comparisonType ComparisonType (opcional)
El tipo de comparación que se utilizará al comparar textos. Las siguientes opciones están disponibles:
  • ComparisonType.Char: compara cada carácter (char) en los textos.
  • ComparisonType.Line: compara cada línea de los textos.
  • ComparisonType.Word: compara cada palabra de los textos.
Opta CompareDocumentsOptions
Las opciones de comparación específicas que deben utilizarse para esta operación. Para crear un objeto de tipo CompareDocumentsOptions, utiliza la clase TestingOptions.CompareText.

ValorDeRetorno

ComparisonResult

El resultado de la acción de comparación, almacenado en una variable ComparisonResult . Puedes llamar a las propiedades AreEquivalent o Differences en ComparisonResult para mostrar si son equivalentes, y si no, para mostrar las diferencias.

Ejemplos

Consulta los siguientes ejemplos para utilizar la API VerifyTextEquivalence :
  1. Comparar texto por carácter:
    En este ejemplo, estamos comparando dos variables string , initialText y modifiedText. La comparación se realiza a nivel de carácter. La regla de comodín y la regla de expresión regular proporcionadas junto con los métodos WithIgnoreWildcardRule y WithIgnoreRegexRule se utilizan para ignorar patrones específicos en la comparación. Por ejemplo, la regla comodín R?d y la regla regex (f|F)ox nos permiten ignorar ciertas palabras que están presentes en las variables, como Red y Fox. En este escenario, el parámetro usePlaceholder se estableció en false, porque no queremos tener un nombre de marcador de posición para los patrones ignorados.
    El método WithGenerateHtml genera un informe HTML que destaca las diferencias.
    var initialText = "Red fox jumps over the lazy fox";
    var modifiedText = "Blue fox leaps over the lazy dog";
    
    var charCompareResult = testing.VerifyTextEquivalence(
        initialText, modifiedText, 
        ComparisonType.Character, 
        TestingOptions.CompareText()
            .WithGenerateHtml(@".\HtmlCompareResults\CharacterTextCompare.html")
            .WithIgnoreWildcardRule("WildcardRule", "R?d", false)
            .WithIgnoreRegexRule("RegexRule", @"(f|F)ox", false)
    );
    
    // Log any differences
    foreach (var diff in charCompareResult.Differences)
    {
        Log(diff.Operation.ToString());
        Console.WriteLine(diff.Text);
        Console.WriteLine("------------------------------------------------------------------------------");
    }var initialText = "Red fox jumps over the lazy fox";
    var modifiedText = "Blue fox leaps over the lazy dog";
    
    var charCompareResult = testing.VerifyTextEquivalence(
        initialText, modifiedText, 
        ComparisonType.Character, 
        TestingOptions.CompareText()
            .WithGenerateHtml(@".\HtmlCompareResults\CharacterTextCompare.html")
            .WithIgnoreWildcardRule("WildcardRule", "R?d", false)
            .WithIgnoreRegexRule("RegexRule", @"(f|F)ox", false)
    );
    
    // Log any differences
    foreach (var diff in charCompareResult.Differences)
    {
        Log(diff.Operation.ToString());
        Console.WriteLine(diff.Text);
        Console.WriteLine("------------------------------------------------------------------------------");
    }
    
  2. Comparar texto por línea:
    En este ejemplo, estamos comparando dos variables string , initialText y modifiedText. La comparación se realiza a nivel de línea. La regla de comodín y la regla de expresión regular proporcionadas junto con los métodos WithIgnoreWildcardRule y WithIgnoreRegexRule se utilizan para ignorar patrones específicos en la comparación. Por ejemplo, la regla comodín R?d y la regla regex (f|F)ox nos permiten ignorar ciertas palabras que están presentes en las variables, como Red y Fox. En este escenario, el parámetro usePlaceholder se estableció en true, porque queremos tener un nombre de marcador de posición para los patrones ignorados.
    El método WithGenerateHtml genera un informe HTML que destaca las diferencias.
    var initialText = @"Red fox jumps over the lazy fox";
    var modifiedText = @"Blue fox leaps over the lazy dog";
    
    var lineCompareResult = testing.VerifyTextEquivalence(
        initialText, modifiedText, 
        ComparisonType.Line, 
        TestingOptions.CompareText()
            .WithGenerateHtml(@".\HtmlCompareResults\LineTextCompare.html")
            .WithIgnoreWildcardRule("WildcardRule", "R?d", true)
            .WithIgnoreRegexRule("RegexRule", @"(f|F)ox", true)
    );
    
    // Log any differences
    foreach (var diff in lineCompareResult.Differences)
    {
        Log(diff.Operation.ToString());
        Console.WriteLine(diff.Text);
        Console.WriteLine("------------------------------------------------------------------------------");
    }var initialText = @"Red fox jumps over the lazy fox";
    var modifiedText = @"Blue fox leaps over the lazy dog";
    
    var lineCompareResult = testing.VerifyTextEquivalence(
        initialText, modifiedText, 
        ComparisonType.Line, 
        TestingOptions.CompareText()
            .WithGenerateHtml(@".\HtmlCompareResults\LineTextCompare.html")
            .WithIgnoreWildcardRule("WildcardRule", "R?d", true)
            .WithIgnoreRegexRule("RegexRule", @"(f|F)ox", true)
    );
    
    // Log any differences
    foreach (var diff in lineCompareResult.Differences)
    {
        Log(diff.Operation.ToString());
        Console.WriteLine(diff.Text);
        Console.WriteLine("------------------------------------------------------------------------------");
    }
    
  3. Comparar texto por palabra:
    En este ejemplo, similar al anterior, estamos comparando dos variables string : initialText y modifiedText. La comparación se realiza a nivel de palabra. La regla de comodín y la regla de expresión regular proporcionadas junto con los métodos WithIgnoreWildcardRule y WithIgnoreRegexRule se utilizan para ignorar patrones específicos en la comparación. Por ejemplo, la regla comodín R?d y la regla regex (f|F)ox nos permiten ignorar ciertas palabras que están presentes en las variables, como Red y Fox.
    El método WithGenerateHtml genera un informe HTML que destaca las diferencias.
    var initialText = "Red fox jumps over the lazy fox";
    var modifiedText = "Blue fox leaps over the lazy dog";
    
    var wordCompareResult = testing.VerifyTextEquivalence(
        initialText, modifiedText, 
        ComparisonType.Word, 
        TestingOptions.CompareText()
            .WithGenerateHtml(@".\HtmlCompareResults\LineWordCompare.html")
            .WithIgnoreWildcardRule("WildcardRule", "R?d", false)
            .WithIgnoreRegexRule("RegexRule", @"(f|F)ox", true)
    );
    
    // Log any differences
    foreach (var diff in wordCompareResult.Differences)
    {
        Log(diff.Operation.ToString());
        Console.WriteLine(diff.Text);
        Console.WriteLine("------------------------------------------------------------------------------");
    }var initialText = "Red fox jumps over the lazy fox";
    var modifiedText = "Blue fox leaps over the lazy dog";
    
    var wordCompareResult = testing.VerifyTextEquivalence(
        initialText, modifiedText, 
        ComparisonType.Word, 
        TestingOptions.CompareText()
            .WithGenerateHtml(@".\HtmlCompareResults\LineWordCompare.html")
            .WithIgnoreWildcardRule("WildcardRule", "R?d", false)
            .WithIgnoreRegexRule("RegexRule", @"(f|F)ox", true)
    );
    
    // Log any differences
    foreach (var diff in wordCompareResult.Differences)
    {
        Log(diff.Operation.ToString());
        Console.WriteLine(diff.Text);
        Console.WriteLine("------------------------------------------------------------------------------");
    }
    
El resultado devuelto por VerifyTextEquivalence incluye una propiedad Differences , que puedes utilizar para imprimir las diferencias entre los textos.

¿Te ha resultado útil esta página?

Obtén la ayuda que necesitas
RPA para el aprendizaje - Cursos de automatización
Foro de la comunidad UiPath
Uipath Logo White
Confianza y seguridad
© 2005-2024 UiPath. Todos los derechos reservados.