Trouver et Remplacer

Vous pouvez facilement naviguer dans votre document à l’aide d’un clavier et d’une souris, mais si vous avez de nombreuses pages à parcourir, il vous faudra un certain temps pour trouver un texte spécifique dans un long document. Cela prendra plus de temps lorsque vous souhaiterez remplacer certains caractères ou mots que vous avez utilisés dans votre document. La fonctionnalité “Rechercher et remplacer” vous permet de rechercher une séquence de caractères dans un document et de la remplacer par une autre séquence de caractères.

Aspose.Words vous permet de rechercher une chaîne spécifique ou un modèle d’expression régulière dans votre document et de le remplacer par une alternative sans installer et utiliser d’applications supplémentaires telles que Microsoft Word. Cela accélérera de nombreuses tâches de saisie et de formatage, vous permettant potentiellement d’économiser des heures de travail.

Cet article explique comment appliquer le remplacement de chaîne et les expressions régulières avec le support des métacaractères.

Façons de trouver et de remplacer

Aspose.Words fournit deux façons d’appliquer l’opération de recherche et de remplacement à l’aide des éléments suivants:

1. Simple string replacement - pour rechercher et remplacer une chaîne spécifique par une autre, vous devez spécifier une chaîne de recherche (caractères alphanumériques) qui va être remplacée en fonction de toutes les occurrences par une autre chaîne de remplacement spécifiée. Les deux chaînes ne doivent pas contenir de symboles. Tenez compte du fait que la comparaison de chaînes peut être sensible à la casse, ou vous pouvez ne pas être sûr de l’orthographe ou avoir plusieurs orthographes similaires.
2. Regular expressions - pour spécifier une expression régulière pour trouver les correspondances de chaîne exactes et les remplacer en fonction de votre expression régulière. Notez qu’un mot est défini comme étant composé uniquement de caractères alphanumériques. Si un remplacement est exécuté avec uniquement des mots entiers correspondants et que la chaîne d’entrée contient des symboles, aucune phrase ne sera trouvée.

En outre, vous pouvez utiliser des métacaractères spéciaux avec un simple remplacement de chaîne et des expressions régulières pour spécifier des pauses dans l’opération de recherche et de remplacement.

Aspose.Words présente la fonctionnalité rechercher et remplacer avec IReplacingCallBack. Vous pouvez travailler avec de nombreuses options pendant le processus de recherche et de remplacement en utilisant la classe FindReplaceOptions.

Rechercher et remplacer du Texte à l’Aide d’un simple Remplacement de Chaîne

Vous pouvez utiliser l’une des méthodes Replace pour rechercher ou remplacer une chaîne particulière et renvoyer le nombre de remplacements effectués. Dans ce cas, vous pouvez spécifier une chaîne à remplacer, une chaîne qui remplacera toutes ses occurrences, si le remplacement est sensible à la casse et si seuls les mots autonomes seront affectés.

L’exemple de code suivant montre comment trouver la chaîne “CustomerName " et la remplacer par la chaîne “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");

Vous pouvez remarquer la différence entre le document avant d’appliquer un simple remplacement de chaîne:

Et après avoir appliqué un simple remplacement de chaîne:

Rechercher et remplacer du Texte à l’aide d’Expressions Régulières

Une expression régulière (regex) est un motif qui décrit une certaine séquence de texte. Supposons que vous souhaitiez remplacer toutes les occurrences doubles d’un mot par une occurrence d’un seul mot. Ensuite, vous pouvez appliquer l’expression régulière suivante pour spécifier le modèle de double mot: ([a-zA-Z]+) \1.

Utilisez l’autre méthode Replace pour rechercher et remplacer des combinaisons de caractères particulières en définissant le paramètre Regex comme modèle d’expression régulière pour trouver des correspondances.

L’exemple de code suivant montre comment remplacer les chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée:

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

