Buscar y Reemplazar

Puede navegar fácilmente dentro de su documento usando un teclado y un mouse, pero si tiene muchas páginas por las que desplazarse, le llevará bastante tiempo encontrar texto específico en un documento largo. Llevará más tiempo cuando desee reemplazar ciertos caracteres o palabras que ha utilizado en su documento. La funcionalidad “Buscar y reemplazar” le permite buscar una secuencia de caracteres en un documento y reemplazarla con otra secuencia de caracteres.

Aspose.Words le permite encontrar una cadena específica o un patrón de expresión regular en su documento y reemplazarlo con una alternativa sin instalar y usar aplicaciones adicionales como Microsoft Word. Esto acelerará muchas tareas de escritura y formato, lo que podría ahorrarle horas de trabajo.

Este artículo explica cómo aplicar reemplazo de cadenas y expresiones regulares con el soporte de metacaracteres.

Formas de Buscar y reemplazar

Aspose.Words proporciona dos formas de aplicar la operación de búsqueda y reemplazo mediante lo siguiente:

1. Simple string replacement - para buscar y reemplazar una cadena específica con otra, debe especificar una cadena de búsqueda (caracteres alfanuméricos) que se reemplazará de acuerdo con todas las ocurrencias con otra cadena de reemplazo especificada. Ambas cadenas no deben contener símbolos. Tenga en cuenta que la comparación de cadenas puede distinguir entre mayúsculas y minúsculas, o puede no estar seguro de la ortografía o tener varias ortografías similares.
2. Regular expressions: para especificar una expresión regular para encontrar las coincidencias exactas de la cadena y reemplazarlas de acuerdo con su expresión regular. Tenga en cuenta que una palabra se define como compuesta solo de caracteres alfanuméricos. Si se ejecuta un reemplazo con solo palabras completas que coinciden y la cadena de entrada contiene símbolos, entonces no se encontrarán frases.

Además, puede usar metacaracteres especiales con reemplazo simple de cadenas y expresiones regulares para especificar saltos dentro de la operación de búsqueda y reemplazo.

Aspose.Words presenta la funcionalidad de buscar y reemplazar con IReplacingCallBack. Puede trabajar con muchas opciones durante el proceso de búsqueda y reemplazo utilizando la clase FindReplaceOptions.

Busque y Reemplace Texto Usando Reemplazo Simple de Cadena

Puede usar uno de los métodos Replace para buscar o reemplazar una cadena en particular y devolver el número de reemplazos que se realizaron. En este caso, puede especificar una cadena que se reemplazará, una cadena que reemplazará todas sus apariciones, si la sustitución distingue entre mayúsculas y minúsculas y si solo se verán afectadas las palabras independientes.

El siguiente ejemplo de código muestra cómo encontrar la cadena “CustomerName " y reemplazarla con la cadena “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");

Puede notar la diferencia entre el documento antes de aplicar el reemplazo simple de cadenas:

Y después de aplicar un simple reemplazo de cuerdas:

Buscar y Reemplazar Texto Usando Expresiones Regulares

Una expresión regular (regex) es un patrón que describe una determinada secuencia de texto. Supongamos que desea reemplazar todas las apariciones dobles de una palabra con una sola aparición de palabra. Luego puede aplicar la siguiente expresión regular para especificar el patrón de doble palabra: ([a-zA-Z]+) \1.

Utilice el otro método Replace para buscar y reemplazar combinaciones de caracteres particulares estableciendo el parámetro Regex como patrón de expresión regular para encontrar coincidencias.

El siguiente ejemplo de código muestra cómo reemplazar cadenas que coinciden con un patrón de expresión regular con una cadena de reemplazo 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");

Puede notar la diferencia entre el documento antes de aplicar el reemplazo de cadenas con expresiones regulares:

Y después de aplicar el reemplazo de cadenas con expresiones regulares:

Buscar y reemplazar Cadenas usando Metacaracteres

Puede usar metacaracteres en la cadena de búsqueda o en la cadena de reemplazo si un texto o frase en particular está compuesto por varios párrafos, secciones o páginas. Algunos de los metacaracteres incluyen &p para un salto de párrafo, &b para un salto de sección, &m para un salto de página y &l para un salto de línea.

Tenga en cuenta que el metacarácter && es igual a &. Por ejemplo, si necesita encontrar el texto de &p que no sea un salto de párrafo, puede usar &&p.

El siguiente ejemplo de código muestra cómo reemplazar texto con párrafo y salto 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");

Buscar y reemplazar Cadenas en el Encabezado / Pie de página de un Documento

Puede buscar y reemplazar texto en la sección encabezado/pie de página de un documento de Word utilizando la clase HeaderFooter.

El siguiente ejemplo de código muestra cómo reemplazar el texto de la sección del encabezado en su 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");

Puede notar la diferencia entre el documento antes de aplicar el reemplazo de la cadena de encabezado:

Y después de aplicar el reemplazo de la cadena de encabezado:

El ejemplo de código para reemplazar el texto de la sección de pie de página en su documento es muy similar al ejemplo de código de encabezado anterior. Todo lo que necesita hacer es reemplazar las siguientes dos líneas:

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

Con lo siguiente:

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

Puede notar la diferencia entre el documento antes de aplicar el reemplazo de la cadena del pie de página:

Y después de aplicar el reemplazo de la cadena del pie de página:

Ignorar texto Durante Buscar y reemplazar

Al aplicar la operación de buscar y reemplazar, puede ignorar ciertos segmentos del texto. Por lo tanto, ciertas partes del texto se pueden excluir de la búsqueda, y la búsqueda y reemplazo se puede aplicar solo a las partes restantes.

Aspose.Words proporciona muchas propiedades de búsqueda y reemplazo para ignorar texto, como IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, y IgnoreInserted.

El siguiente ejemplo de código muestra cómo ignorar texto dentro de eliminar revisiones:

// 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 la Operación de Búsqueda y reemplazo

Aspose.Words proporciona muchos properties diferentes para buscar y reemplazar texto, como aplicar un formato específico con las propiedades ApplyFont y ApplyParagraphFormats, usar sustituciones en patrones de reemplazo con la propiedad UseSubstitutions y otros.

El siguiente ejemplo de código muestra cómo resaltar una palabra específica en su 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 le permite usar la interfaz IReplacingCallback para crear y llamar a un método personalizado durante una operación de reemplazo. Es posible que tenga algunos casos de uso en los que necesite personalizar la operación de búsqueda y reemplazo, como reemplazar el texto especificado con una expresión regular con etiquetas HTML, por lo que básicamente aplicará reemplazar con insertar HTML.

Si necesita reemplazar una cadena con una etiqueta HTML, aplique la interfaz IReplacingCallback para personalizar la operación de búsqueda y reemplazo de modo que la coincidencia comience al comienzo de una ejecución con el nodo de coincidencia de su documento. Proporcionemos varios ejemplos del uso de IReplacingCallback.

El siguiente ejemplo de código muestra cómo reemplazar el texto especificado con 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;
       }
}

El siguiente ejemplo de código muestra cómo resaltar números positivos con color verde y números negativos con color rojo:

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

El siguiente ejemplo de código muestra cómo anteponer un número de línea a cada línea:

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