Znajdź i zamień

Możesz łatwo poruszać się po dokumencie za pomocą klawiatury i myszy, ale jeśli masz wiele stron do przewinięcia, znalezienie określonego tekstu w długim dokumencie zajmie sporo czasu. Zastąpienie niektórych znaków lub słów użytych w dokumencie będzie bardziej czasochłonne. Funkcjonalność “Znajdź i zamień” umożliwia odnalezienie ciągu znaków w dokumencie i zastąpienie go innym ciągiem znaków.

Aspose.Words umożliwia znalezienie określonego ciągu znaków lub wzorca wyrażenia regularnego w dokumencie i zastąpienie go alternatywą bez instalowania i używania dodatkowych aplikacji, takich jak Microsoft Word. Przyspieszy to wiele zadań związanych z pisaniem i formatowaniem, potencjalnie oszczędzając godziny pracy.

W tym artykule wyjaśniono, jak zastosować zamianę ciągów i wyrażenia regularne z obsługą metaznaków.

Sposoby znajdowania i zamiany

Aspose.Words udostępnia dwa sposoby stosowania operacji znajdowania i zamieniania, korzystając z następujących metod:

1. Prosta zamiana ciągu – aby znaleźć i zamienić konkretny ciąg na inny, należy podać szukany ciąg (znaki alfanumeryczne), który będzie zastępowany przy każdym wystąpieniu innym określonym ciągiem zastępczym. Oba ciągi nie mogą zawierać symboli. Weź pod uwagę, że przy porównywaniu ciągów może uwzględniać wielkość liter lub możesz nie być pewien pisowni lub mieć kilka podobnych pisowni.
2. Wyrażenia regularne – aby określić wyrażenie regularne, aby znaleźć dokładnie pasujące ciągi znaków i zastąpić je zgodnie z wyrażeniem regularnym. Należy pamiętać, że słowo definiuje się jako składające się wyłącznie ze znaków alfanumerycznych. Jeśli zamiana zostanie wykonana z dopasowaniem tylko całych słów, a ciąg wejściowy będzie zawierał symbole, wówczas nie zostaną znalezione żadne frazy.

Ponadto można używać specjalnych metaznaków przy prostej zamianie ciągów znaków i wyrażeń regularnych w celu określenia przerw w operacji znajdowania i zamiany.

Aspose.Words przedstawia funkcję wyszukiwania i zamiany w przestrzeni nazw Aspose.Words.Replacing. Podczas procesu znajdowania i zamieniania można pracować z wieloma opcjami, korzystając z klasy FindReplaceOptions.

Znajdź i zamień tekst za pomocą prostej zamiany ciągów

Możesz użyć jednej z metod Replace, aby znaleźć lub zamienić określony ciąg znaków i zwrócić liczbę dokonanych zamian. W takim przypadku możesz określić ciąg znaków, który ma zostać zastąpiony, ciąg, który zastąpi wszystkie jego wystąpienia, czy przy zamianie uwzględniana jest wielkość liter i czy wpłynie to tylko na pojedyncze słowa.

Poniższy przykład kodu pokazuje, jak znaleźć ciąg “CustomerName” i zastąpić go ciągiem “James Bond”:

// 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");

Możesz zauważyć różnicę między dokumentem przed zastosowaniem prostej zamiany ciągu znaków:

A po zastosowaniu prostej zamiany ciągów:

Znajdź i zamień tekst za pomocą wyrażeń regularnych

Wyrażenie regularne (regex) to wzorzec opisujący określoną sekwencję tekstu. Załóżmy, że chcesz zastąpić wszystkie podwójne wystąpienia słowa pojedynczym wystąpieniem słowa. Następnie możesz zastosować następujące wyrażenie regularne, aby określić wzorzec podwójnych słów: ([a-zA-Z]+) \1.

Użyj innej metody Replace, aby wyszukać i zastąpić określone kombinacje znaków, ustawiając parametr Regex jako wzorzec wyrażenia regularnego w celu znalezienia dopasowań.

Poniższy przykład kodu pokazuje, jak zastąpić ciągi pasujące do wzorca wyrażenia regularnego określonym ciągiem zastępczym:

