Najít a nahradit

V dokumentu se můžete snadno pohybovat pomocí klávesnice a myši, ale pokud máte k procházení mnoho stránek, nalezení konkrétního textu v dlouhém dokumentu bude chvíli trvat. Bude to časově náročnější, když chcete nahradit určité znaky nebo slova, která jste použili v dokumentu. Funkce “Najít a nahradit” umožňuje najít sekvenci znaků v dokumentu a nahradit ji jinou sekvencí znaků.

Aspose.Words umožňuje najít v dokumentu konkrétní řetězec nebo vzor regulárního výrazu a nahradit jej alternativou bez instalace a použití dalších aplikací, jako je Microsoft Word. To urychlí mnoho úkolů psaní a formátování, což vám potenciálně ušetří hodiny práce.

Tento článek vysvětluje, jak použít nahrazení řetězce a regulární výrazy s podporou metacharacters.

Způsoby, jak najít a nahradit

Aspose.Words poskytuje dva způsoby použití operace najít a nahradit pomocí následujícího:

1. Simple string replacement - Chcete-li najít a nahradit konkrétní řetězec jiným, musíte zadat vyhledávací řetězec (alfanumerické znaky), který bude nahrazen podle všech výskytů jiným zadaným náhradním řetězcem. Oba řetězce nesmí obsahovat symboly. Vezměte v úvahu, že porovnání řetězců může rozlišovat velká a malá písmena, nebo si nejste jisti pravopisem nebo máte několik podobných pravopisů.
2. Regular expressions - Chcete-li zadat regulární výraz, najděte přesné shody řetězců a nahraďte je podle regulárního výrazu. Všimněte si, že slovo je definováno jako tvořené pouze alfanumerickými znaky. Pokud je náhrada provedena pouze s odpovídajícími celými slovy a vstupní řetězec obsahuje symboly, nebudou nalezeny žádné fráze.

Kromě toho můžete použít speciální metaznaky s jednoduchou náhradou řetězců a regulárními výrazy k určení přestávek v rámci operace najít a nahradit.

Aspose.Words představuje funkci Najít a nahradit jmenným prostorem Aspose.Words.Replacing. Během procesu najít a nahradit můžete pracovat s mnoha možnostmi pomocí třídy FindReplaceOptions.

Najděte a nahraďte Text pomocí jednoduché náhrady řetězce

Pomocí jedné z metod Replace můžete najít nebo nahradit konkrétní řetězec a vrátit počet provedených náhrad. V tomto případě můžete určit řetězec, který má být nahrazen, řetězec, který nahradí všechny jeho výskyty, zda náhrada rozlišuje velká a malá písmena a zda budou ovlivněna pouze samostatná slova.

Následující příklad kódu ukazuje, jak najít řetězec “CustomerName " a nahradit jej řetězcem “James Bond”:

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

// Specify the search string and replace string using the Replace method.
doc->get_Range()->Replace(u"_CustomerName_", u"James Bond", System::MakeObject<FindReplaceOptions>());

// Save the result.
System::String outputPath = outputDataDir + u"Range.ReplaceSimple.docx";
doc->Save(outputPath);

Rozdíl mezi dokumentem si můžete všimnout před použitím jednoduché výměny řetězců:

A po použití jednoduché výměny řetězce:

Najděte a nahraďte Text pomocí regulárních výrazů

Regulární výraz (regulární výraz) je vzor, který popisuje určitou posloupnost textu. Předpokládejme, že chcete nahradit všechny dvojité výskyty slova výskytem jednoho slova. Poté můžete použít následující regulární výraz k určení dvouslovného vzoru: ([a-zA-Z]+) \1.

Pomocí jiné metody Replace vyhledejte a nahraďte konkrétní kombinace znaků nastavením parametru Regex jako vzoru regulárního výrazu pro nalezení shod.

Následující příklad kódu ukazuje, jak nahradit řetězce, které odpovídají vzoru regulárního výrazu, zadaným náhradním řetězcem:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<Document> doc = System::MakeObject<Document>();
auto builder = System::MakeObject<DocumentBuilder>(doc);
builder->Writeln(u"sad mad bad");

