Vergelyk Dokumente

Die vergelyking van dokumente is’n proses wat veranderinge tussen twee dokumente identifiseer en die veranderinge as hersienings bevat. Hierdie proses vergelyk enige twee dokumente, insluitend weergawes van een spesifieke dokument, dan sal die veranderinge tussen beide dokumente as hersienings in die eerste dokument vertoon word.

Die vergelykingsmetode word bereik deur woorde op karaktervlak of op woordvlak te vergelyk. As’n woord’n verandering van ten minste een karakter bevat, sal die verskil in die resultaat vertoon word as’n verandering van die hele woord, nie’n karakter nie. Hierdie vergelykingsproses is’n gewone taak in die regs-en finansiële bedrywe.

In plaas daarvan om handmatig na verskille tussen dokumente of tussen verskillende weergawes daarvan te soek, kan jy Aspose.Words gebruik om dokumente te vergelyk en inhoudveranderings in formatering, koptekst/voetskrif, tabelle en meer te kry.

Hierdie artikel verduidelik hoe om dokumente te vergelyk en hoe om gevorderde vergelykende eienskappe te spesifiseer.

Beperkings en Ondersteunde Lêerformate

Vergelyking van dokumente is’n baie komplekse kenmerk. Daar is verskillende dele van inhoudkombinasie wat ontleed moet word om alle verskille te herken. Die rede vir hierdie kompleksiteit is omdat Aspose.Words dieselfde vergelykingsresultate as die Microsoft Word vergelykingsalgoritme wil kry.

Die algemene beperking vir twee dokumente wat vergelyk word, is dat hulle nie hersienings mag hê voordat hulle die vergelykingsmetode noem nie, aangesien hierdie beperking in Microsoft Word bestaan.

Vergelyk Twee Dokumente

Wanneer jy dokumente vergelyk, verskyn verskille van laasgenoemde dokument van eersgenoemde as hersienings van eersgenoemde. As u’n dokument verander, sal elke wysiging sy eie hersiening hê nadat u die vergelykingsmetode uitgevoer het.

Aspose.Words laat jou toe om dokumente verskille te identifiseer met behulp van die Compare metode – dit is soortgelyk aan die Microsoft Word dokument vergelyk funksie. Dit laat jou toe om dokumente of dokumentweergawes na te gaan om verskille en veranderinge te vind, insluitend formateringsaanpassings soos lettertipeveranderings, spasiëringsveranderinge, die byvoeging van woorde en paragrawe.

As gevolg van die vergelyking kan dokumente as gelyk of nie gelyk bepaal word nie. Die term “gelyke” dokumente beteken dat die vergelykingsmetode nie veranderinge as hersienings kan voorstel nie. Dit beteken dat beide dokument teks en teks formatering is dieselfde. Maar daar kan ander verskille tussen dokumente wees. Byvoorbeeld, Microsoft Word ondersteun slegs formaat hersienings vir style, en jy kan nie styl invoeging/verwydering verteenwoordig. Dokumente kan dus’n ander stel style hê, en die Compare metode lewer steeds geen hersienings nie.

Die volgende kode voorbeeld toon hoe om te kyk of twee dokumente is gelyk of nie:

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

Die volgende kode voorbeeld toon hoe om eenvoudig die Compare metode toe te pas op twee dokumente:

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

Spesifiseer Gevorderde Vergelykingsopsies

Daar is baie verskillende eienskappe van die CompareOptions klas wat jy kan aansoek doen wanneer jy wil dokumente te vergelyk.

Byvoorbeeld, Aspose.Words laat jou toe om veranderinge wat tydens’n vergelykingsbewerking vir sekere soorte voorwerpe in die oorspronklike dokument gemaak is, te ignoreer. Jy kan die toepaslike eienskap vir die voorwerp tipe kies, soos IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, en ander deur hulle op “waar"te stel.

Daarbenewens bied Aspose.Words die Granularity eienskap waarmee u kan spesifiseer of u veranderinge volgens karakter of woord moet opspoor.

Nog’n gemeenskaplike eienskap is’n keuse in watter dokument om vergelyking veranderinge te wys. Byvoorbeeld, die” Vergelyk dokumente dialoog boks “in Microsoft Word het die opsie” Wys veranderinge in " – dit beïnvloed ook die vergelyking resultate. Aspose.Words verskaf die Target eienskap wat hierdie doel dien.

Die volgende kode voorbeeld toon hoe om die gevorderde vergelyking eienskappe stel:

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