Documenten vergelijken
Het vergelijken van documenten is een proces dat veranderingen tussen twee documenten identificeert en de wijzigingen als herzieningen bevat. Dit proces vergelijkt twee documenten, waaronder versies van één specifiek document, dan worden de wijzigingen tussen beide documenten getoond als herzieningen in het eerste document.
De vergelijkingsmethode wordt bereikt door woorden op tekenniveau of op woordniveau te vergelijken. Als een woord een verandering van ten minste één teken bevat, wordt in het resultaat het verschil weergegeven als een verandering van het hele woord, geen teken. Dit vergelijkingsproces is een gebruikelijke taak in de juridische en financiële sector.
In plaats van handmatig te zoeken naar verschillen tussen documenten of tussen verschillende versies ervan, kunt u Aspose.Words voor het vergelijken van documenten en het krijgen van wijzigingen in inhoud in formatteren, header/voeter, tabellen, en meer.
Dit artikel legt uit hoe documenten te vergelijken en hoe geavanceerde vergelijkingseigenschappen te specificeren.
Probeer online
U kunt twee documenten online vergelijken met behulp van de Documentvergelijkend online gereedschap.
Merk op dat de vergelijkingsmethode, hieronder beschreven, wordt gebruikt in dit hulpmiddel om te zorgen voor gelijke resultaten. Zo krijgt u dezelfde resultaten, zelfs met behulp van de online vergelijking tool of met behulp van de vergelijking methode in Aspose.Words.
Beperkingen en ondersteunde bestandsformaten
Het vergelijken van documenten is een zeer complex kenmerk. Er zijn verschillende delen van de inhoud combinatie die moeten worden geanalyseerd om alle verschillen te herkennen. De reden voor deze complexiteit is omdat Aspose.Words doelt op dezelfde vergelijkingsresultaten als de Microsoft Word vergelijkingsalgoritme.
De algemene beperking voor twee documenten die worden vergeleken, is dat zij geen herzieningen mogen hebben alvorens de vergelijkingsmethode aan te roepen, aangezien deze beperking bestaat in Microsoft Word.
Vergelijk twee documenten
Wanneer u documenten vergelijkt, verschillen van het laatste document van het eerste verschijnen als herzieningen van het eerste. Wanneer u een document wijzigt, zal elke bewerking een eigen revisie hebben na het uitvoeren van de vergelijkingsmethode.
Aspose.Words kunt u documenten verschillen met behulp van de Compare Dit is vergelijkbaar met de Microsoft Word functie document vergelijken. Hiermee kunt u documenten of documentversies controleren om verschillen en wijzigingen te vinden, waaronder opmaakwijzigingen zoals lettertypewijzigingen, spatiëringswijzigingen, toevoeging van woorden en alinea’s.
Als gevolg van de vergelijking kunnen documenten worden vastgesteld als gelijk of niet gelijk. De term “gelijke documenten” betekent dat de vergelijkingsmethode geen wijzigingen als herzieningen kan weergeven. Dit betekent dat zowel documenttekst als tekstopmaak hetzelfde zijn. Maar er kunnen andere verschillen zijn tussen documenten. Bijvoorbeeld, Microsoft Word ondersteunt alleen format revisies voor stijlen, en u kunt niet vertegenwoordigen stijl invoegen / verwijderen. Dus documenten kunnen een andere set van stijlen, en de Compare methode levert nog steeds geen herzieningen op.
Het volgende voorbeeld van code laat zien hoe te controleren of twee documenten gelijk zijn of niet:
// 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"); |
Het volgende voorbeeld van de code laat zien hoe u de Compare
methode voor twee documenten:
// 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"); |
Geavanceerde vergelijkingsopties specificeren
Er zijn veel verschillende eigenschappen van de CompareOptions klasse die u kunt toepassen wanneer u documenten wilt vergelijken.
Bijvoorbeeld, Aspose.Words Hiermee kunt u wijzigingen negeren die zijn gemaakt tijdens een vergelijkingsbewerking voor bepaalde soorten objecten in het oorspronkelijke document. U kunt de juiste eigenschap voor het objecttype selecteren, zoals IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, en anderen door ze op “true”
Bovendien, Aspose.Words levert de Granularity eigenschap waarmee u kunt specificeren of wijzigingen per teken of per woord moeten worden gevolgd.
Een andere gemeenschappelijke eigenschap is een keuze in welk document om vergelijkingsveranderingen te tonen. Bijvoorbeeld het dialoogvenster documenten vergelijken Microsoft Word heeft de optie Aspose.Words levert de Target bezit dat dit doel dient.
Het volgende voorbeeld van code laat zien hoe u de geavanceerde vergelijkingseigenschappen kunt instellen:
// 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"); |