Temukan dan Ganti

Anda dapat dengan mudah menavigasi di dalam dokumen menggunakan keyboard dan mouse, tetapi jika Anda memiliki banyak halaman untuk digulir, akan memakan waktu cukup lama untuk menemukan teks tertentu dalam dokumen yang panjang. Akan lebih memakan waktu saat Anda ingin mengganti karakter atau kata tertentu yang telah Anda gunakan dalam dokumen Anda. Fungsionalitas “Temukan dan ganti” memungkinkan Anda menemukan urutan karakter dalam dokumen dan menggantinya dengan urutan karakter lainnya.

Aspose.Words memungkinkan Anda menemukan string atau pola ekspresi reguler tertentu dalam dokumen Anda dan menggantinya dengan alternatif tanpa menginstal dan menggunakan aplikasi tambahan seperti Microsoft Word. Ini akan mempercepat banyak tugas pengetikan dan pemformatan, yang berpotensi menghemat jam kerja Anda.

Artikel ini menjelaskan cara menerapkan penggantian string dan ekspresi reguler dengan dukungan metakarakter.

Cara Menemukan dan Mengganti

Aspose.Words menyediakan dua cara untuk menerapkan operasi temukan dan ganti dengan menggunakan yang berikut ini:

1. Simple string replacement - untuk menemukan dan mengganti string tertentu dengan string lain, Anda perlu menentukan string pencarian (karakter alfanumerik) yang akan diganti menurut semua kemunculan dengan string pengganti lain yang ditentukan. Kedua string tidak boleh berisi simbol. Perhatikan bahwa perbandingan string dapat peka huruf besar-kecil, atau Anda mungkin tidak yakin dengan ejaannya atau memiliki beberapa ejaan yang serupa.
2. Regular expressions - untuk menentukan ekspresi reguler untuk menemukan kecocokan string yang tepat dan menggantinya sesuai dengan ekspresi reguler Anda. Perhatikan bahwa sebuah kata didefinisikan hanya terdiri dari karakter alfanumerik. Jika penggantian dijalankan dengan hanya seluruh kata yang dicocokkan dan string input kebetulan berisi simbol, maka tidak ada frasa yang akan ditemukan.

Selain itu, Anda dapat menggunakan metakarakter khusus dengan penggantian string sederhana dan ekspresi reguler untuk menentukan jeda dalam operasi temukan dan ganti.

Aspose.Words menyajikan fungsionalitas temukan dan ganti dengan IReplacingCallBack. Anda dapat bekerja dengan banyak opsi selama proses temukan dan ganti menggunakan kelas FindReplaceOptions.

Temukan dan Ganti Teks Menggunakan Penggantian String Sederhana

Anda dapat menggunakan salah satu metode Replace untuk menemukan atau mengganti string tertentu dan mengembalikan jumlah penggantian yang dilakukan. Dalam hal ini, Anda dapat menentukan string yang akan diganti, string yang akan menggantikan semua kemunculannya, apakah penggantiannya peka huruf besar-kecil, dan apakah hanya kata-kata yang berdiri sendiri yang akan terpengaruh.

Contoh kode berikut menunjukkan cara menemukan string “CustomerName " dan menggantinya dengan string “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");

Anda dapat melihat perbedaan antara dokumen sebelum menerapkan penggantian string sederhana:

Dan setelah menerapkan penggantian string sederhana:

Temukan dan Ganti Teks Menggunakan Ekspresi Reguler

Ekspresi reguler (regex) adalah pola yang menggambarkan urutan teks tertentu. Misalkan Anda ingin mengganti semua kemunculan ganda sebuah kata dengan kemunculan satu kata. Kemudian Anda dapat menerapkan ekspresi reguler berikut untuk menentukan pola kata ganda: ([a-zA-Z]+) \1.

Gunakan metode Replace lainnya untuk mencari dan mengganti kombinasi karakter tertentu dengan menyetel parameter Regex sebagai pola ekspresi reguler untuk menemukan kecocokan.

