Dokumente vergleichen
Das Vergleichen von Dokumenten ist ein Prozess, der Änderungen zwischen zwei Dokumenten identifiziert und die Änderungen als Revisionen enthält. Dieser Prozess vergleicht zwei beliebige Dokumente, einschließlich Versionen eines bestimmten Dokuments, dann werden die Änderungen zwischen beiden Dokumenten als Revisionen im ersten Dokument angezeigt.
Das Vergleichsverfahren wird durch Vergleichen von Wörtern auf Zeichenebene oder auf Wortebene erreicht. Wenn ein Wort eine Änderung von mindestens einem Zeichen enthält, wird die Differenz im Ergebnis als Änderung des gesamten Wortes und nicht als Zeichen angezeigt. Dieser Vergleichsprozess ist eine übliche Aufgabe in der Rechts- und Finanzbranche.
Anstatt manuell nach Unterschieden zwischen Dokumenten oder zwischen verschiedenen Versionen davon zu suchen, können Sie Aspose.Words zum Vergleichen von Dokumenten und zum Abrufen von Inhaltsänderungen in Formatierung, Kopf- / Fußzeile, Tabellen und mehr verwenden.
In diesem Artikel wird erläutert, wie Sie Dokumente vergleichen und erweiterte Vergleichseigenschaften angeben.
Online ausprobieren
Sie können zwei Dokumente online vergleichen, indem Sie die Dokumentenvergleich online Werkzeug.
Beachten Sie, dass die unten beschriebene Vergleichsmethode in diesem Tool verwendet wird, um sicherzustellen, dass gleiche Ergebnisse erzielt werden. So erhalten Sie auch mit dem Online Vergleichstool oder mit der Vergleichsmethode in Aspose.Words die gleichen Ergebnisse.
Einschränkungen und unterstützte Dateiformate
Der Vergleich von Dokumenten ist eine sehr komplexe Funktion. Es gibt verschiedene Teile der Inhaltskombination, die analysiert werden müssen, um alle Unterschiede zu erkennen. Der Grund für diese Komplexität liegt darin, dass Aspose.Words darauf abzielt, dieselben Vergleichsergebnisse wie der Microsoft Word -Vergleichsalgorithmus zu erhalten.
Die allgemeine Einschränkung für zwei zu vergleichende Dokumente besteht darin, dass sie vor dem Aufruf der compare Methode keine Revisionen haben dürfen, da diese Einschränkung in Microsoft Word vorhanden ist.
Zwei Dokumente vergleichen
Wenn Sie Dokumente vergleichen, werden Unterschiede des letzteren Dokuments zum ersteren als Überarbeitungen zum ersteren angezeigt. Wenn Sie ein Dokument ändern, hat jede Bearbeitung nach dem Ausführen der Vergleichsmethode eine eigene Revision.
Aspose.Words ermöglicht es Ihnen, Dokumentunterschiede mit der Compare-Methode zu identifizieren - dies ähnelt der Microsoft Word-Dokumentvergleichsfunktion. Es ermöglicht Ihnen, Dokumente oder Dokumentversionen zu überprüfen, um Unterschiede und Änderungen zu finden, einschließlich Formatierungsänderungen wie Schriftänderungen, Abstandsänderungen, Hinzufügen von Wörtern und Absätzen.
Als Ergebnis des Vergleichs können Dokumente als gleich oder ungleich bestimmt werden. Der Begriff “gleiche” Dokumente bedeutet, dass die Vergleichsmethode Änderungen nicht als Revisionen darstellen kann. Dies bedeutet, dass sowohl Dokumenttext als auch Textformatierung identisch sind. Es kann jedoch auch andere Unterschiede zwischen Dokumenten geben. Beispielsweise unterstützt Microsoft Word nur Formatrevisionen für Stile, und Sie können das Einfügen / Löschen von Stilen nicht darstellen. Dokumente können also unterschiedliche Stile haben, und die Compare -Methode erzeugt immer noch keine Revisionen.
Das folgende Codebeispiel zeigt, wie überprüft wird, ob zwei Dokumente gleich sind oder nicht:
// 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"); |
Das folgende Codebeispiel zeigt, wie Sie die Compare
-Methode einfach auf zwei Dokumente anwenden:
// 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"); |
Erweiterte Vergleichsoptionen angeben
Es gibt viele verschiedene Eigenschaften der Klasse CompareOptions, die Sie anwenden können, wenn Sie Dokumente vergleichen möchten.
Mit Aspose.Words können Sie beispielsweise Änderungen ignorieren, die während eines Vergleichsvorgangs für bestimmte Objekttypen im Originaldokument vorgenommen wurden. Sie können die entsprechende Eigenschaft für den Objekttyp auswählen, z. B IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, und andere, indem Sie sie auf “wahr” setzen.
Darüber hinaus stellt Aspose.Words die Eigenschaft Granularity bereit, mit der Sie angeben können, ob Änderungen nach Zeichen oder nach Wörtern verfolgt werden sollen.
Eine weitere häufige Eigenschaft ist die Auswahl, in welchem Dokument Vergleichsänderungen angezeigt werden sollen. Beispielsweise hat der “Dialog Dokumente vergleichen” in Microsoft Word die Option “Änderungen anzeigen in” – dies wirkt sich auch auf die Vergleichsergebnisse aus. Aspose.Words stellt die Eigenschaft Target bereit, die diesem Zweck dient.
Das folgende Codebeispiel zeigt, wie Sie die erweiterten Vergleichseigenschaften festlegen:
// 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"); |