Comparer des Documents

La comparaison de documents est un processus qui identifie les modifications entre deux documents et contient les modifications en tant que révisions. Ce processus compare deux documents quelconques, y compris les versions d’un document spécifique, puis les modifications entre les deux documents seront affichées sous forme de révisions dans le premier document.

La méthode de comparaison est réalisée en comparant des mots au niveau des caractères ou au niveau des mots. Si un mot contient un changement d’au moins un caractère, dans le résultat, la différence sera affichée comme un changement du mot entier, pas d’un caractère. Ce processus de comparaison est une tâche habituelle dans les industries juridiques et financières.

Au lieu de rechercher manuellement les différences entre les documents ou entre différentes versions de ceux-ci, vous pouvez utiliser Aspose.Words pour comparer des documents et obtenir des modifications de contenu dans la mise en forme, l’en-tête/pied de page, les tableaux, etc.

Cet article explique comment comparer des documents et comment spécifier des propriétés de comparaison avancées.

Limitations et Formats de fichiers pris en charge

La comparaison de documents est une fonctionnalité très complexe. Il existe diverses parties de la combinaison de contenu qui doivent être analysées pour reconnaître toutes les différences. La raison de cette complexité est que Aspose.Words vise à obtenir les mêmes résultats de comparaison que l’algorithme de comparaison Microsoft Word.

La limitation générale pour deux documents comparés est qu’ils ne doivent pas avoir de révisions avant d’appeler la méthode compare car cette limitation existe dans Microsoft Word.

Comparer deux Documents

Lorsque vous comparez des documents,les différences entre ce dernier document et le premier apparaissent comme des révisions du premier. Lorsque vous modifiez un document, chaque modification aura sa propre révision après l’exécution de la méthode de comparaison.

Aspose.Words vous permet d’identifier les différences entre les documents à l’aide de la méthode Compare, similaire à la fonction de comparaison de documents Microsoft Word. Il vous permet de vérifier des documents ou des versions de documents pour trouver des différences et des modifications, y compris des modifications de formatage telles que des changements de police, des changements d’espacement, l’ajout de mots et de paragraphes.

À la suite de la comparaison, les documents peuvent être déterminés comme égaux ou non égaux. Le terme “documents égaux” signifie que la méthode de comparaison ne peut pas représenter les changements comme des révisions. Cela signifie que le texte du document et la mise en forme du texte sont identiques. Mais il peut y avoir d’autres différences entre les documents. Par exemple, Microsoft Word ne prend en charge que les révisions de format pour les styles, et vous ne pouvez pas représenter l’insertion/suppression de style. Ainsi, les documents peuvent avoir un ensemble de styles différent, et la méthode Compare ne produit toujours aucune révision.

L’exemple de code suivant montre comment vérifier si deux documents sont égaux ou non:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
Document docA = new Document(dataDir + "DocumentA.doc");
Document docB = new Document(dataDir + "DocumentB.doc");
docA.compare(docB, "user", new Date());
if (docA.getRevisions().getCount() == 0)
System.out.println("Documents are equal");
else
System.out.println("Documents are not equal");

L’exemple de code suivant montre comment appliquer simplement la méthode Compare à deux documents:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
// The source document doc1
Document doc1 = new Document();
DocumentBuilder builder = new DocumentBuilder(doc1);
builder.writeln("This is the original document.");
// The target document doc2
Document doc2 = new Document();
builder = new DocumentBuilder(doc2);
builder.writeln("This is the edited document.");
// If either document has a revision, an exception will be thrown
if (doc1.getRevisions().getCount() == 0 && doc2.getRevisions().getCount() == 0)
doc1.compare(doc2, "authorName", new Date());
// If doc1 and doc2 are different, doc1 now has some revisions after the comparison, which can now be viewed and processed
if (doc1.getRevisions().getCount() == 2)
System.out.println("Documents are equal");
for (Revision r : doc1.getRevisions())
{
System.out.println("Revision type: " + r.getRevisionType() + ", on a node of type " + r.getParentNode().getNodeType() + "");
System.out.println("\tChanged text: " + r.getParentNode().getText() + "");
}
// All the revisions in doc1 are differences between doc1 and doc2, so accepting them on doc1 transforms doc1 into doc2
doc1.getRevisions().acceptAll();
// doc1, when saved, now resembles doc2
doc1.save(dataDir + "Document.Compare.docx");
doc1 = new Document(dataDir + "Document.Compare.docx");
if (doc1.getRevisions().getCount() == 0)
System.out.println("Documents are equal");
if (doc2.getText().trim() == doc1.getText().trim())
System.out.println("Documents are equal");

