Localizar e substituir

Você pode navegar facilmente em seu documento usando um teclado e mouse, mas se tiver muitas páginas para percorrer, levará um bom tempo para encontrar um texto específico em um documento longo. Será mais demorado quando pretender substituir determinados caracteres ou palavras que utilizou no seu documento. A funcionalidade “Localizar e substituir” permite localizar uma sequência de caracteres num documento e substituí-la por outra sequência de caracteres.

Aspose.Words permite que você encontre uma string específica ou padrão de expressão regular em seu documento e substitua-o por uma alternativa sem instalar e usar aplicativos adicionais, como Microsoft Word. Isso acelerará muitas tarefas de digitação e formatação, potencialmente economizando horas de trabalho.

Este artigo explica como aplicar a substituição de strings e expressões regulares com o Suporte de metacaracteres.

Formas de encontrar e substituir

Aspose.Words fornece duas maneiras de aplicar a operação localizar e substituir usando o seguinte:

1. Simple string replacement - para encontrar e substituir uma string específica por outra, é necessário especificar uma string de pesquisa (caracteres alfanuméricos) que será substituída de acordo com todas as ocorrências por outra string de substituição especificada. Ambas as cadeias não devem conter símbolos. Leve em consideração que a comparação de strings pode diferenciar maiúsculas de minúsculas, ou você pode não ter certeza da ortografia ou ter várias grafias semelhantes.
2. Regular expressions - para especificar uma expressão regular para encontrar as correspondências exatas da string e substituí-las de acordo com sua expressão regular. Observe que uma palavra é definida como sendo composta apenas por caracteres alfanuméricos. Se uma substituição for executada com apenas palavras inteiras sendo correspondidas e a string de entrada contiver símbolos, nenhuma frase será encontrada.

Além disso, você pode usar metacaracteres especiais com substituição de string simples e expressões regulares para especificar quebras na operação localizar e substituir.

Aspose.Words apresenta a funcionalidade localizar e substituir com o namespace Aspose.Words.Replacing. Você pode trabalhar com muitas opções durante o processo localizar e substituir usando a classe FindReplaceOptions.

Localizar e substituir texto usando substituição de String simples

Você pode usar um dos métodos Replace para localizar ou substituir uma string específica e retornar o número de substituições que foram feitas. Nesse caso, você pode especificar uma string a ser substituída, uma string que substituirá todas as suas ocorrências, se a substituição diferencia maiúsculas de minúsculas e se apenas palavras independentes serão afetadas.

O exemplo de código a seguir mostra como encontrar a string"_ CustomerName _ " e substituí-la pela string *“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);

Você pode notar a diferença entre o documento antes de aplicar a substituição simples da string:

E depois de aplicar a substituição simples da corda:

Localizar e substituir texto usando expressões regulares

Uma expressão regular (regex) é um padrão que descreve uma determinada sequência de texto. Suponha que você queira substituir todas as ocorrências duplas de uma palavra por uma ocorrência de uma única palavra. Em seguida, você pode aplicar a seguinte expressão regular para especificar o padrão de palavra dupla: ([a-zA-Z]+) \1.

Use o outro método Replace para pesquisar e substituir combinações de caracteres específicas definindo o parâmetro Regex como o padrão de expressão regular para encontrar correspondências.

O exemplo de código a seguir mostra como substituir strings que correspondem a um padrão de expressão regular por uma string de substituição especificada:

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

Você pode notar a diferença entre o documento antes de aplicar a substituição de string por expressões regulares:

E depois de aplicar a substituição de string com expressões regulares:

Localizar e substituir String usando metacaracteres

Você pode usar metacaracteres na string de pesquisa ou na string de substituição se um determinado texto ou frase for composto por vários parágrafos, seções ou páginas. Alguns dos metacaracteres incluem &p para uma quebra de parágrafo, &b para uma quebra de Seção, &m para uma quebra de página e &l para uma quebra de linha.

Observe que o metacaráter && é igual a &. Por exemplo, se você precisar encontrar um texto para &p que não seja uma quebra de parágrafo, poderá usar &&p.

O exemplo de código a seguir mostra como substituir texto por parágrafo e quebra de página:

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

Localizar e substituir String no Cabeçalho / Rodapé de um documento

Pode localizar e substituir texto na secção cabeçalho/rodapé de um documento do Word utilizando a classe HeaderFooter.

O exemplo de código a seguir mostra como substituir o texto da seção de cabeçalho no documento:

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

Você pode notar a diferença entre o documento antes de aplicar a substituição da string de cabeçalho:

E depois de aplicar a substituição da string do cabeçalho:

O exemplo de código para substituir o texto da secção de rodapé no documento é muito semelhante ao exemplo de código de cabeçalho anterior. Tudo o que você precisa fazer é substituir as duas linhas a seguir:

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

Com o seguinte:

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

Você pode notar a diferença entre o documento antes de aplicar a substituição da string de rodapé:

E depois de aplicar a substituição da corda do rodapé:

Ignorar texto durante localizar e substituir

Ao aplicar a operação localizar e substituir, pode ignorar determinados segmentos do texto. Assim, certas partes do texto podem ser excluídas da pesquisa, e a localização e substituição podem ser aplicadas apenas às partes restantes.

Aspose.Words fornece muitas propriedades find E replace para ignorar texto, como IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, e IgnoreInserted.

O exemplo de código a seguir mostra como ignorar o texto dentro das revisões de exclusão:

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

Personalizar a operação localizar e substituir

Aspose.Words fornece muitos properties diferentes para localizar e substituir texto, como aplicar formato específico com propriedades ApplyFont e ApplyParagraphFormats, usando substituições em padrões de substituição com propriedade UseSubstitutions e outros.

O exemplo de código a seguir mostra como destacar uma palavra específica em seu documento:

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 permite que você use a interface IReplacingCallback para criar e chamar um método personalizado durante uma operação de substituição. Você pode ter alguns casos de uso em que precisa personalizar a operação localizar e substituir, como substituir o texto especificado por uma expressão regular com tags HTML, então basicamente você aplicará substituir por Inserir HTML.

Se você precisar substituir uma string por uma tag HTML, Aplique a interface IReplacingCallback para personalizar a operação localizar e substituir para que a correspondência comece no início de uma execução com o nó de correspondência do documento. Vamos fornecer vários exemplos de uso de IReplacingCallback.

O exemplo de código a seguir mostra como substituir o texto especificado por 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");
}

O exemplo de código a seguir mostra como destacar números positivos com cor verde e números negativos com cor vermelha:

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

O exemplo de código a seguir mostra Como preceder um número de linha para cada linha:

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