System::SharedPtr<FindReplaceOptions> options = System::MakeObject<FindReplaceOptions>();

// Replaces all occurrences of the words "sad" or "mad" to "bad".
doc->get_Range()->Replace(System::MakeObject<System::Text::RegularExpressions::Regex>(u"[s|m]ad"), u"bad", options);

const System::String outputPath = outputDataDir + u"FindAndReplaceWithRegex_out.doc";
doc->Save(outputPath);

Rozdíl mezi dokumentem si můžete všimnout před použitím nahrazení řetězce regulárními výrazy:

A po použití nahrazení řetězce regulárními výrazy:

Najděte a nahraďte řetězec pomocí Metacharacters

Pokud se určitý text nebo fráze skládá z více odstavců, oddílů nebo stránek, můžete ve vyhledávacím řetězci nebo v náhradním řetězci použít znaky meta. Některé z metacharakterů zahrnují &p pro konec odstavce, &b pro konec oddílu, &m pro konec stránky a &l pro konec řádku.

Všimněte si, že metacharakter && se rovná &. Pokud například potřebujete najít text pro &p, který není koncem odstavce, můžete použít &&p.

Následující příklad kódu ukazuje, jak nahradit text odstavcem a koncem stránky:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<Document> doc = System::MakeObject<Document>();
System::SharedPtr<DocumentBuilder> builder = System::MakeObject<DocumentBuilder>(doc);

builder->get_Font()->set_Name(u"Arial");
builder->Writeln(u"First section");
builder->Writeln(u"  1st paragraph");
builder->Writeln(u"  2nd paragraph");
builder->Writeln(u"{insert-section}");
builder->Writeln(u"Second section");
builder->Writeln(u"  1st paragraph");

System::SharedPtr<FindReplaceOptions> options = System::MakeObject<FindReplaceOptions>();
options->get_ApplyParagraphFormat()->set_Alignment(ParagraphAlignment::Center);

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

// Insert section break instead of custom text tag.
count = doc->get_Range()->Replace(u"{insert-section}", u"&b", options);

System::String savePath = outputDataDir + u"FindReplaceUsingMetaCharacters.ReplaceTextContaingMetaCharacters.docx";
doc->Save(savePath);

Najít a nahradit řetězec v záhlaví / zápatí dokumentu

Text můžete najít a nahradit v části Záhlaví/zápatí dokumentu Word pomocí třídy HeaderFooter.

Následující příklad kódu ukazuje, jak nahradit text části záhlaví v dokumentu:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Open the template document, containing obsolete copyright information in the footer.
auto doc = System::MakeObject<Document>(inputDataDir + u"HeaderFooter.ReplaceText.doc");

// Access header of the Word document.
auto headersFooters = doc->get_FirstSection()->get_HeadersFooters();
auto header = headersFooters->idx_get(HeaderFooterType::HeaderPrimary);

// Set options.
auto options = System::MakeObject<FindReplaceOptions>();
options->set_MatchCase(false);
options->set_FindWholeWordsOnly(false);

// Replace text in the header of the Word document.
header->get_Range()->Replace(u"Aspose.Words", u"Remove", options);

auto footer = headersFooters->idx_get(HeaderFooterType::FooterPrimary);
footer->get_Range()->Replace(u"(C) 2006 Aspose Pty Ltd.", u"Copyright (C) Aspose Pty Ltd.", options);


// Save the Word document.
doc->Save(outputDataDir + u"HeaderReplace.docx");

Rozdíl mezi dokumentem si můžete všimnout před použitím nahrazení řetězce záhlaví:

A po použití nahrazení řetězce záhlaví:

Příklad kódu, který nahradí text části zápatí v dokumentu, je velmi podobný předchozímu příkladu kódu záhlaví. Vše, co musíte udělat, je nahradit následující dva řádky:

auto header = headersFooters->idx_get(HeaderFooterType::HeaderPrimary);
header->get_Range()->Replace(u"Aspose.Words", u"Remove", options);

