Localizar e substituir

Você pode navegar facilmente em seu documento usando um teclado e mouse, mas se tiver muitas páginas para percorrer, levará um bom tempo para encontrar um texto específico em um documento longo. Será mais demorado quando pretender substituir determinados caracteres ou palavras que utilizou no seu documento. A funcionalidade “Localizar e substituir” permite localizar uma sequência de caracteres num documento e substituí-la por outra sequência de caracteres.

Aspose.Words permite que você encontre uma string específica ou padrão de expressão regular em seu documento e substitua-o por uma alternativa sem instalar e usar aplicativos adicionais, como Microsoft Word. Isso acelerará muitas tarefas de digitação e formatação, potencialmente economizando horas de trabalho.

Este artigo explica como aplicar a substituição de strings e expressões regulares com o Suporte de metacaracteres.

Formas de encontrar e substituir

Aspose.Words fornece duas maneiras de aplicar a operação localizar e substituir usando o seguinte:

1. Simple string replacement - para encontrar e substituir uma string específica por outra, é necessário especificar uma string de pesquisa (caracteres alfanuméricos) que será substituída de acordo com todas as ocorrências por outra string de substituição especificada. Ambas as cadeias não devem conter símbolos. Leve em consideração que a comparação de strings pode diferenciar maiúsculas de minúsculas, ou você pode não ter certeza da ortografia ou ter várias grafias semelhantes.
2. Regular expressions - para especificar uma expressão regular para encontrar as correspondências exatas da string e substituí-las de acordo com sua expressão regular. Observe que uma palavra é definida como sendo composta apenas por caracteres alfanuméricos. Se uma substituição for executada com apenas palavras inteiras sendo correspondidas e a string de entrada contiver símbolos, nenhuma frase será encontrada.

Além disso, você pode usar metacaracteres especiais com substituição de string simples e expressões regulares para especificar quebras na operação localizar e substituir.

Aspose.Words apresenta a funcionalidade localizar e substituir com o IReplacingCallBack. Você pode trabalhar com muitas opções durante o processo localizar e substituir usando a classe FindReplaceOptions.

Localizar e substituir texto usando substituição de String simples

Você pode usar um dos métodos Replace para localizar ou substituir uma string específica e retornar o número de substituições que foram feitas. Nesse caso, você pode especificar uma string a ser substituída, uma string que substituirá todas as suas ocorrências, se a substituição diferencia maiúsculas de minúsculas e se apenas palavras independentes serão afetadas.

O exemplo de código a seguir mostra como encontrar a string" CustomerName " e substituí-la pela 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");

Você pode notar a diferença entre o documento antes de aplicar a substituição simples da string:

E depois de aplicar a substituição simples da corda:

Localizar e substituir texto usando expressões regulares

Uma expressão regular (regex) é um padrão que descreve uma determinada sequência de texto. Suponha que você queira substituir todas as ocorrências duplas de uma palavra por uma ocorrência de uma única palavra. Em seguida, você pode aplicar a seguinte expressão regular para especificar o padrão de palavra dupla: ([a-zA-Z]+) \1.

Use o outro método Replace para pesquisar e substituir combinações de caracteres específicas definindo o parâmetro Regex como o padrão de expressão regular para encontrar correspondências.

O exemplo de código a seguir mostra como substituir strings que correspondem a um padrão de expressão regular por uma string de substituição especificada:

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

Você pode notar a diferença entre o documento antes de aplicar a substituição de string por expressões regulares:

E depois de aplicar a substituição de string com expressões regulares:

Localizar e substituir String usando metacaracteres

Você pode usar metacaracteres na string de pesquisa ou na string de substituição se um determinado texto ou frase for composto por vários parágrafos, seções ou páginas. Alguns dos metacaracteres incluem &p para uma quebra de parágrafo, &b para uma quebra de Seção, &m para uma quebra de página e &l para uma quebra de linha.

Observe que o metacaráter && é igual a &. Por exemplo, se você precisar encontrar o texto para &p que não é uma quebra de parágrafo, poderá usar &&p.

O exemplo de código a seguir mostra como substituir texto por parágrafo e quebra de página:

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

Localizar e substituir String no Cabeçalho / Rodapé de um documento

Pode localizar e substituir texto na secção cabeçalho/rodapé de um documento do Word utilizando a classe HeaderFooter.

O exemplo de código a seguir mostra como substituir o texto da seção de cabeçalho no documento:

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

Você pode notar a diferença entre o documento antes de aplicar a substituição da string de cabeçalho:

E depois de aplicar a substituição da string do cabeçalho:

O exemplo de código para substituir o texto da secção de rodapé no documento é muito semelhante ao exemplo de código de cabeçalho anterior. Tudo o que você precisa fazer é substituir as duas linhas a seguir:

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

Com o seguinte:

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

Você pode notar a diferença entre o documento antes de aplicar a substituição da string de rodapé:

E depois de aplicar a substituição da corda do rodapé:

Ignorar texto durante localizar e substituir

Ao aplicar a operação localizar e substituir, pode ignorar determinados segmentos do texto. Assim, certas partes do texto podem ser excluídas da pesquisa, e a localização e substituição podem ser aplicadas apenas às partes restantes.

Aspose.Words fornece muitas propriedades find E replace para ignorar texto, como IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, e IgnoreInserted.

O exemplo de código a seguir mostra como ignorar o texto dentro das revisões de exclusão:

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

Personalizar a operação localizar e substituir

Aspose.Words fornece muitos properties diferentes para localizar e substituir texto, como aplicar formato específico com propriedades ApplyFont e ApplyParagraphFormats, usando substituições em padrões de substituição com propriedade UseSubstitutions e outros.

O exemplo de código a seguir mostra como destacar uma palavra específica em seu documento:

// 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 permite utilizar a interface IReplacingCallback para criar e chamar um método personalizado durante uma operação de substituição. Você pode ter alguns casos de uso em que precisa personalizar a operação localizar e substituir, como substituir o texto especificado por uma expressão regular com tags HTML, então basicamente você aplicará substituir por Inserir HTML.

Se você precisar substituir uma string por uma tag HTML, Aplique a interface IReplacingCallback para personalizar a operação localizar e substituir para que a correspondência comece no início de uma execução com o nó de correspondência do documento. Vamos fornecer vários exemplos de uso de IReplacingCallback.

O exemplo de código a seguir mostra como substituir o texto especificado por 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;
       }
}

O exemplo de código a seguir mostra como destacar números positivos com cor verde e números negativos com cor vermelha:

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

O exemplo de código a seguir mostra Como preceder um número de linha para cada linha:

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