Zoeken en vervangen

U kunt gemakkelijk navigeren in uw document met behulp van een toetsenbord en muis, maar als u veel pagina’s om door te schuiven, zal het vrij lang duren om specifieke tekst te vinden in een lang document. Het zal tijdrovender zijn wanneer u bepaalde tekens of woorden wilt vervangen die u in uw document hebt gebruikt. Met de functionaliteit van de zoek- en vervangfunctie kunt u een reeks tekens in een document vinden en vervangen door een andere reeks tekens.

Aspose.Words kunt u een specifieke string of reguliere expressie patroon in uw document te vinden en te vervangen door een alternatief zonder het installeren en het gebruik van extra toepassingen zoals Microsoft Word. Dit zal veel typen en formatteren taken versnellen, mogelijk bespaart u uren werk.

Dit artikel legt uit hoe tekenreeksvervanging en reguliere expressies toe te passen met behulp van metakarakters.

Manieren om te vinden en te vervangen

Aspose.Words biedt twee manieren om de vondst toe te passen en te vervangen door gebruik te maken van:

1. Eenvoudige tekenreeksvervanging Beide snaren mogen geen symbolen bevatten. Houd er rekening mee dat snaarvergelijking hoofdlettergevoelig kan zijn, of dat je niet zeker bent van spelling of meerdere soortgelijke spellingen hebt.
2. Regular expressions Merk op dat een woord wordt gedefinieerd als bestaande uit alleen alfanumerieke tekens. Als een vervanging wordt uitgevoerd met alleen hele woorden die worden aangepast en de invoer string toevallig symbolen bevatten, dan zullen geen zinnen worden gevonden.

Ook kunt u speciale metakarakters gebruiken met eenvoudige tekenreeksvervanging en reguliere expressies om breuken binnen de zoek- en vervangoperatie te specificeren.

Aspose.Words presenteert de zoek en vervangen functionaliteit door de IReplacingCallBack. U kunt werken met vele opties tijdens het vinden en vervangen proces met behulp van FindReplaceOptions Klasse.

Tekst zoeken en vervangen met behulp van eenvoudige tekenreeksvervanging

U kunt een van de Replace methoden om een bepaalde string te vinden of te vervangen en het aantal vervangingen dat is gemaakt terug te geven. In dit geval kunt u een tekenreeks opgeven die vervangen moet worden, een tekenreeks die alle gebeurtenissen vervangt, of de vervanging hoofdlettergevoelig is, en of alleen stand-alone woorden beïnvloed zullen worden.

Het volgende voorbeeld van de code laat zien hoe je de string kunt vinden en vervangen door de string *

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

U kunt het verschil tussen het document opmerken voordat u eenvoudige tekenreeksvervanging toepast:

En na het toepassen van eenvoudige string vervanger:

Tekst zoeken en vervangen met reguliere expressies

Een reguliere expressie (regex) is een patroon dat een bepaalde volgorde van tekst beschrijft. Stel dat je alle dubbele gebeurtenissen van een woord wilt vervangen door één woord. Dan kunt u de volgende reguliere expressie toepassen om het dubbele-woord patroon op te geven: ([a-zA-Z]+) \1.

Gebruik de andere Replace methode om bepaalde tekenscombinaties te zoeken en te vervangen door de Regex parameter als het reguliere expressiepatroon om overeenkomsten te vinden.

Het volgende codevoorbeeld laat zien hoe tekenreeksen die overeenkomen met een reguliere expressiepatroon te vervangen door een gespecificeerde vervangende tekenreeks:

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

U kunt het verschil tussen het document merken voordat u tekenreeksvervanging toepast met reguliere expressies:

En na het toepassen van tekenreeksvervanging door reguliere expressies:

Tekenreeks zoeken en vervangen met metakarakters

U kunt metatekens in de zoekreeks of de vervangende tekenreeks gebruiken als een bepaalde tekst of zin bestaat uit meerdere paragrafen, secties of pagina’s. Enkele van de metakenmerken zijn &p voor een paragraafpauze, &b voor een sectiebreuk, &m voor een paginapauze, en &l voor een lijnbreuk.

Merk op dat het metakarakter && gelijk aan &. Bijvoorbeeld, als u de tekst voor &p Dat is geen paragraaf pauze, dan kunt u gebruiken &&p.

Het volgende voorbeeld van code laat zien hoe tekst vervangen kan worden door paragraaf en pagina-breuk:

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

String zoeken en vervangen in header/footer van een document

U kunt tekst vinden en vervangen in de header/voeter sectie van een Word-document met behulp van de HeaderFooter Klasse.

Het volgende voorbeeld van code laat zien hoe u de tekst van de koptekst in uw document kunt vervangen:

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

U kunt het verschil zien tussen het document voordat u header string vervanger:

En na het aanbrengen van header string vervanger:

Het codevoorbeeld om de tekst van de footer sectie in uw document te vervangen is zeer vergelijkbaar met het vorige header code voorbeeld. Je hoeft alleen de volgende twee regels te vervangen:

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

Met de volgende kenmerken:

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

U kunt het verschil tussen het document merken voordat u de tekst van de voettekst vervangt:

En na het aanbrengen van footer string vervanging:

Tekst negeren tijdens zoeken en vervangen

Bij het toepassen van de zoek- en vervangoperatie kunt u bepaalde segmenten van de tekst negeren. Dus, bepaalde delen van de tekst kunnen worden uitgesloten van de zoekopdracht, en de vondst en vervanging kan alleen worden toegepast op de resterende delen.

Aspose.Words biedt veel zoek-en vervangen eigenschappen voor het negeren van tekst zoals IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, en IgnoreInserted.

Het volgende voorbeeld van code laat zien hoe je tekst in de delete revisies negeert:

// 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

Operatie zoeken en vervangen aanpassen

Aspose.Words biedt veel verschillende properties tekst te vinden en te vervangen, zoals het toepassen van een specifiek formaat door ApplyFont en ApplyParagraphFormats eigenschappen, gebruik van substituties in vervangende patronen met UseSubstitutions eigendom, en anderen.

Het volgende voorbeeld van code laat zien hoe u een specifiek woord in uw document markeert:

// 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 kunt u de IReplacingCallback interface om een aangepaste methode aan te maken en aan te roepen tijdens een vervangende bewerking. U kunt enkele use cases hebben waarin u de zoekopdracht moet aanpassen en de bewerking moet vervangen, zoals het vervangen van tekst door een reguliere expressie door HTML-tags, dus in principe zult u vervangen door het invoegen van HTML.

Als je een tekenreeks moet vervangen door een HTML-tag, moet je de IReplacingCallback interface om de zoek- en vervangoperatie aan te passen zodat de wedstrijd begint bij het begin van een run met de match-node van uw document. Laten we verschillende voorbeelden geven van het gebruik van IReplacingCallback.

Het volgende voorbeeld van code laat zien hoe je de tekst die is opgegeven met HTML kunt vervangen:

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

Het volgende voorbeeld van code laat zien hoe positieve getallen met groene kleur en negatieve getallen met rode kleur te markeren:

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

Het volgende voorbeeld van code laat zien hoe je een regelnummer aan elke regel voorschrijft:

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