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, è necessario 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. Prendi in considerazione che il confronto delle stringhe può essere case-sensitive o potresti non essere sicuro dell’ortografia o avere diverse ortografie simili.
  2. Regular expressions - per specificare un’espressione regolare per trovare le corrispondenze esatte della stringa e sostituirle in base all’espressione regolare. Si noti che una parola è definita come composta solo da caratteri alfanumerici. Se una sostituzione viene eseguita con solo parole intere che vengono abbinate 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 IReplacingCallBack. È possibile lavorare con 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-Java
// 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.getRange().replace("_CustomerName_", "James Bond", new FindReplaceOptions());
// Save the result.
doc.save(dataDir + "Range.ReplaceSimple.docx");

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

before-simple-string-replacement-aspose-words-java

E dopo aver applicato una semplice sostituzione delle corde:

after-simple-string-replacement-aspose-words-java

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-Java
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.writeln("sad mad bad");
if(doc.getText().trim() == "sad mad bad")
{
System.out.println("Strings are equal!");
}
// Replaces all occurrences of the words "sad" or "mad" to "bad".
FindReplaceOptions options = new FindReplaceOptions();
doc.getRange().replace(Pattern.compile("[s|m]ad"), "bad", options);
// Save the Word document.
doc.save(dataDir + "Range.ReplaceWithRegex.docx");

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

before-replacement-with-regular-expressions-aspose-words-java

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

after-replacement-with-regular-expressions-aspose-words-java

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.

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-Java
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.getFont().setName("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.getApplyParagraphFormat().setAlignment(ParagraphAlignment.CENTER);
// Double each paragraph break after word "section", add kind of underline and make it centered.
int count = doc.getRange().replace("section&p", "section&p----------------------&p", options);
// Insert section break instead of custom text tag.
count = doc.getRange().replace("{insert-section}", "&b", options);
doc.save(dataDir + "ReplaceTextContaingMetaCharacters_out.docx");

È 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-Java
// 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.getFirstSection().getHeadersFooters();
HeaderFooter header = headersFooters.get(HeaderFooterType.HEADER_PRIMARY);
// Set options.
FindReplaceOptions options = new FindReplaceOptions();
options.setMatchCase(false);
options.setFindWholeWordsOnly(false);
// Replace text in the header of the Word document.
header.getRange().replace("Aspose.Words", "Remove", options);
// Save the Word document.
doc.save(dataDir + "HeaderReplace.docx");

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

before-applying-header-string-replacement-aspose-words-java

E dopo aver applicato la sostituzione della stringa di intestazione:

after-applying-header-string-replacement-aspose-words-java

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:

HeaderFooter header = headersFooters.get(HeaderFooterType.HEADER_PRIMARY);
header.getRange().replace("Aspose.Words", "Remove", options);

Con il seguente:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
HeaderFooterCollection headersFooters = doc.getFirstSection().getHeadersFooters();
HeaderFooter footer = headersFooters.get(HeaderFooterType.FOOTER_PRIMARY);
// Replace text in the footer of the Word document.
int year = Calendar.getInstance().get(Calendar.YEAR);
footer.getRange().replace("(C) 2006 Aspose Pty Ltd.", "Copyright (C) " + year + " by Aspose Pty Ltd.", options);

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

before-applying-footer-string-replacement-aspose-words-java

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

after-applying-footer-string-replacement-aspose-words-java

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:

// Create new document.
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("author", new Date());
doc.getFirstSection().getBody().getFirstParagraph().remove();
doc.stopTrackRevisions();
Pattern regex = Pattern.compile("e", Pattern.CASE_INSENSITIVE);
FindReplaceOptions options = new FindReplaceOptions();
// Replace 'e' in document ignoring deleted text.
options.setIgnoreDeleted(true);
doc.getRange().replace(regex, "*", options);
System.out.println(doc.getText()); // The output is: Deleted\rT*xt\f
// Replace 'e' in document NOT ignoring deleted text.
options.setIgnoreDeleted(false);
doc.getRange().replace(regex, "*", options);
System.out.println(doc.getText()); // 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-Java
// Highlight word "the" with yellow color.
FindReplaceOptions options = new FindReplaceOptions();
options.getApplyFont().setHighlightColor(Color.YELLOW);
// Replace highlighted text.
doc.getRange().replace("the", "the", 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-Java
public static void ReplaceWithHtml() throws Exception {
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.writeln("Hello <CustomerName>,");
FindReplaceOptions options = new FindReplaceOptions();
options.setReplacingCallback(new ReplaceWithHtmlEvaluator());
doc.getRange().replace(Pattern.compile(" <CustomerName>,"), "", options);
//doc.getRange().replace(" <CustomerName>,", html, options);
// Save the modified document.
doc.save(dataDir + "Range.ReplaceWithInsertHtml.doc");
System.out.println("\nText replaced with meta characters successfully.\nFile saved at " + dataDir);
}
static class ReplaceWithHtmlEvaluator implements IReplacingCallback {
public int replacing(ReplacingArgs e) throws Exception {
// This is a Run node that contains either the beginning or the complete match.
Node currentNode = e.getMatchNode();
// create Document Buidler and insert MergeField
DocumentBuilder builder = new DocumentBuilder((Document) e.getMatchNode().getDocument());
builder.moveTo(currentNode);
// Replace '<CustomerName>' text with a red bold name.
builder.insertHtml("<b><font color='red'>James Bond, </font></b>");e.getReplacement();
currentNode.remove();
//Signal to the replace engine to do nothing because we have already done all what we wanted.
return ReplaceAction.SKIP;
}
}

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-Java
// Replace and Highlight Numbers.
static class NumberHighlightCallback implements IReplacingCallback {
public int replacing (ReplacingArgs args) throws Exception {
Node currentNode = args.getMatchNode();
// Let replacement to be the same text.
args.setReplacement(currentNode.getText());
int val = currentNode.hashCode();
// Apply either red or green color depending on the number value sign.
FindReplaceOptions options = new FindReplaceOptions();
if(val > 0)
{
options.getApplyFont().setColor(Color.GREEN);
}
else
{
options.getApplyFont().setColor(Color.RED);
}
return ReplaceAction.REPLACE;
}
}

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-Java
public static void TestLineCounter() throws Exception {
// 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();
opt.setReplacingCallback(new LineCounterCallback());
doc.getRange().replace(Pattern.compile("[^&p]*&p"), "", opt);
doc.save(dataDir + "TestLineCounter.docx");
}
static class LineCounterCallback implements IReplacingCallback
{
private int mCounter = 1;
public int replacing(ReplacingArgs args) throws Exception {
Node currentNode = args.getMatchNode();
System.out.println(currentNode.getText());
args.setReplacement(mCounter++ +"."+ currentNode.getText());
return ReplaceAction.REPLACE;
}
}