Znajdź i zastąp

Można łatwo poruszać się w obrębie dokumentu za pomocą klawiatury i myszy, ale jeśli masz wiele stron do przewinięcia, to zajmie sporo czasu, aby znaleźć określony tekst w długim dokumencie. Będzie to bardziej czasochłonne, gdy chcesz zastąpić niektóre znaki lub słowa, które zostały użyte w dokumencie. Funkcja “Znajdź i zastąp” pozwala znaleźć sekwencję znaków w dokumencie i zastąpić ją inną sekwencją znaków.

Aspose.Words pozwala na znalezienie określonego łańcucha lub wzoru wyrażeń regularnych w dokumencie i zastąpienie go alternatywą bez instalowania i przy użyciu dodatkowych aplikacji, takich jak: Microsoft Word. To przyspieszy wiele zadań maszynopisania i formatowania, potencjalnie oszczędzając godziny pracy.

Ten artykuł wyjaśnia, jak stosować wymianę strun i wyrażenia regularne przy wsparciu metacharacter.

Sposoby znalezienia i zastąpienia

Aspose.Words zapewnia dwa sposoby zastosowania wyszukiwania i wymiany operacji za pomocą:

1. • Proste zastępowanie strun * - aby znaleźć i zastąpić określony łańcuch innym, musisz określić łańcuch wyszukiwania (znaki alfanumeryczne), który zostanie zastąpiony zgodnie ze wszystkimi zdarzeniami innym określonym łańcuchem zastępczym. Oba łańcuchy nie mogą zawierać symboli. Należy wziąć pod uwagę, że porównanie strun może być wrażliwe na przypadek, lub można nie być pewnym pisowni lub mieć kilka podobnych pisowni.
2. • Wyrażenia regularne * - aby określić wyrażenie regularne, aby znaleźć dokładne dopasowanie łańcuchów i zastąpić je zgodnie z wyrażeniem regularnym. Należy zauważyć, że słowo jest zdefiniowane jako składające się wyłącznie z znaków alfanumerycznych. Jeśli zamiana jest wykonywana z dopasowanymi tylko całymi słowami i łańcuch wejściowy zawiera symbole, wtedy nie zostaną znalezione żadne zwroty.

Ponadto można użyć specjalnych metacharaktorów z prostym wymianą strun i wyrażeniami regularnymi, aby określić przerwy w operacji wyszukiwania i wymiany.

Aspose.Words prezentuje funkcje wyszukiwania i wymiany z IReplacingCallBack. Możesz pracować z wieloma opcjami podczas wyszukiwania i zastępowania procesu za pomocą FindReplaceOptions Klasa.

Znajdź i zastąp tekst za pomocą prostej wymiany strun

Można użyć jednego z Replace metody odnalezienia lub zastąpienia danego łańcucha i zwrócenia liczby dokonanych wymian. W tym przypadku możesz określić łańcuch, który ma być zastąpiony, łańcuch, który zastąpi wszystkie jego zdarzenia, czy zamiana jest wrażliwa na przypadek i czy tylko samodzielne słowa będą miały wpływ.

Poniższy przykład kodu pokazuje jak znaleźć łańcuch “_ CustomerName _” i zastąpić go łańcuchem * “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");

Możesz zauważyć różnicę między dokumentem przed zastosowaniem prostej wymiany łańcucha:

I po zastosowaniu prostej wymiany strun:

Znajdź i zastąp tekst używając wyrażeń regularnych

Wyrażenie regularne (regex) jest wzorem opisującym pewną sekwencję tekstu. Załóżmy, że chcesz zastąpić wszystkie podwójne wystąpienia słowa pojedynczym wyrazem. Następnie można zastosować następujące wyrażenie regularne, aby określić wzór duble- słowo: ([a-zA-Z]+) \1.

Użyj drugiego Replace metoda wyszukiwania i zastępowania poszczególnych kombinacji znaków przez ustawienie Regex parametr jako wzorzec wyrażenia regularnego do znalezienia dopasowania.

