Documenten Vergelijken

Het vergelijken van documenten is een proces dat wijzigingen tussen twee documenten identificeert en de wijzigingen als revisies bevat. Dit proces vergelijkt om het even welke twee documenten, met inbegrip van versies van één specifiek document, dan zullen de wijzigingen tussen beide documenten als herzieningen in het eerste document worden getoond.

De vergelijkingsmethode wordt bereikt door woorden op karakterniveau of woordniveau te vergelijken. Als een woord een verandering van ten minste één teken bevat, wordt het verschil in het resultaat weergegeven als een verandering van het hele woord, niet als een 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 gebruiken voor het vergelijken van documenten en het verkrijgen van inhoudswijzigingen in opmaak, kop - /voettekst, tabellen en meer.

In dit artikel wordt uitgelegd hoe u documenten kunt vergelijken en hoe u geavanceerde vergelijkingseigenschappen kunt opgeven.

Online proberen

U kunt twee documenten online vergelijken met behulp van de Documentvergelijking online tool.

Merk op dat de vergelijkingsmethode, die hieronder wordt beschreven, in deze tool wordt gebruikt om ervoor te zorgen dat gelijke resultaten worden verkregen. U krijgt dus dezelfde resultaten, zelfs met behulp van de online vergelijkingstool of met behulp van de vergelijkingsmethode in Aspose.Words.

Beperkingen en Ondersteunde bestandsindelingen

Het vergelijken van documenten is een zeer complexe functie. Er zijn verschillende delen van de inhoudscombinatie die moeten worden geanalyseerd om alle verschillen te herkennen. De reden voor deze complexiteit is te wijten aan het feit dat Aspose.Words dezelfde vergelijkingsresultaten wil krijgen als het Microsoft Word vergelijkingsalgoritme.

De algemene beperking voor twee documenten die worden vergeleken, is dat ze geen herzieningen mogen hebben voordat de vergelijkingsmethode wordt aangeroepen, aangezien deze beperking bestaat in Microsoft Word.

Merk op dat u twee documenten kunt vergelijken binnen de ondersteunde bestandsformaten. U kunt documentobjecten vergelijken en zelfs u kunt die objecten helemaal opnieuw maken zonder een specifieke indeling te hebben.

