Trova e sostituisci

Puoi navigare facilmente all’interno del tuo documento usando una tastiera e un mouse, ma se hai molte pagine da scorrere, ci vorrà un po ' di tempo per trovare testo specifico in un documento lungo. Sarà più dispendioso in termini di tempo quando si desidera sostituire determinati caratteri o parole che sono stati utilizzati nel documento. La funzionalità “Trova e sostituisci” consente di trovare una sequenza di caratteri in un documento e sostituirla con un’altra sequenza di caratteri.

Aspose.Words consente di trovare una stringa specifica o un modello di espressione regolare nel documento e sostituirlo con un’alternativa senza installare e utilizzare applicazioni aggiuntive come Microsoft Word. Ciò velocizzerà molte attività di digitazione e formattazione, risparmiando potenzialmente ore di lavoro.

Questo articolo spiega come applicare la sostituzione delle stringhe e le espressioni regolari con il supporto dei metacaratteri.

Modi per trovare e sostituire

Aspose.Words fornisce due modi per applicare l’operazione Trova e sostituisci utilizzando quanto segue:

1. Simple string replacement – per trovare e sostituire una stringa specifica con un’altra, devi specificare una stringa di ricerca (caratteri alfanumerici) che verrà sostituita in base a tutte le occorrenze con un’altra stringa di sostituzione specificata. Entrambe le stringhe non devono contenere simboli. Tieni presente che il confronto delle stringhe può essere sensibile alle maiuscole e alle minuscole, oppure potresti non essere sicuro dell’ortografia o avere diverse ortografie simili.
2. Regular expressions – per specificare un’espressione regolare per trovare le corrispondenze esatte di stringa e sostituirle in base alla tua espressione regolare. Nota che una parola è definita come composta solo da caratteri alfanumerici. Se viene eseguita una sostituzione con solo parole intere che corrispondono e la stringa di input contiene simboli, non verrà trovata alcuna frase.

Inoltre, è possibile utilizzare metacaratteri speciali con semplice sostituzione di stringhe ed espressioni regolari per specificare le interruzioni all’interno dell’operazione Trova e sostituisci.

Aspose.Words presenta la funzionalità trova e sostituisci con lo spazio dei nomi Aspose.Words.Replacing. È possibile utilizzare molte opzioni durante il processo di ricerca e sostituzione utilizzando la classe FindReplaceOptions.

Trova e sostituisci il testo usando la sostituzione semplice delle stringhe

È possibile utilizzare uno dei metodi Replace per trovare o sostituire una stringa particolare e restituire il numero di sostituzioni effettuate. In questo caso, è possibile specificare una stringa da sostituire, una stringa che sostituirà tutte le sue occorrenze, se la sostituzione è case-sensitive e se saranno interessate solo le parole stand-alone.

Il seguente esempio di codice mostra come trovare la stringa “_ CustomerName _ " e sostituirla con la stringa *“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);

È possibile notare la differenza tra il documento prima di applicare la sostituzione semplice della stringa:

E dopo aver applicato una semplice sostituzione delle corde:

Trovare e sostituire il testo usando le espressioni regolari

Un’espressione regolare (regex) è un modello che descrive una determinata sequenza di testo. Supponiamo di voler sostituire tutte le occorrenze doppie di una parola con una singola occorrenza di parola. Quindi è possibile applicare la seguente espressione regolare per specificare il modello a doppia parola: ([a-zA-Z]+) \1.

Utilizzare l’altro metodo Replace per cercare e sostituire particolari combinazioni di caratteri impostando il parametro Regex come modello di espressione regolare per trovare corrispondenze.

L’esempio di codice seguente mostra come sostituire le stringhe che corrispondono a un modello di espressione regolare con una stringa di sostituzione specificata:

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

È possibile notare la differenza tra il documento prima di applicare la sostituzione delle stringhe con le espressioni regolari:

E dopo aver applicato la sostituzione delle stringhe con espressioni regolari:

Trova e sostituisci stringa usando metacaratteri

È possibile utilizzare i metacaratteri nella stringa di ricerca o nella stringa di sostituzione se un determinato testo o frase è composto da più paragrafi, sezioni o pagine. Alcuni metacaratteri includono &p per un’interruzione di paragrafo, &b per un’interruzione di sezione, &m per un’interruzione di pagina e &l per un’interruzione di riga.

Si noti che il metacarattero && è uguale a**&**. Ad esempio, se è necessario trovare il testo per **&p** che non è un’interruzione di paragrafo, è possibile utilizzare **&&p**.

Il seguente esempio di codice mostra come sostituire il testo con paragrafo e interruzione di pagina:

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

Trovare e sostituire la stringa nell’intestazione / piè di pagina di un documento

È possibile trovare e sostituire il testo nella sezione intestazione/piè di pagina di un documento Word utilizzando la classe HeaderFooter.

Il seguente esempio di codice mostra come sostituire il testo della sezione di intestazione nel 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");

È possibile notare la differenza tra il documento prima di applicare la sostituzione della stringa di intestazione:

E dopo aver applicato la sostituzione della stringa di intestazione:

L’esempio di codice per sostituire il testo della sezione piè di pagina nel documento è molto simile al precedente esempio di codice di intestazione. Tutto quello che devi fare è sostituire le seguenti due righe:

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

Con il seguente:

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

È possibile notare la differenza tra il documento prima di applicare la sostituzione della stringa del piè di pagina:

E dopo aver applicato la sostituzione della stringa del piè di pagina:

Ignora il testo durante Trova e sostituisci

Durante l’applicazione dell’operazione Trova e sostituisci, è possibile ignorare determinati segmenti del testo. Quindi, alcune parti del testo possono essere escluse dalla ricerca e la ricerca e la sostituzione possono essere applicate solo alle parti rimanenti.

Aspose.Words fornisce molte proprietà trova e sostituisci per ignorare il testo come IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, e IgnoreInserted.

L’esempio di codice seguente mostra come ignorare il testo all’interno di Elimina revisioni:

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

Personalizza l’operazione Trova e sostituisci

Aspose.Words fornisce molti properties diversi per trovare e sostituire il testo, ad esempio l’applicazione di un formato specifico con proprietà ApplyFont e ApplyParagraphFormats, l’utilizzo di sostituzioni nei modelli di sostituzione con proprietà UseSubstitutions e altri.

L’esempio di codice seguente mostra come evidenziare una parola specifica nel 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 consente di utilizzare l’interfaccia IReplacingCallback per creare e chiamare un metodo personalizzato durante un’operazione di sostituzione. Potresti avere alcuni casi d’uso in cui è necessario personalizzare l’operazione trova e sostituisci come la sostituzione del testo specificato con un’espressione regolare con tag HTML, quindi in pratica applicherai replace con l’inserimento di HTML.

Se è necessario sostituire una stringa con un tag HTML, applicare l’interfaccia IReplacingCallback per personalizzare l’operazione trova e sostituisci in modo che la corrispondenza inizi all’inizio di un’esecuzione con il nodo di corrispondenza del documento. Forniamo alcuni esempi di utilizzo di IReplacingCallback.

Il seguente esempio di codice mostra come sostituire il testo specificato con 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");
}

Il seguente esempio di codice mostra come evidenziare numeri positivi con colore verde e numeri negativi con colore rosso:

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

Il seguente esempio di codice mostra come anteporre un numero di riga a ciascuna riga:

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