Poniższy przykład kodu pokazuje, jak zastąpić łańcuchy pasujące do wzoru wyrażenia regularnego określonym łańcuchem zastępczym:

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

Możesz zauważyć różnicę między dokumentem przed zastosowaniem wymiany łańcucha wyrażeń regularnych:

I po zastosowaniu wymiany strun z wyrażeniami regularnymi:

Znajdź i zastąp String używając Metacharacters

Możesz użyć metacharaktorów w łańcuchu wyszukiwania lub w łańcuchu zastępczym, jeśli dany tekst lub zdanie składa się z wielu akapitów, sekcji lub stron. Niektóre metacharaktory obejmują &p dla przerwy w wyciągu, &b na przerwę w sekcji, &m dla przerwy na stronie, oraz &l Na przerwę w kolejce.

Należy zauważyć, że metacharacter && równa się &. Na przykład, jeśli trzeba znaleźć tekst dla &p to nie jest przerwa na paragraf, wtedy można użyć &&p.

Poniższy przykład kodu pokazuje jak zastąpić tekst akapitem i przerwą na stronie:

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

Znajdź i zastąp String w nagłówku / Footer dokumentu

Można znaleźć i zastąpić tekst w sekcji nagłówka / stopki dokumentu Word za pomocą HeaderFooter Klasa.

Poniższy przykład kodu pokazuje jak zastąpić tekst sekcji nagłówka w dokumencie:

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

Możesz zauważyć różnicę między dokumentem przed zastosowaniem zmiany nagłówka:

I po zastosowaniu wymiany nagłówka:

Przykład kodu zastępujący tekst sekcji stopki w dokumencie jest bardzo podobny do poprzedniego przykładu kodu nagłówka. Wszystko, co musisz zrobić, to zastąpić następujące dwie linie:

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

Następujące elementy:

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

Można zauważyć różnicę między dokumentem przed zastosowaniem wymiany znaków stopki:

I po zastosowaniu wymiany strun stopki:

Ignoruj tekst podczas wyszukiwania i zamiany

Podczas stosowania operacji wyszukiwania i wymiany, można zignorować niektóre segmenty tekstu. Tak więc, niektóre części tekstu mogą być wyłączone z wyszukiwania, a znalezienie i wymiana mogą być stosowane tylko do pozostałych części.

Aspose.Words zapewnia wiele właściwości wyszukiwania i wymiany dla ignorowania tekstu, takich jak IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, oraz IgnoreInserted.

Poniższy przykład kodu pokazuje jak ignorować tekst wewnątrz usunąć poprawki:

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

Dostosuj operację Znajdź i zastąp

Aspose.Words zapewnia wiele różnych properties znaleźć i zastąpić tekst taki jak stosowanie określonego formatu ApplyFont oraz ApplyParagraphFormats właściwości, za pomocą substytucji w wzorach zamiennych z UseSubstitutions nieruchomości i innych.

Poniższy przykład kodu pokazuje, jak podkreślić konkretne słowo w dokumencie:

// 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 pozwala na użycie IReplacingCallback interfejs do tworzenia i wywoływania niestandardowych metod podczas operacji wymiany. Możesz mieć kilka przypadków użycia, gdzie trzeba dostosować wyszukiwania i wymiany operacji, takich jak zastąpienie tekstu określonego wyrażeniem regularnym z znacznikami HTML, więc w zasadzie będzie stosować zastępowanie z wstawiania HTML.

Jeśli trzeba zastąpić łańcuch znacznikiem HTML, należy zastosować IReplacingCallback interfejs, aby dostosować operację wyszukiwania i wymiany tak mecz zaczyna się na początku uruchomienia z węzłem dopasowania dokumentu. Podajmy kilka przykładów użycia IReplacingCallback.

Poniższy przykład kodu pokazuje jak zastąpić tekst określony w 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;
       }
}

Poniższy przykład kodu pokazuje, jak podkreślić liczby dodatnie z zielonym kolorem i liczby ujemne z czerwonym kolorem:

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

Poniższy przykład kodu pokazuje, jak prepremiować numer linii do każdej linii:

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