Vous pouvez remarquer la différence entre le document avant d’appliquer le remplacement de chaîne par des expressions régulières:

Et après avoir appliqué le remplacement de chaîne avec des expressions régulières:

Rechercher et remplacer une Chaîne à l’aide de métacaractères

Vous pouvez utiliser des métacaractères dans la chaîne de recherche ou la chaîne de remplacement si un texte ou une phrase particulière est composé de plusieurs paragraphes, sections ou pages. Certains des métacaractères incluent &p pour un saut de paragraphe, &b pour un saut de section, &m pour un saut de page et &l pour un saut de ligne.

Notez que le métacaractère && est égal à &. Par exemple, si vous avez besoin de trouver le texte pour &p qui n’est pas un saut de paragraphe, vous pouvez utiliser &&p.

L’exemple de code suivant montre comment remplacer le texte par un paragraphe et un saut de page:

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

Rechercher et remplacer une chaîne dans l’en-tête/le pied de page d’un Document

Vous pouvez rechercher et remplacer du texte dans la section en-tête/pied de page d’un document Word à l’aide de la classe HeaderFooter.

L’exemple de code suivant montre comment remplacer le texte de la section d’en-tête dans votre document:

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

Vous pouvez remarquer la différence entre le document avant d’appliquer le remplacement de la chaîne d’en-tête:

Et après avoir appliqué le remplacement de la chaîne d’en-tête:

L’exemple de code pour remplacer le texte de la section de pied de page dans votre document est très similaire à l’exemple de code d’en-tête précédent. Il vous suffit de remplacer les deux lignes suivantes:

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

Avec ce qui suit:

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

Vous pouvez remarquer la différence entre le document avant d’appliquer le remplacement de la chaîne de pied de page:

Et après avoir appliqué le remplacement de la chaîne de pied de page:

Ignorer le texte Pendant la Recherche et le remplacement

Lors de l’application de l’opération de recherche et de remplacement, vous pouvez ignorer certains segments du texte. Ainsi, certaines parties du texte peuvent être exclues de la recherche, et la recherche et le remplacement ne peuvent être appliqués qu’aux parties restantes.

Aspose.Words fournit de nombreuses propriétés de recherche et de remplacement pour ignorer le texte, telles que IgnoreDeleted, IgnoreFieldCodes, IgnoreFields, IgnoreFootnotes, et IgnoreInserted.

L’exemple de code suivant montre comment ignorer le texte dans les révisions de suppression:

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

Personnaliser l’opération de recherche et de remplacement

Aspose.Words fournit de nombreux properties différents pour rechercher et remplacer du texte, tels que l’application d’un format spécifique avec les propriétés ApplyFont et ApplyParagraphFormats, l’utilisation de substitutions dans les modèles de remplacement avec la propriété UseSubstitutions, et d’autres.

L’exemple de code suivant montre comment mettre en évidence un mot spécifique dans votre document:

// 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 vous permet d’utiliser l’interface IReplacingCallback pour créer et appeler une méthode personnalisée lors d’une opération de remplacement. Vous pouvez avoir des cas d’utilisation où vous devez personnaliser l’opération de recherche et de remplacement, comme le remplacement du texte spécifié par une expression régulière avec des balises HTML, donc en gros, vous appliquerez replace en insérant HTML.

Si vous devez remplacer une chaîne par une balise HTML, appliquez l’interface IReplacingCallback pour personnaliser l’opération de recherche et de remplacement afin que la correspondance commence au début d’une exécution avec le nœud de correspondance de votre document. Donnons plusieurs exemples d’utilisation de IReplacingCallback.

L’exemple de code suivant montre comment remplacer le texte spécifié par 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;
       }
}

L’exemple de code suivant montre comment mettre en évidence les nombres positifs de couleur verte et les nombres négatifs de couleur rouge:

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

L’exemple de code suivant montre comment ajouter un numéro de ligne à chaque ligne:

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