Suchen und Ersetzen

Mit Tastatur und Maus können Sie problemlos in Ihrem Dokument navigieren. Wenn Sie jedoch durch viele Seiten scrollen müssen, dauert es eine ganze Weile, bis Sie in einem langen Dokument einen bestimmten Text finden. Es wird zeitaufwändiger sein, wenn Sie bestimmte Zeichen oder Wörter ersetzen möchten, die Sie in Ihrem Dokument verwendet haben. Mit der Funktion “Suchen und Ersetzen” können Sie eine Zeichenfolge in einem Dokument finden und durch eine andere Zeichenfolge ersetzen.

Mit Aspose.Words können Sie eine bestimmte Zeichenfolge oder ein Muster eines regulären Ausdrucks in Ihrem Dokument finden und durch eine Alternative ersetzen, ohne zusätzliche Anwendungen wie Microsoft Word installieren und verwenden zu müssen. Dadurch werden viele Tipp- und Formatierungsaufgaben beschleunigt, was Ihnen möglicherweise stundenlange Arbeit erspart.

In diesem Artikel wird erläutert, wie Sie String-Ersetzung und reguläre Ausdrücke mit Unterstützung von Metazeichen anwenden.

Möglichkeiten, {#ways-to-find-and-replace} zu finden und zu ersetzen

Aspose.Words bietet zwei Möglichkeiten, den Such- und Ersetzungsvorgang anzuwenden, indem es Folgendes verwendet:

1. Einfache Zeichenfolgenersetzung – um eine bestimmte Zeichenfolge zu finden und durch eine andere zu ersetzen, müssen Sie eine Suchzeichenfolge (alphanumerische Zeichen) angeben, die bei jedem Vorkommen durch eine andere angegebene Ersatzzeichenfolge ersetzt wird. Beide Zeichenfolgen dürfen keine Symbole enthalten. Berücksichtigen Sie, dass beim Vergleich von Zeichenfolgen die Groß-/Kleinschreibung beachtet werden kann. Andernfalls sind Sie möglicherweise nicht sicher, was die Schreibweise angeht, oder Sie haben mehrere ähnliche Schreibweisen.
2. Reguläre Ausdrücke – um einen regulären Ausdruck anzugeben, um die genauen Zeichenfolgenübereinstimmungen zu finden und sie entsprechend Ihrem regulären Ausdruck zu ersetzen. Beachten Sie, dass ein Wort nur aus alphanumerischen Zeichen besteht. Wenn beim Ersetzen nur ganze Wörter gefunden werden und die Eingabezeichenfolge zufällig Symbole enthält, werden keine Phrasen gefunden.

Darüber hinaus können Sie spezielle Metazeichen mit einfacher Zeichenfolgenersetzung und regulären Ausdrücken verwenden, um Pausen innerhalb des Such- und Ersetzungsvorgangs anzugeben.

Aspose.Words bietet die Such- und Ersetzungsfunktion mit dem Aspose.Words.Replacing-Namespace. Mithilfe der FindReplaceOptions-Klasse können Sie während des Such- und Ersetzungsprozesses mit vielen Optionen arbeiten.

Suchen und ersetzen Sie Text mithilfe der einfachen Zeichenfolgenersetzung

Sie können eine der Replace-Methoden verwenden, um eine bestimmte Zeichenfolge zu suchen oder zu ersetzen und die Anzahl der vorgenommenen Ersetzungen zurückzugeben. In diesem Fall können Sie eine zu ersetzende Zeichenfolge angeben, eine Zeichenfolge, die alle Vorkommen ersetzt, ob bei der Ersetzung die Groß-/Kleinschreibung beachtet werden soll und ob nur eigenständige Wörter betroffen sein sollen.

Das folgende Codebeispiel zeigt, wie Sie die Zeichenfolge “CustomerName” finden und durch die Zeichenfolge “James Bond” ersetzen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// Load a Word Docx document by creating an instance of the Document class.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.Writeln("Hello _CustomerName_,");

// Specify the search string and replace string using the Replace method.
doc.Range.Replace("_CustomerName_", "James Bond", new FindReplaceOptions());

// Save the result.
doc.Save(dataDir + "Range.ReplaceSimple.docx");

Sie können den Unterschied zwischen dem Dokument erkennen, bevor Sie eine einfache Zeichenfolgenersetzung anwenden:

Und nach der einfachen String-Ersetzung:

Suchen und Ersetzen von Text mithilfe regulärer Ausdrücke

Ein regulärer Ausdruck (Regex) ist ein Muster, das eine bestimmte Textsequenz beschreibt. Angenommen, Sie möchten alle doppelten Vorkommen eines Wortes durch ein einziges Wort ersetzen. Anschließend können Sie den folgenden regulären Ausdruck anwenden, um das Doppelwortmuster anzugeben: ([a-zA-Z]+) \1.

Verwenden Sie die andere Replace-Methode, um bestimmte Zeichenkombinationen zu suchen und zu ersetzen, indem Sie den Regex-Parameter als reguläres Ausdrucksmuster festlegen, um Übereinstimmungen zu finden.

Das folgende Codebeispiel zeigt, wie Zeichenfolgen, die einem regulären Ausdrucksmuster entsprechen, durch eine angegebene Ersetzungszeichenfolge ersetzt werden:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.Writeln("sad mad bad");

Assert.AreEqual("sad mad bad", doc.GetText().Trim());

// Replaces all occurrences of the words "sad" or "mad" to "bad".
doc.Range.Replace(new Regex("[s|m]ad"), "bad");

// Save the Word document.
doc.Save("Range.ReplaceWithRegex.docx");

Sie können den Unterschied zwischen dem Dokument erkennen, bevor Sie die Zeichenfolgenersetzung durch reguläre Ausdrücke anwenden:

Und nach der String-Ersetzung durch reguläre Ausdrücke:

Suchen und Ersetzen von Zeichenfolgen mithilfe von Metazeichen

Sie können Metazeichen in der Suchzeichenfolge oder der Ersetzungszeichenfolge verwenden, wenn ein bestimmter Text oder Satz aus mehreren Absätzen, Abschnitten oder Seiten besteht. Zu den Metazeichen gehören &P für einen Absatzumbruch, &B für einen Abschnittsumbruch, &M für einen Seitenumbruch und &l für einen Zeilenumbruch.

Beachten Sie, dass das Metazeichen && & entspricht. Wenn Sie beispielsweise Text für &P suchen müssen, der kein Absatzumbruch ist, können Sie &&P verwenden.

Das folgende Codebeispiel zeigt, wie Text durch Absatz und Seitenumbruch ersetzt wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.Font.Name = "Arial";
builder.Writeln("First section");
builder.Writeln("  1st paragraph");
builder.Writeln("  2nd paragraph");
builder.Writeln("{insert-section}");
builder.Writeln("Second section");
builder.Writeln("  1st paragraph");

FindReplaceOptions options = new FindReplaceOptions();
options.ApplyParagraphFormat.Alignment = ParagraphAlignment.Center;

// Double each paragraph break after word "section", add kind of underline and make it centered.
int count = doc.Range.Replace("section&p", "section&p----------------------&p", options);

// Insert section break instead of custom text tag.
count = doc.Range.Replace("{insert-section}", "&b", options);
dataDir = dataDir + "ReplaceTextContaingMetaCharacters_out.docx";
doc.Save(dataDir);

Suchen und ersetzen Sie eine Zeichenfolge in der Kopf-/Fußzeile eines {#find-and-replace-string-in-header-or-footer-of-a-document}-Dokuments

Mithilfe der HeaderFooter-Klasse können Sie Text im Kopf-/Fußzeilenbereich eines Word-Dokuments suchen und ersetzen.

Das folgende Codebeispiel zeigt, wie Sie den Text des Kopfzeilenabschnitts in Ihrem Dokument ersetzen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// Open the template document, containing obsolete copyright information in the footer.
Document doc = new Document(dataDir + "HeaderFooter.ReplaceText.doc");

// Access header of the Word document.
HeaderFooterCollection headersFooters = doc.FirstSection.HeadersFooters;
HeaderFooter header = headersFooters[HeaderFooterType.HeaderPrimary];

// Set options.
FindReplaceOptions options = new FindReplaceOptions
{
    MatchCase = false,
    FindWholeWordsOnly = false
};

// Replace text in the header of the Word document.
header.Range.Replace("Aspose.Words", "Remove", options);

// Save the Word document.
doc.Save(dataDir + "HeaderReplace.docx");

Sie können den Unterschied zwischen dem Dokument erkennen, bevor Sie die Ersetzung der Header-Zeichenfolge anwenden:

Und nach der Anwendung der Header-String-Ersetzung:

Das Codebeispiel zum Ersetzen des Texts des Fußzeilenabschnitts in Ihrem Dokument ist dem vorherigen Codebeispiel für die Kopfzeile sehr ähnlich. Sie müssen lediglich die folgenden beiden Zeilen ersetzen:

HeaderFooter header = headersFooters[HeaderFooterType.HeaderPrimary];
header.Range.Replace("Aspose.Words", "Remove", options);

Mit den folgenden:

HeaderFooter footer = headersFooters[HeaderFooterType.FooterPrimary];
int currentYear = System.DateTime.Now.Year;
footer.Range.Replace("(C) 2006 Aspose Pty Ltd.", $"Copyright (C) {currentYear} by Aspose Pty Ltd.", options);

Sie können den Unterschied zwischen dem Dokument erkennen, bevor Sie die Ersetzung der Fußzeilenzeichenfolge anwenden:

Und nach dem Ersetzen der Fußzeilenzeichenfolge:

Text beim Suchen und Ersetzen von {#ignore-text-during-find-and-replace} ignorieren

Während Sie den Such- und Ersetzungsvorgang anwenden, können Sie bestimmte Textsegmente ignorieren. So können bestimmte Teile des Textes von der Suche ausgeschlossen werden und das Suchen und Ersetzen nur auf die übrigen Teile angewendet werden.

Aspose.Words bietet viele Such- und Ersetzungseigenschaften zum Ignorieren von Text wie IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes und IgnoreInserted.

Das folgende Codebeispiel zeigt, wie Text in Löschrevisionen ignoriert wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

// Insert non-revised text.
builder.Writeln("Deleted");
builder.Write("Text");

// Remove first paragraph with tracking revisions.
doc.StartTrackRevisions("John Doe", DateTime.Now);
doc.FirstSection.Body.FirstParagraph.Remove();
doc.StopTrackRevisions();

Regex regex = new Regex("e");
FindReplaceOptions options = new FindReplaceOptions();

// Replace 'e' in document while ignoring deleted text.
options.IgnoreDeleted = true;
doc.Range.Replace(regex, "*", options);

Assert.AreEqual(doc.GetText().Trim(), "Deleted\rT*xt");

// Replace 'e' in document while not ignoring deleted text.
options.IgnoreDeleted = false;
doc.Range.Replace(regex, "*", options);

Passen Sie den Such- und Ersetzungsvorgang {#customize-find-and-replace-operation} an

Aspose.Words bietet viele verschiedene properties zum Suchen und Ersetzen von Text, z. B. das Anwenden eines bestimmten Formats mit ApplyFont- und ApplyParagraphFormats-Eigenschaften, die Verwendung von Ersetzungen in Ersetzungsmustern mit UseSubstitutions-Eigenschaften und andere.

Das folgende Codebeispiel zeigt, wie Sie ein bestimmtes Wort in Ihrem Dokument hervorheben:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// Highlight word "the" with yellow color.
FindReplaceOptions options = new FindReplaceOptions();
options.ApplyFont.HighlightColor = Color.Yellow;

// Replace highlighted text.
doc.Range.Replace("Hello", "Hello", options);

Mit Aspose.Words können Sie die IReplacingCallback-Schnittstelle verwenden, um während eines Ersetzungsvorgangs eine benutzerdefinierte Methode zu erstellen und aufzurufen. Möglicherweise gibt es einige Anwendungsfälle, in denen Sie den Such- und Ersetzungsvorgang anpassen müssen, z. B. das Ersetzen von mit einem regulären Ausdruck angegebenem Text durch HTML-Tags. Grundsätzlich wenden Sie also das Ersetzen durch Einfügen von HTML an.

Wenn Sie eine Zeichenfolge durch ein HTML-Tag ersetzen müssen, wenden Sie die IReplacingCallback-Schnittstelle an, um den Such- und Ersetzungsvorgang so anzupassen, dass die Übereinstimmung am Anfang einer Ausführung mit dem Übereinstimmungsknoten Ihres Dokuments beginnt. Lassen Sie uns einige Beispiele für die Verwendung von IReplacingCallback bereitstellen.

Das folgende Codebeispiel zeigt, wie der angegebene Text durch HTML ersetzt wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
public static void ReplaceWithHtml(string dataDir)
{
    Document doc = new Document();
    DocumentBuilder builder = new DocumentBuilder(doc);

    builder.Writeln("Hello <CustomerName>,");

    FindReplaceOptions options = new FindReplaceOptions();
    options.ReplacingCallback = new ReplaceWithHtmlEvaluator(options);

    doc.Range.Replace(new Regex(@" <CustomerName>,"), String.Empty, options);

    // Save the modified document. 
    doc.Save(dataDir + "Range.ReplaceWithInsertHtml.doc");
}

private class ReplaceWithHtmlEvaluator : IReplacingCallback
{
    internal ReplaceWithHtmlEvaluator(FindReplaceOptions options)
    {
        mOptions = options;
    }

    //This simplistic method will only work well when the match starts at the beginning of a run. 
    ReplaceAction IReplacingCallback.Replacing(ReplacingArgs args)
    {
        DocumentBuilder builder = new DocumentBuilder((Document)args.MatchNode.Document);
        builder.MoveTo(args.MatchNode);

        // Replace '<CustomerName>' text with a red bold name.
        builder.InsertHtml("<b><font color='red'>James Bond, </font></b>"); args.Replacement = "";
        return ReplaceAction.Replace;
    }

    private readonly FindReplaceOptions mOptions;
}

Das folgende Codebeispiel zeigt, wie man positive Zahlen mit grüner Farbe und negative Zahlen mit roter Farbe hervorhebt:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
// Replace and Highlight Numbers.
internal class NumberHighlightCallback : IReplacingCallback
{
    public NumberHighlightCallback(FindReplaceOptions opt)
    {
        mOpt = opt;
    }

    public ReplaceAction Replacing(ReplacingArgs args)
    {
        // Let replacement to be the same text.
        args.Replacement = args.Match.Value;

        int val = int.Parse(args.Match.Value);

        // Apply either red or green color depending on the number value sign.
        mOpt.ApplyFont.Color = (val > 0)
            ? Color.Green
            : Color.Red;

        return ReplaceAction.Replace;
    }

    private readonly FindReplaceOptions mOpt;
}

Das folgende Codebeispiel zeigt, wie jeder Zeile eine Zeilennummer vorangestellt wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET
public void LineCounter()
{
    // Create a document.
    Document doc = new Document();
    DocumentBuilder builder = new DocumentBuilder(doc);

    // Add lines of text.
    builder.Writeln("This is first line");
    builder.Writeln("Second line");
    builder.Writeln("And last line");

    // Prepend each line with line number.
    FindReplaceOptions opt = new FindReplaceOptions() { ReplacingCallback = new LineCounterCallback() };
    doc.Range.Replace(new Regex("[^&p]*&p"), "", opt);

    doc.Save(@"X:\TestLineCounter.docx");
}

internal class LineCounterCallback : IReplacingCallback
{
    public ReplaceAction Replacing(ReplacingArgs args)
    {
        Debug.WriteLine(args.Match.Value);

        args.Replacement = string.Format("{0} {1}", mCounter++, args.Match.Value);
        return ReplaceAction.Replace;
    }

    private int mCounter = 1;
}