activities
latest
false
Wichtig :
Bitte beachten Sie, dass dieser Inhalt teilweise mithilfe von maschineller Übersetzung lokalisiert wurde. Es kann 1–2 Wochen dauern, bis die Lokalisierung neu veröffentlichter Inhalte verfügbar ist.
UiPath logo, featuring letters U and I in white

Workflow-Aktivitäten

Letzte Aktualisierung 6. Dez. 2024

VerifyTextEqualence

Überprüft, ob zwei Texte äquivalent sind, verwendet mehrere Vergleichsoptionen, einschließlich der folgenden Vergleichstypen:
  • Vergleichen von Wörtern.
  • Vergleichen von Zeilen.
  • Vergleichen von Zeichen als char -Variablen.

VerifyTextEquivalence(string, string, ComparisonType, ComparisonOptions)

VerifyTextEquivalence(
    string baselineText,
    string targetText,
    [ComparisonType comparisonType],
    [ComparisonOptions opts]
)VerifyTextEquivalence(
    string baselineText,
    string targetText,
    [ComparisonType comparisonType],
    [ComparisonOptions opts]
)
baselineText String
Der Basistext, der als Referenz für den Vergleich verwendet wird.
targetText String
Der Text, der mit dem Basistext verglichen wird.
comparisonType ComparisonType (Optional)
Der Vergleichstyp, der beim Vergleichen von Texten verwendet werden soll. Die folgenden Optionen sind verfügbar:
  • ComparisonType.Char: Vergleicht jedes Zeichen (char) in den Texten.
  • ComparisonType.Line: Vergleicht jede Zeile in den Texten.
  • ComparisonType.Word: Vergleicht jedes Wort in den Texten.
Optionen CompareDocumentsOptions
Die spezifischen Vergleichsoptionen, die für diesen Vorgang verwendet werden sollen. Um ein Objekt vom Typ CompareDocumentsOptions zu erstellen, verwenden Sie die Klasse TestingOptions.CompareText.

Rückgabewert

ComparisonResult

Das Ergebnis der Vergleichsaktion, das in einer ComparisonResult -Variablen gespeichert wird. Sie können die Eigenschaften AreEquivalent oder Differences auf dem ComparisonResult aufrufen, um anzuzeigen, ob sie äquivalent sind, und wenn nicht, um die Unterschiede anzuzeigen.

Beispiele

Überprüfen Sie die folgenden Beispiele für die Verwendung der VerifyTextEquivalence -API:
  1. Vergleichen von Text nach Zeichen:
    In diesem Beispiel vergleichen wir zwei string -Variablen, initialText und modifiedText. Der Vergleich erfolgt auf Zeichenebene. Die Platzhalterregel und die Regel für reguläre Ausdrücke, die zusammen mit den Methoden WithIgnoreWildcardRule und WithIgnoreRegexRule bereitgestellt werden, werden verwendet, um bestimmte Muster im Vergleich zu ignorieren. Beispielsweise ermöglichen uns die Platzhalterregel R?d und die Regel für reguläre Ausdrücke (f|F)ox , bestimmte Wörter zu ignorieren, die in den Variablen vorhanden sind, z. B. Red, und Fox. In diesem Szenario wurde der Parameter usePlaceholder auf false festgelegt, da wir keinen Platzhalternamen für die ignorierten Muster haben möchten.
    Die Methode WithGenerateHtml gibt einen HTML-Bericht aus, in dem die Unterschiede hervorgehoben werden.
    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. Vergleichen von Text nach Zeile:
    In diesem Beispiel vergleichen wir zwei string -Variablen, initialText und modifiedText. Der Vergleich erfolgt auf Zeilenebene. Die Platzhalterregel und die Regel für reguläre Ausdrücke, die zusammen mit den Methoden WithIgnoreWildcardRule und WithIgnoreRegexRule bereitgestellt werden, werden verwendet, um bestimmte Muster im Vergleich zu ignorieren. Beispielsweise ermöglichen uns die Platzhalterregel R?d und die Regel für reguläre Ausdrücke (f|F)ox , bestimmte Wörter zu ignorieren, die in den Variablen vorhanden sind, z. B. Red, und Fox. In diesem Szenario wurde der Parameter usePlaceholder auf true festgelegt, da wir einen Platzhalternamen für die ignorierten Muster haben möchten.
    Die Methode WithGenerateHtml gibt einen HTML-Bericht aus, in dem die Unterschiede hervorgehoben werden.
    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. Vergleichen von Text für Wort:
    In diesem Beispiel vergleichen wir, ähnlich wie im vorherigen, zwei string -Variablen: initialText und modifiedText. Der Vergleich erfolgt auf Wortebene. Die Platzhalterregel und die Regel für reguläre Ausdrücke, die zusammen mit den Methoden WithIgnoreWildcardRule und WithIgnoreRegexRule bereitgestellt werden, werden verwendet, um bestimmte Muster im Vergleich zu ignorieren. Beispielsweise ermöglichen uns die Platzhalterregel R?d und die Regel für reguläre Ausdrücke (f|F)ox , bestimmte Wörter zu ignorieren, die in den Variablen vorhanden sind, z. B. Red, und Fox.
    Die Methode WithGenerateHtml gibt einen HTML-Bericht aus, in dem die Unterschiede hervorgehoben werden.
    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("------------------------------------------------------------------------------");
    }
    
Das von VerifyTextEquivalence zurückgegebene Ergebnis enthält eine Differences -Eigenschaft, mit der Sie die Unterschiede zwischen Texten ausgeben können.

War diese Seite hilfreich?

Hilfe erhalten
RPA lernen – Automatisierungskurse
UiPath Community-Forum
Uipath Logo White
Vertrauen und Sicherheit
© 2005–2024 UiPath. Alle Rechte vorbehalten