Trova e sostituisci
Puoi navigare facilmente all’interno del documento utilizzando tastiera e mouse, ma se hai molte pagine da scorrere, ci vorrà un po' di tempo per trovare il testo specifico in un documento lungo. Richiederà più tempo quando desideri sostituire determinati caratteri o parole che hai utilizzato nel tuo documento. La funzionalità “Trova e sostituisci” ti consente di trovare una sequenza di caratteri in un documento e sostituirla con un’altra sequenza di caratteri.
Aspose.Words ti consente di trovare una stringa specifica o un modello di espressione regolare nel tuo documento e sostituirlo con un’alternativa senza installare e utilizzare applicazioni aggiuntive come Microsoft Word. Ciò accelererà 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 di ricerca e sostituzione utilizzando quanto segue:
- Sostituzione stringa semplice – 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. Tieni presente che il confronto tra stringhe può fare distinzione tra maiuscole e minuscole, oppure potresti non essere sicuro dell’ortografia o avere diverse ortografie simili.
- Espressioni regolari – per specificare un’espressione regolare per trovare le corrispondenze esatte della stringa e sostituirle in base all’espressione regolare. Tieni presente che una parola è definita come composta solo da caratteri alfanumerici. Se la sostituzione viene eseguita con la corrispondenza solo di parole intere e la stringa di input contiene simboli, non verrà trovata alcuna frase.
Inoltre, puoi utilizzare metacaratteri speciali con semplici sostituzioni di stringhe ed espressioni regolari per specificare interruzioni all’interno dell’operazione di ricerca e sostituzione.
Aspose.Words presenta la funzionalità di ricerca e sostituzione con lo spazio dei nomi Aspose.Words.Replacing. Puoi lavorare con molte opzioni durante il processo di ricerca e sostituzione utilizzando la classe FindReplaceOptions.
Trova e sostituisci testo utilizzando la semplice sostituzione di 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 fa distinzione tra maiuscole e minuscole e se verranno influenzate solo le parole autonome.
L’esempio di codice seguente 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-.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"); |
Puoi notare la differenza tra il documento prima di applicare la semplice sostituzione della stringa:
![prima della semplice sostituzione della stringa](/words/net/find-and-replace/before-simple-string-replacement.png)
E dopo aver applicato la semplice sostituzione della stringa:
![dopo la semplice sostituzione della stringa](/words/net/find-and-replace/after-simple-string-replacement.png)
Trova e sostituisci testo utilizzando le espressioni regolari
Un’espressione regolare (regex) è un modello che descrive una determinata sequenza di testo. Supponiamo di voler sostituire tutte le doppie occorrenze di una parola con un’occorrenza di parola singola. Quindi puoi applicare la seguente espressione regolare per specificare il modello a doppia parola: ([a-zA-Z]+) \1
.
Utilizza 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-.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"); |
Puoi notare la differenza tra il documento prima di applicare la sostituzione della stringa con le espressioni regolari:
![prima della sostituzione con espressioni regolari](/words/net/find-and-replace/before-replacement-with-regular-expressions.png)
E dopo aver applicato la sostituzione delle stringhe con le espressioni regolari:
![dopo la sostituzione con espressioni regolari](/words/net/find-and-replace/after-replacement-with-regular-expressions.png)
Trova e sostituisci la stringa utilizzando i metacaratteri
È possibile utilizzare i metacaratteri nella stringa di ricerca o nella stringa di sostituzione se un particolare 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.
L’esempio di codice seguente mostra come sostituire il testo con paragrafi e interruzioni di pagina:
// 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); |
Trova e sostituisci la stringa nell’intestazione/piè di pagina di un documento
Puoi 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:
Puoi notare la differenza tra il documento prima di applicare la sostituzione della stringa di intestazione:
![prima di applicare la sostituzione della stringa di intestazione](/words/net/find-and-replace/before-applying-header-string-replacement.png)
E dopo aver applicato la sostituzione della stringa di intestazione:
![dopo l'applicazione della sostituzione della stringa di intestazione](/words/net/find-and-replace/after-applying-header-string-replacement.png)
L’esempio di codice per sostituire il testo della sezione piè di pagina nel documento è molto simile all’esempio di codice di intestazione precedente. Tutto quello che devi fare è sostituire le seguenti due righe:
HeaderFooter header = headersFooters[HeaderFooterType.HeaderPrimary];
header.Range.Replace("Aspose.Words", "Remove", options);
Con quanto segue:
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);
Puoi notare la differenza tra il documento prima di applicare la sostituzione della stringa del piè di pagina:
![prima di applicare la sostituzione della stringa del piè di pagina](/words/net/find-and-replace/before-applying-footer-string-replacement.png)
E dopo aver applicato la sostituzione della stringa del piè di pagina:
![dopo l'applicazione della sostituzione della stringa del piè di pagina](/words/net/find-and-replace/after-applying-footer-string-replacement.png)
Ignora testo durante Trova e sostituisci
Durante l’applicazione dell’operazione di ricerca e sostituzione, puoi ignorare alcuni segmenti del testo. Pertanto, alcune parti del testo possono essere escluse dalla ricerca e la ricerca e sostituzione può essere applicata solo alle parti rimanenti.
Aspose.Words fornisce molte proprietà di ricerca e sostituzione per ignorare testo come IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes e IgnoreInserted.
L’esempio di codice seguente mostra come ignorare il testo all’interno delle revisioni di eliminazione:
// 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); |
Personalizza l’operazione Trova e sostituisci
Aspose.Words fornisce molti properties diversi per trovare e sostituire testo, ad esempio applicando un formato specifico con proprietà ApplyFont e ApplyParagraphFormats, utilizzando sostituzioni in modelli di sostituzione con proprietà UseSubstitutions e altro.
Il seguente esempio di codice 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-.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 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 di ricerca e sostituzione, ad esempio sostituire il testo specificato con un’espressione regolare con tag HTML, quindi in pratica applicherai la sostituzione inserendo HTML.
Se devi sostituire una stringa con un tag HTML, applica l’interfaccia IReplacingCallback per personalizzare l’operazione di ricerca e sostituzione in modo che la corrispondenza inizi all’inizio di un’esecuzione con il nodo di corrispondenza del documento. Forniamo diversi esempi di utilizzo di IReplacingCallback.
L’esempio di codice seguente 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-.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; | |
} |
Il seguente esempio di codice mostra come evidenziare i numeri positivi con il colore verde e i numeri negativi con il colore rosso:
// 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; | |
} |
L’esempio di codice seguente 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-.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; | |
} |