Spécifiez les Options de Comparaison Avancées

Il existe de nombreuses propriétés différentes de la classe CompareOptions que vous pouvez appliquer lorsque vous souhaitez comparer des documents.

Par exemple, Aspose.Words vous permet d’ignorer les modifications apportées lors d’une opération de comparaison pour certains types d’objets dans le document d’origine. Vous pouvez sélectionner la propriété appropriée pour le type d’objet, par exemple IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, et d’autres en les réglant sur “vrai”.

De plus, Aspose.Words fournit la propriété Granularity avec laquelle vous pouvez spécifier si vous souhaitez suivre les modifications par caractère ou par mot.

Une autre propriété commune est le choix du document dans lequel afficher les modifications de comparaison. Par exemple, la" boîte de dialogue Comparer les documents “dans Microsoft Word a l’option “Afficher les modifications dans” – cela affecte également les résultats de la comparaison. Aspose.Words fournit la propriété Target qui sert à cette fin.

L’exemple de code suivant montre comment définir les propriétés de comparaison avancées:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
// Create the original document
Document docOriginal = new Document();
DocumentBuilder builder = new DocumentBuilder(docOriginal);
// Insert paragraph text with an endnote
builder.writeln("Hello world! This is the first paragraph.");
builder.insertFootnote(FootnoteType.ENDNOTE, "Original endnote text.");
// Insert a table
builder.startTable();
builder.insertCell();
builder.write("Original cell 1 text");
builder.insertCell();
builder.write("Original cell 2 text");
builder.endTable();
// Insert a textbox
Shape textBox = builder.insertShape(ShapeType.TEXT_BOX, 150, 20);
builder.moveTo(textBox.getFirstParagraph());
builder.write("Original textbox contents");
// Insert a DATE field
builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph(""));
builder.insertField(" DATE ");
// Insert a comment
Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date());
newComment.setText("Original comment.");
builder.getCurrentParagraph().appendChild(newComment);
// Insert a header
builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY);
builder.writeln("Original header contents.");
// Create a clone of our document, which we will edit and later compare to the original
Document docEdited = (Document)docOriginal.deepClone(true);
Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph();
// Change the formatting of the first paragraph, change casing of original characters and add text
firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing.");
firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().get(StyleIdentifier.HEADING_1));
// Edit the footnote
Footnote footnote = (Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true);
footnote.getFirstParagraph().getRuns().get(1).setText("Edited endnote text.");
// Edit the table
Table table = (Table)docEdited.getChild(NodeType.TABLE, 0, true);
table.getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents");
// Edit the textbox
textBox = (Shape)docEdited.getChild(NodeType.SHAPE, 0, true);
textBox.getFirstParagraph().getRuns().get(0).setText("Edited textbox contents");
// Edit the DATE field
FieldDate fieldDate = (FieldDate)docEdited.getRange().getFields().get(0);
fieldDate.setUseLunarCalendar(true);
// Edit the comment
Comment comment = (Comment)docEdited.getChild(NodeType.COMMENT, 0, true);
comment.getFirstParagraph().getRuns().get(0).setText("Edited comment.");
// Edit the header
docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents.");
// Apply different comparing options
CompareOptions compareOptions = new CompareOptions();
compareOptions.setIgnoreFormatting(false);
compareOptions.setIgnoreCaseChanges(false);
compareOptions.setIgnoreComments(false);
compareOptions.setIgnoreTables(false);
compareOptions.setIgnoreFields(false);
compareOptions.setIgnoreFootnotes(false);
compareOptions.setIgnoreTextboxes(false);
compareOptions.setIgnoreHeadersAndFooters(false);
compareOptions.setTarget(ComparisonTargetType.NEW);
// compare both documents
docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions);
docOriginal.save(dataDir + "Document.CompareOptions.docx");