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.
Essayez en ligne
Vous pouvez comparer deux documents en ligne en utilisant le Comparaison de documents en ligne outil.
Notez que la méthode de comparaison, décrite ci-dessous, est utilisée dans cet outil pour garantir des résultats égaux. Ainsi, vous obtiendrez les mêmes résultats même en utilisant l’outil de comparaison en ligne ou en utilisant la méthode de comparaison dans Aspose.Words.
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"); |