S následujícími:

auto footer = headersFooters->idx_get(HeaderFooterType::FooterPrimary);
footer->get_Range()->Replace(u"(C) 2006 Aspose Pty Ltd.", u"Copyright (C) Aspose Pty Ltd.", options);

Rozdíl mezi dokumentem si můžete všimnout před použitím nahrazení řetězce zápatí:

A po použití zápatí řetězec nahrazení:

Ignorujte Text během hledání a nahrazení

Při použití operace najít a nahradit můžete ignorovat určité segmenty textu. Některé části textu lze tedy z vyhledávání vyloučit a najít a nahradit lze použít pouze na zbývající části.

Aspose.Words poskytuje mnoho vlastností najít a nahradit pro ignorování textu, jako například IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, a IgnoreInserted.

Následující příklad kódu ukazuje, jak ignorovat text uvnitř odstranit revize:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
System::SharedPtr<Document> doc = System::MakeObject<Document>();
System::SharedPtr<DocumentBuilder> builder = System::MakeObject<DocumentBuilder>(doc);

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

// Remove first paragraph with tracking revisions.
doc->StartTrackRevisions(u"John Doe", System::DateTime::get_Now());
doc->get_FirstSection()->get_Body()->get_FirstParagraph()->Remove();
doc->StopTrackRevisions();

System::SharedPtr<FindReplaceOptions> options = System::MakeObject<FindReplaceOptions>();

// Replace 'e' in document while deleted text.
options->set_IgnoreDeleted(true);
doc->get_Range()->Replace(System::MakeObject<Regex>(u"e"), u"*", options);
std::cout << doc->GetText().ToUtf8String() << std::endl; // The output is: Deleted\rT*xt\f

// Replace 'e' in document NOT ignoring deleted text.
options->set_IgnoreDeleted(false);
doc->get_Range()->Replace(System::MakeObject<Regex>(u"e"), u"*", options);
std::cout << doc->GetText().ToUtf8String() << std::endl; // The output is: D*l*t*d\rT*xt\f

Přizpůsobení operace najít a nahradit

Aspose.Words poskytuje mnoho různých properties k vyhledání a nahrazení textu, například použití konkrétního formátu s vlastnostmi ApplyFont a ApplyParagraphFormats, použití substitucí v náhradních vzorcích s vlastností UseSubstitutions a další.

Následující příklad kódu ukazuje, jak zvýraznit konkrétní slovo v dokumentu:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Highlight word "the" with yellow color.
auto options = System::MakeObject<FindReplaceOptions>();
options->get_ApplyFont()->set_HighlightColor(System::Drawing::Color::get_Yellow());

// Replace highlighted text.
doc->get_Range()->Replace(u"Hello", u"Hello", options);

Aspose.Words umožňuje použít rozhraní IReplacingCallback k vytvoření a volání vlastní metody během operace nahrazení. Můžete mít některé případy použití, kdy potřebujete přizpůsobit operaci najít a nahradit, jako je nahrazení textu určeného regulárním výrazem značkami HTML, takže v zásadě použijete nahradit vložením HTML.

Pokud potřebujete nahradit řetězec značkou HTML, Použijte rozhraní IReplacingCallback k přizpůsobení operace najít a nahradit tak, aby shoda začala na začátku běhu s uzlem shody vašeho dokumentu. Uveďme několik příkladů použití IReplacingCallback.

Následující příklad kódu ukazuje, jak nahradit text zadaný HTML:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
class ReplaceWithHtmlEvaluator : public IReplacingCallback
{
    typedef ReplaceWithHtmlEvaluator ThisType;
    typedef IReplacingCallback BaseType;

    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    RTTI_INFO(ThisType, ThisTypeBaseTypesInfo);

public:
    ReplaceWithHtmlEvaluator(System::SharedPtr<FindReplaceOptions> options);
    ReplaceAction Replacing(System::SharedPtr<ReplacingArgs> args) override;

private:
    System::SharedPtr<FindReplaceOptions> mOptions;
};