// 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");

Różnicę pomiędzy dokumentem można zauważyć przed zastosowaniem zamiany ciągów na wyrażenia regularne:

A po zastosowaniu zamiany ciągów na wyrażenia regularne:

Znajdź i zamień ciąg przy użyciu metaznaków

Jeśli dany tekst lub fraza składa się z wielu akapitów, sekcji lub stron, możesz użyć metaznaków w ciągu wyszukiwania lub ciągu zastępczym. Niektóre metaznaki obejmują &P dla podziału akapitu, &B dla podziału sekcji, &M dla podziału strony i &l dla podziału wiersza.

Należy pamiętać, że metaznak && jest równy &. Na przykład, jeśli chcesz znaleźć tekst w formacie &P, który nie jest podziałem akapitu, możesz użyć &&P.

Poniższy przykład kodu pokazuje, jak zastąpić tekst akapitem i podziałem strony:

// 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);

Znajdź i zamień ciąg w nagłówku/stopce dokumentu

Możesz znaleźć i zamienić tekst w sekcji nagłówka/stopki dokumentu Word, korzystając z klasy HeaderFooter.

Poniższy przykład kodu pokazuje, jak zastąpić tekst sekcji nagłówka w dokumencie:

// 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");

Możesz zauważyć różnicę między dokumentem przed zastosowaniem zamiany ciągu nagłówka:

A po zastosowaniu zamiany ciągu nagłówka:

Przykładowy kod zastępujący tekst sekcji stopki w dokumencie jest bardzo podobny do poprzedniego przykładowego kodu nagłówka. Wszystko, co musisz zrobić, to zastąpić następujące dwie linie:

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

Z następującymi:

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);

Możesz zauważyć różnicę między dokumentem przed zastosowaniem zamiany ciągu stopki:

A po zastosowaniu zamiany ciągu stopki:

Ignoruj tekst podczas wyszukiwania i zamiany

Stosując operację znajdź i zamień, możesz zignorować niektóre segmenty tekstu. Zatem niektóre części tekstu można wykluczyć z wyszukiwania, a funkcję Znajdź i Zamień można zastosować tylko do pozostałych części.

Aspose.Words udostępnia wiele właściwości wyszukiwania i zamiany umożliwiających ignorowanie tekstu, takich jak IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes i IgnoreInserted.

Poniższy przykład kodu pokazuje, jak zignorować tekst w usuwanych wersjach:

// 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);

Dostosuj operację Znajdź i zamień

Aspose.Words udostępnia wiele różnych formatów properties do wyszukiwania i zastępowania tekstu, takich jak stosowanie określonego formatu z właściwościami ApplyFont i ApplyParagraphFormats, używanie podstawień we wzorcach zastępowania właściwością UseSubstitutions i inne.

Poniższy przykład kodu pokazuje, jak wyróżnić określone słowo w dokumencie:

// 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);

Aspose.Words umożliwia użycie interfejsu IReplacingCallback do tworzenia i wywoływania metody niestandardowej podczas operacji zamiany. Możesz mieć pewne przypadki użycia, w których będziesz musiał dostosować operację znajdowania i zamiany, na przykład zastąpienie tekstu określonego wyrażeniem regularnym znacznikami HTML, więc zasadniczo zastosujesz zamianę, wstawiając kod HTML.

Jeśli chcesz zamienić ciąg znaków na znacznik HTML, zastosuj interfejs IReplacingCallback, aby dostosować operację znajdowania i zamiany tak, aby dopasowanie rozpoczynało się na początku przebiegu z węzłem dopasowania w dokumencie. Podajmy kilka przykładów użycia IReplacingCallback.

Poniższy przykład kodu pokazuje, jak zastąpić tekst określony kodem HTML:

// 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;
}

Poniższy przykład kodu pokazuje, jak wyróżnić liczby dodatnie kolorem zielonym i liczby ujemne kolorem czerwonym:

// 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;
}

Poniższy przykład kodu pokazuje, jak dodać numer linii do każdej linii:

// 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;
}