Contoh kode berikut menunjukkan cara mengganti string yang cocok dengan pola ekspresi reguler dengan string pengganti yang ditentukan:

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

Anda dapat melihat perbedaan antara dokumen sebelum menerapkan penggantian string dengan ekspresi reguler:

Dan setelah menerapkan penggantian string dengan ekspresi reguler:

Temukan dan Ganti String Menggunakan Metakarakter

Anda dapat menggunakan metakarakter dalam string pencarian atau string pengganti jika teks atau frasa tertentu terdiri dari beberapa paragraf, bagian, atau halaman. Beberapa metakarakter termasuk &p untuk jeda paragraf, &b untuk jeda bagian, &m untuk jeda halaman, dan &l untuk jeda baris.

Perhatikan bahwa metakarakter && sama dengan &. Misalnya, jika Anda perlu mencari teks untuk &p yang bukan jeda paragraf, maka Anda dapat menggunakan &&p.

Contoh kode berikut menunjukkan cara mengganti teks dengan paragraf dan jeda halaman:

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

Temukan dan Ganti String di Header / Footer Dokumen

Anda dapat menemukan dan mengganti teks di bagian header / footer dokumen Word menggunakan kelas HeaderFooter.

Contoh kode berikut menunjukkan cara mengganti teks bagian header di dokumen Anda:

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

Anda dapat melihat perbedaan antara dokumen sebelum menerapkan penggantian string header:

Dan setelah menerapkan penggantian string header:

Contoh kode untuk mengganti teks bagian footer di dokumen Anda sangat mirip dengan contoh kode header sebelumnya. Yang perlu Anda lakukan hanyalah mengganti dua baris berikut:

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

Dengan yang berikut ini:

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

Anda dapat melihat perbedaan antara dokumen sebelum menerapkan penggantian string footer:

Dan setelah menerapkan penggantian string footer:

Abaikan Teks Saat Mencari dan Mengganti

Saat menerapkan operasi temukan dan ganti, Anda dapat mengabaikan segmen teks tertentu. Jadi, bagian teks tertentu dapat dikecualikan dari pencarian, dan find and replace hanya dapat diterapkan ke bagian yang tersisa.

Aspose.Words menyediakan banyak properti find dan replace untuk mengabaikan teks seperti IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, dan IgnoreInserted.

Contoh kode berikut menunjukkan cara mengabaikan teks di dalam revisi hapus:

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

Sesuaikan Operasi Temukan dan Ganti

Aspose.Words menyediakan banyak properties berbeda untuk menemukan dan mengganti teks seperti menerapkan format tertentu dengan properti ApplyFont dan ApplyParagraphFormats, menggunakan substitusi dalam pola penggantian dengan properti UseSubstitutions, dan lainnya.

Contoh kode berikut menunjukkan cara menyorot kata tertentu dalam dokumen Anda:

// 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 memungkinkan Anda menggunakan antarmuka IReplacingCallback untuk membuat dan memanggil metode khusus selama operasi penggantian. Anda mungkin memiliki beberapa kasus penggunaan di mana Anda perlu menyesuaikan operasi temukan dan ganti seperti mengganti teks yang ditentukan dengan ekspresi reguler dengan tag HTML, jadi pada dasarnya Anda akan menerapkan replace dengan menyisipkan HTML.

Jika Anda perlu mengganti string dengan tag HTML, terapkan antarmuka IReplacingCallback untuk menyesuaikan operasi temukan dan ganti sehingga pencocokan dimulai di awal proses dengan simpul pencocokan dokumen Anda. Mari kita berikan beberapa contoh penggunaan IReplacingCallback.

Contoh kode berikut menunjukkan cara mengganti teks yang ditentukan dengan 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;
       }
}

Contoh kode berikut menunjukkan cara menyorot bilangan positif dengan warna hijau dan bilangan negatif dengan warna merah:

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

Contoh kode berikut menunjukkan cara menambahkan nomor baris ke setiap baris:

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