Twee Documenten {#compare-two-documents}Vergelijken

Wanneer u documenten vergelijkt, worden verschillen tussen het laatste document en het eerste weergegeven als herzieningen van het eerste. Wanneer u een document wijzigt, heeft elke bewerking zijn eigen herziening nadat u de vergelijkingsmethode hebt uitgevoerd.

Met Aspose.Words kunt u verschillen in documenten identificeren met behulp van de methode Compare – Dit is vergelijkbaar met de functie Microsoft Word document vergelijken. Hiermee kunt u documenten of documentversies controleren om verschillen en wijzigingen te vinden, inclusief opmaakwijzigingen zoals lettertypewijzigingen, spatiëringwijzigingen, het toevoegen van woorden en alinea ' s.

Als gevolg van de vergelijking kunnen documenten als gelijk of niet gelijk worden bepaald. De term" gelijke " documenten betekent dat de vergelijkingsmethode niet in staat is om wijzigingen als herzieningen weer te geven. Dit betekent dat zowel documenttekst als tekstopmaak hetzelfde zijn. Maar er kunnen andere verschillen zijn tussen documenten. Microsoft Word ondersteunt bijvoorbeeld alleen opmaakherzieningen voor stijlen en u kunt geen stijlinvoeging/ - verwijdering weergeven. Documenten kunnen dus een andere set stijlen hebben en de methode Compare produceert nog steeds geen herzieningen.

Het volgende codevoorbeeld laat zien hoe u kunt 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-C
System::SharedPtr<Document> docA = System::MakeObject<Document>(inputDataDir + u"TestFile.doc");
System::SharedPtr<Document> docB = System::MakeObject<Document>(inputDataDir + u"TestFile - Copy.doc");
// DocA now contains changes as revisions. 
docA->Compare(docB, u"user", System::DateTime::get_Now());
if (docA->get_Revisions()->get_Count() == 0)
{
    std::cout << "Documents are equal" << std::endl;
}
else
{
    std::cout << "Documents are not equal" << std::endl;
}

Het volgende codevoorbeeld laat zien hoe u de methode Compare eenvoudig toepast op twee documenten:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// The source document doc1
System::SharedPtr<Document> doc1 = System::MakeObject<Document>();
System::SharedPtr<DocumentBuilder> builder = System::MakeObject<DocumentBuilder>(doc1);
builder->Writeln(u"This is the original document.");

// The target document doc2
System::SharedPtr<Document> doc2 = System::MakeObject<Document>();
builder = System::MakeObject<DocumentBuilder>(doc2);
builder->Writeln(u"This is the edited document.");

// If either document has a revision, an exception will be thrown
if (doc1->get_Revisions()->get_Count() == 0 && doc2->get_Revisions()->get_Count() == 0)
    doc1->Compare(doc2, u"authorName", System::DateTime::get_Now());

// If doc1 and doc2 are different, doc1 now has some revisions after the comparison, which can now be viewed and processed
if (doc1->get_Revisions()->get_Count() == 2)
    std::cout << "Documents are equal." << std::endl << std::endl;

for (System::SharedPtr<Revision> r : System::IterateOver(doc1->get_Revisions()))
{
    std::cout << "Revision type: " << System::ObjectExt::ToString(r->get_RevisionType()).ToUtf8String() 
        << ", on a node of type " << System::ObjectExt::ToString(r->get_ParentNode()->get_NodeType()).ToUtf8String() << std::endl;
    std::cout << "Changed text: " << r->get_ParentNode()->GetText() << std::endl;
}

// All the revisions in doc1 are differences between doc1 and doc2, so accepting them on doc1 transforms doc1 into doc2
doc1->get_Revisions()->AcceptAll();

// doc1, when saved, now resembles doc2
doc1->Save(inputDataDir + u"Document.Compare.docx");
doc1 = System::MakeObject<Document>(inputDataDir + u"Document.Compare.docx");

if (doc1->get_Revisions()->get_Count() == 0)
    std::cout << "Documents are equal" << std::endl;

if (doc2->GetText().Trim() == doc1->GetText().Trim())
    std::cout << "Documents are equal" << std::endl;

Geef Geavanceerde Vergelijkingsopties {#specify-advanced-comparing-properties}Op

Er zijn veel verschillende eigenschappen van de klasse CompareOptions die u kunt toepassen wanneer u documenten wilt vergelijken.

Met Aspose.Words kunt u bijvoorbeeld wijzigingen negeren die zijn aangebracht tijdens een vergelijkingsbewerking voor bepaalde typen objecten in het oorspronkelijke document. U kunt de juiste eigenschap voor het objecttype selecteren, zoals IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, en anderen door ze op “waar"te zetten.

Daarnaast biedt Aspose.Words de eigenschap Granularity waarmee u kunt opgeven of u wijzigingen per teken of per woord wilt bijhouden.

Een andere gemeenschappelijke eigenschap is een keuze in welk document vergelijkingswijzigingen worden weergegeven. Het dialoogvenster “documenten vergelijken” in Microsoft Word heeft bijvoorbeeld de optie “Wijzigingen Weergeven in” – dit heeft ook invloed op de vergelijkingsresultaten. Aspose.Words geeft de Target eigenschap die dit doel dient.

Het volgende codevoorbeeld laat zien hoe u de geavanceerde vergelijkingseigenschappen instelt:

For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C
// Create the original document
System::SharedPtr<Document> docOriginal = System::MakeObject<Document>();
System::SharedPtr<DocumentBuilder> builder = System::MakeObject<DocumentBuilder>(docOriginal);

// Insert paragraph text with an endnote
builder->Writeln(u"Hello world! This is the first paragraph.");
builder->InsertFootnote(FootnoteType::Endnote, u"Original endnote text.");

// Insert a table
builder->StartTable();
builder->InsertCell();
builder->Write(u"Original cell 1 text");
builder->InsertCell();
builder->Write(u"Original cell 2 text");
builder->EndTable();

// Insert a textbox
System::SharedPtr<Shape> textBox = builder->InsertShape(ShapeType::TextBox, 150, 20);
builder->MoveTo(textBox->get_FirstParagraph());
builder->Write(u"Original textbox contents");

// Insert a DATE field
builder->MoveTo(docOriginal->get_FirstSection()->get_Body()->AppendParagraph(u""));
builder->InsertField(u" DATE ");

// Insert a comment
auto newComment = System::MakeObject<Comment>(docOriginal, u"John Doe", u"J.D.", System::DateTime::get_Now());
newComment->SetText(u"Original comment.");
builder->get_CurrentParagraph()->AppendChild(newComment);

// Insert a header
builder->MoveToHeaderFooter(Aspose::Words::HeaderFooterType::HeaderPrimary);
builder->Writeln(u"Original header contents.");

// Create a clone of our document, which we will edit and later compare to the original
auto docEdited = System::DynamicCast<Aspose::Words::Document>(System::StaticCast<Node>(docOriginal)->Clone(true));
System::SharedPtr<Paragraph> firstParagraph = docEdited->get_FirstSection()->get_Body()->get_FirstParagraph();

// Change the formatting of the first paragraph, change casing of original characters and add text
firstParagraph->get_Runs()->idx_get(0)->set_Text(u"hello world! this is the first paragraph, after editing.");
firstParagraph->get_ParagraphFormat()->set_Style(docEdited->get_Styles()->idx_get(Aspose::Words::StyleIdentifier::Heading1));

// Edit the footnote
auto footnote = System::DynamicCast<Aspose::Words::Footnote>(docEdited->GetChild(Aspose::Words::NodeType::Footnote, 0, true));
footnote->get_FirstParagraph()->get_Runs()->idx_get(1)->set_Text(u"Edited endnote text.");

// Edit the table
auto table = System::DynamicCast<Aspose::Words::Tables::Table>(docEdited->GetChild(Aspose::Words::NodeType::Table, 0, true));
table->get_FirstRow()->get_Cells()->idx_get(1)->get_FirstParagraph()->get_Runs()->idx_get(0)->set_Text(u"Edited Cell 2 contents");

// Edit the textbox
textBox = System::DynamicCast<Aspose::Words::Drawing::Shape>(docEdited->GetChild(Aspose::Words::NodeType::Shape, 0, true));
textBox->get_FirstParagraph()->get_Runs()->idx_get(0)->set_Text(u"Edited textbox contents");

// Edit the DATE field
auto fieldDate = System::DynamicCast<Aspose::Words::Fields::FieldDate>(docEdited->get_Range()->get_Fields()->idx_get(0));
fieldDate->set_UseLunarCalendar(true);

// Edit the comment
auto comment = System::DynamicCast<Aspose::Words::Comment>(docEdited->GetChild(Aspose::Words::NodeType::Comment, 0, true));
comment->get_FirstParagraph()->get_Runs()->idx_get(0)->set_Text(u"Edited comment.");

// Edit the header
docEdited->get_FirstSection()->get_HeadersFooters()->idx_get(Aspose::Words::HeaderFooterType::HeaderPrimary)->get_FirstParagraph()->get_Runs()->idx_get(0)->set_Text(u"Edited header contents.");

// When we compare documents, the differences of the latter document from the former show up as revisions to the former
// Each edit that we've made above will have its own revision, after we run the Compare method
// We can compare with a CompareOptions object, which can suppress changes done to certain types of objects within the original document
// from registering as revisions after the comparison by setting some of these members to "true"
auto compareOptions = System::MakeObject<Aspose::Words::CompareOptions>();
compareOptions->set_IgnoreFormatting(false);
compareOptions->set_IgnoreCaseChanges(false);
compareOptions->set_IgnoreComments(false);
compareOptions->set_IgnoreTables(false);
compareOptions->set_IgnoreFields(false);
compareOptions->set_IgnoreFootnotes(false);
compareOptions->set_IgnoreTextboxes(false);
compareOptions->set_IgnoreHeadersAndFooters(false);
compareOptions->set_Target(Aspose::Words::ComparisonTargetType::New);

docOriginal->Compare(docEdited, u"John Doe", System::DateTime::get_Now(), compareOptions);
docOriginal->Save(inputDataDir + u"Document.CompareOptions.docx");