ReplaceWithHtmlEvaluator::ReplaceWithHtmlEvaluator(System::SharedPtr<FindReplaceOptions> options)
{
    mOptions = options;
}

ReplaceAction ReplaceWithHtmlEvaluator::Replacing(System::SharedPtr<ReplacingArgs> args)
{
    System::SharedPtr<DocumentBuilder> builder = System::MakeObject<DocumentBuilder>(System::DynamicCast<Document>(args->get_MatchNode()->get_Document()));
    builder->MoveTo(args->get_MatchNode());

    // Replace '<CustomerName>' text with a red bold name.
    builder->InsertHtml(u"<b><font color='red'>James Bond, </font></b>");
    args->set_Replacement(u"");

    return ReplaceAction::Replace;
}

void ReplaceWithHtml(System::String const& inputDataDir, System::String const& outputDataDir)
{
    auto doc = System::MakeObject<Document>();
    auto builder = System::MakeObject<DocumentBuilder>(doc);

    builder->Writeln(u"Hello <CustomerName>,");

    auto options = System::MakeObject<FindReplaceOptions>();
    auto optionsReplacingCallback = System::MakeObject<ReplaceWithHtmlEvaluator>(options);

    doc->get_Range()->Replace(new Regex(u" <CustomerName>,"), System::String::Empty, options);

    // Save the modified document. 
    doc->Save(outputDataDir + u"Range.ReplaceWithInsertHtml.doc");
}

Následující příklad kódu ukazuje, jak zvýraznit kladná čísla zelenou barvou a záporná čísla červenou barvou:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Replace and Highlight Numbers.
class NumberHighlightCallback : public IReplacingCallback
{
    typedef NumberHighlightCallback ThisType;
    typedef IReplacingCallback BaseType;

    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    RTTI_INFO(ThisType, ThisTypeBaseTypesInfo);
public:
    NumberHighlightCallback(System::SharedPtr<FindReplaceOptions> const& opt)
        : mOpt(opt) { }

    Aspose::Words::Replacing::ReplaceAction Replacing(System::SharedPtr<Aspose::Words::Replacing::ReplacingArgs> args) override
    {
        // Let replacement to be the same text.
        args->set_Replacement(args->get_Match()->get_Value());
        auto val = System::Convert::ToInt32(args->get_Match()->get_Value());

        // Apply either red or green color depending on the number value sign.
        mOpt->get_ApplyFont()->set_Color(val > 0 ? System::Drawing::Color::get_Green() : System::Drawing::Color::get_Red());
        return ReplaceAction::Replace;
    }
private:
    System::SharedPtr<FindReplaceOptions> mOpt;
};

Následující příklad kódu ukazuje, jak předřadit číslo řádku na každý řádek:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
class LineCounterCallback : public IReplacingCallback
{
    typedef LineCounterCallback ThisType;
    typedef IReplacingCallback BaseType;
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    RTTI_INFO(ThisType, ThisTypeBaseTypesInfo);
public:
    Aspose::Words::Replacing::ReplaceAction Replacing(System::SharedPtr<Aspose::Words::Replacing::ReplacingArgs> args) override
    {
        std::cout << args->get_Match()->get_Value().ToUtf8String() << '\n';
        args->set_Replacement(System::String::Format(u"{0} {1}", mCounter++, args->get_Match()->get_Value()));
        return ReplaceAction::Replace;
    }
private:
    int32_t mCounter = 1;
};

void LineCounter(System::String const& inputDataDir, System::String const& outputDataDir)
{
    // Create a document.
    auto doc = System::MakeObject<Document>();
    auto builder = System::MakeObject<DocumentBuilder>(doc);

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

    // Prepend each line with line number.
    auto opt = System::MakeObject<FindReplaceOptions>();
    opt->set_ReplacingCallback(System::MakeObject<LineCounterCallback>());
    doc->get_Range()->Replace(System::MakeObject<Regex>(u"[^&p]*&p"), u"", opt);

    doc->Save(outputDataDir + u"TestLineCounter.docx");
}