Suchen und Ersetzen
Sie können einfach mit Tastatur und Maus in Ihrem Dokument navigieren, aber wenn Sie viele Seiten zum Scrollen haben, dauert es eine Weile, bis Sie bestimmten Text in einem langen Dokument finden. Es wird zeitaufwändiger, wenn Sie bestimmte Zeichen oder Wörter ersetzen möchten, die Sie in Ihrem Dokument verwendet haben. Die Funktion “Suchen und Ersetzen” ermöglicht es Ihnen, eine Zeichenfolge in einem Dokument zu finden und durch eine andere Zeichenfolge zu ersetzen.
Aspose.Words ermöglicht es Ihnen, eine bestimmte Zeichenfolge oder ein Muster für reguläre Ausdrücke in Ihrem Dokument zu finden und durch eine Alternative zu ersetzen, ohne zusätzliche Anwendungen wie Microsoft Word zu installieren und zu verwenden. Dies beschleunigt viele Tipp- und Formatierungsaufgaben und spart Ihnen möglicherweise Stunden Arbeit.
In diesem Artikel wird erläutert, wie Sie Zeichenfolgenersetzung und reguläre Ausdrücke mit Unterstützung von Metazeichen anwenden.
Möglichkeiten zum Suchen und Ersetzen von
Aspose.Words bietet zwei Möglichkeiten, die Operation Suchen und Ersetzen anzuwenden, indem Sie Folgendes verwenden:
- Simple string replacement - Um eine bestimmte Zeichenfolge zu finden und durch eine andere zu ersetzen, müssen Sie eine Suchzeichenfolge (alphanumerische Zeichen) angeben, die bei allen Vorkommen durch eine andere angegebene Ersatzzeichenfolge ersetzt wird. Beide Zeichenfolgen dürfen keine Symbole enthalten. Berücksichtigen Sie, dass beim Zeichenfolgenvergleich zwischen Groß- und Kleinschreibung unterschieden werden kann oder dass Sie sich bei der Rechtschreibung nicht sicher sind oder mehrere ähnliche Schreibweisen haben.
- Regular expressions - um einen regulären Ausdruck anzugeben, um die genauen Übereinstimmungen der Zeichenfolge zu finden und sie gemäß Ihrem regulären Ausdruck zu ersetzen. Beachten Sie, dass ein Wort so definiert ist, dass es nur aus alphanumerischen Zeichen besteht. Wenn eine Ersetzung ausgeführt wird, bei der nur ganze Wörter übereinstimmen und die Eingabezeichenfolge zufällig Symbole enthält, werden keine Phrasen gefunden.
Sie können auch spezielle Metazeichen mit einfacher Zeichenfolgenersetzung und regulären Ausdrücken verwenden, um Unterbrechungen innerhalb der Such- und Ersetzungsoperation anzugeben.
Aspose.Words zeigt die Funktion zum Suchen und Ersetzen mit IReplacingCallBack an. Sie können während des Such- und Ersetzungsprozesses mit der Klasse FindReplaceOptions mit vielen Optionen arbeiten.
Suchen und Ersetzen von Text mit der einfachen Zeichenfolgenersetzung
Sie können eine der Replace -Methoden verwenden, um eine bestimmte Zeichenfolge zu suchen oder zu ersetzen und die Anzahl der vorgenommenen Ersetzungen zurückzugeben. In diesem Fall können Sie eine zu ersetzende Zeichenfolge angeben, eine Zeichenfolge, die alle Vorkommen ersetzt, ob bei der Ersetzung zwischen Groß- und Kleinschreibung unterschieden wird und ob nur eigenständige Wörter betroffen sind.
Das folgende Codebeispiel zeigt, wie Sie die Zeichenfolge “CustomerName” finden und durch die Zeichenfolge “James Bond” ersetzen:
// 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"); |
Sie können den Unterschied zwischen dem Dokument feststellen, bevor Sie eine einfache Zeichenfolgenersetzung anwenden:
Und nach dem Anwenden eines einfachen String-Ersetzens:
Suchen und Ersetzen von Text mit regulären Ausdrücken
Ein regulärer Ausdruck (Regex) ist ein Muster, das eine bestimmte Textfolge beschreibt. Angenommen, Sie möchten alle doppelten Vorkommen eines Wortes durch ein einzelnes Vorkommen ersetzen. Dann können Sie den folgenden regulären Ausdruck anwenden, um das Doppelwortmuster anzugeben: ([a-zA-Z]+) \1
.
Verwenden Sie die andere Replace-Methode, um bestimmte Zeichenkombinationen zu suchen und zu ersetzen, indem Sie den Parameter Regex
als Muster für reguläre Ausdrücke festlegen, um Übereinstimmungen zu finden.
Das folgende Codebeispiel zeigt, wie Zeichenfolgen, die einem regulären Ausdrucksmuster entsprechen, durch eine angegebene Ersetzungszeichenfolge ersetzt werden:
// 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"); |
Sie können den Unterschied zwischen dem Dokument feststellen, bevor Sie die Zeichenfolgenersetzung durch reguläre Ausdrücke anwenden:
Und nach dem Anwenden der Zeichenfolgenersetzung durch reguläre Ausdrücke:
Suchen und Ersetzen von Zeichenfolgen mit Metazeichen
Sie können Metazeichen in der Suchzeichenfolge oder der Ersetzungszeichenfolge verwenden, wenn ein bestimmter Text oder Ausdruck aus mehreren Absätzen, Abschnitten oder Seiten besteht. Einige der Metazeichen enthalten &p für einen Absatzumbruch, &b für einen Abschnittsumbruch, &m für einen Seitenumbruch und &l für einen Zeilenumbruch.
Das folgende Codebeispiel zeigt, wie Text durch Absatz- und Seitenumbrüche ersetzt wird:
// 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"); |
Zeichenfolge in Kopf- / Fußzeile eines Dokuments suchen und ersetzen
Sie können Text im Kopf- / Fußzeilenbereich eines Word-Dokuments mit der Klasse HeaderFooter suchen und ersetzen.
Das folgende Codebeispiel zeigt, wie Sie den Text des Kopfzeilenabschnitts in Ihrem Dokument ersetzen:
// 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"); |
Sie können den Unterschied zwischen dem Dokument feststellen, bevor Sie die Ersetzung der Kopfzeilenzeichenfolge anwenden:
Und nach dem Anwenden des Ersetzens der Header-Zeichenfolge:
Das Codebeispiel zum Ersetzen des Textes des Fußzeilenabschnitts in Ihrem Dokument ist dem vorherigen Codebeispiel für die Kopfzeile sehr ähnlich. Alles was Sie tun müssen, ist die folgenden zwei Zeilen zu ersetzen:
HeaderFooter header = headersFooters.get(HeaderFooterType.HEADER_PRIMARY);
header.getRange().replace("Aspose.Words", "Remove", options);
Mit den folgenden:
Sie können den Unterschied zwischen dem Dokument feststellen, bevor Sie das Ersetzen der Fußzeilenzeichenfolge anwenden:
Und nach dem Anwenden des Ersetzens der Fußzeilenzeichenfolge:
Text beim Suchen und Ersetzen ignorieren
Beim Anwenden der Operation Suchen und Ersetzen können Sie bestimmte Textsegmente ignorieren. So können bestimmte Teile des Textes von der Suche ausgeschlossen werden, und das Suchen und Ersetzen kann nur auf die verbleibenden Teile angewendet werden.
Aspose.Words bietet viele Such- und Ersetzungseigenschaften zum Ignorieren von Text, z. B.: IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, und IgnoreInserted.
Das folgende Codebeispiel zeigt, wie Text in Löschrevisionen ignoriert wird:
// 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 |
Anpassen der Such- und Ersetzungsoperation
Aspose.Words bietet viele verschiedene properties zum Suchen und Ersetzen von Text, z. B. das Anwenden eines bestimmten Formats mit ApplyFont - und ApplyParagraphFormats -Eigenschaften, das Verwenden von Ersetzungen in Ersetzungsmustern mit UseSubstitutions -Eigenschaften und andere.
Das folgende Codebeispiel zeigt, wie Sie ein bestimmtes Wort in Ihrem Dokument hervorheben:
// 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 ermöglicht die Verwendung der IReplacingCallback-Schnittstelle zum Erstellen und Aufrufen einer benutzerdefinierten Methode während einer Ersetzungsoperation. Möglicherweise haben Sie einige Anwendungsfälle, in denen Sie die Such- und Ersetzungsoperation anpassen müssen, z. B. das Ersetzen von Text, der durch einen regulären Ausdruck mit HTML -Tags angegeben wurde. Im Grunde werden Sie replace durch Einfügen von HTML anwenden.
Wenn Sie eine Zeichenfolge durch ein HTML-Tag ersetzen müssen, wenden Sie die IReplacingCallback-Schnittstelle an, um die Such- und Ersetzungsoperation so anzupassen, dass die Übereinstimmung zu Beginn eines Laufs mit dem Übereinstimmungsknoten Ihres Dokuments beginnt. Lassen Sie uns einige Beispiele für die Verwendung von IReplacingCallback geben.
Das folgende Codebeispiel zeigt, wie der durch HTML angegebene Text ersetzt wird:
// 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; | |
} | |
} |
Das folgende Codebeispiel zeigt, wie positive Zahlen mit grüner Farbe und negative Zahlen mit roter Farbe hervorgehoben werden:
// 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; | |
} | |
} |
Das folgende Codebeispiel zeigt, wie jeder Zeile eine Zeilennummer vorangestellt wird:
// 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; | |
} | |
} |