Porównaj Dokumenty

Porównywanie dokumentów to proces, który identyfikuje zmiany między dwoma dokumentami i zawiera zmiany jako poprawki. Ten proces porównuje dowolne dwa dokumenty, w tym wersje jednego konkretnego dokumentu, a zmiany między obydwoma dokumentami zostaną pokazane jako poprawki w pierwszym dokumencie.

Metodę porównania uzyskuje się poprzez porównanie słów na poziomie znaków lub na poziomie słów. Jeśli słowo zawiera zmianę co najmniej jednego znaku, w wyniku różnica zostanie wyświetlona jako zmiana całego słowa, a nie znaku. Ten proces porównywania jest zwykłym zadaniem w branży prawnej i finansowej.

Zamiast ręcznego wyszukiwania różnic między dokumentami lub między różnymi ich wersjami, możesz użyć Aspose.Words do porównywania dokumentów i uzyskiwania zmian treści w formatowaniu, nagłówku/stopce, tabelach i innych.

W tym artykule wyjaśniono, jak porównywać dokumenty i jak określić zaawansowane właściwości porównywania.

Spróbuj online

Możesz porównać dwa dokumenty online, korzystając z Porównanie dokumentów online narzędzie.

Zauważ, że metoda porównania, opisana poniżej, jest używana w tym narzędziu, aby zapewnić uzyskanie równych wyników. Dzięki temu uzyskasz te same wyniki nawet za pomocą narzędzia do porównywania online lub metody porównywania w Aspose.Words.

Ograniczenia i Obsługiwane formaty plików

Porównywanie dokumentów to bardzo złożona funkcja. Istnieją różne części kombinacji treści, które należy przeanalizować, aby rozpoznać wszystkie różnice. Przyczyną tej złożoności jest fakt, że Aspose.Words ma na celu uzyskanie takich samych wyników porównania, jak algorytm porównania Microsoft Word.

Ogólne ograniczenie dla dwóch porównywanych dokumentów polega na tym, że nie mogą one mieć poprawek przed wywołaniem metody porównania, ponieważ to ograniczenie istnieje w Microsoft Word.

Pamiętaj, że możesz porównać dowolne dwa dokumenty w ramach obsługiwane formaty plików. Możesz porównywać obiekty dokumentu, a nawet tworzyć te obiekty od zera bez żadnego określonego formatu.

Porównaj Dwa Dokumenty

Kiedy porównujesz dokumenty, różnice między tym drugim dokumentem a pierwszym pojawiają się jako poprawki do pierwszego. Po zmodyfikowaniu dokumentu każda edycja będzie miała własną wersję po uruchomieniu metody porównywania.

Aspose.Words umożliwia identyfikację różnic dokumentów za pomocą metody Compare – jest to podobne do funkcji porównywania dokumentów Microsoft Word. Umożliwia sprawdzanie dokumentów lub wersji dokumentów w celu znalezienia różnic i zmian, w tym modyfikacji formatowania, takich jak zmiany czcionek, zmiany odstępów, dodawanie słów i akapitów.

W wyniku porównania dokumenty można określić jako równe lub nie równe. Termin “równe” dokumenty oznacza, że metoda porównania nie jest w stanie przedstawić zmian jako poprawek. Oznacza to, że zarówno tekst dokumentu, jak i formatowanie tekstu są takie same. Ale mogą istnieć inne różnice między dokumentami. Na przykład Microsoft Word obsługuje tylko wersje formatu stylów i nie można reprezentować wstawiania/usuwania stylu. Tak więc dokumenty mogą mieć inny zestaw stylów, a metoda Compare nadal nie generuje żadnych poprawek.

Poniższy przykład kodu pokazuje, jak sprawdzić, czy dwa dokumenty są równe, czy nie:

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;
}

Poniższy przykład kodu pokazuje, jak po prostu zastosować metodę Compare do dwóch dokumentów:

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;

Określ Zaawansowane Opcje Porównania

Istnieje wiele różnych właściwości klasy CompareOptions, które można zastosować, gdy chcesz porównać dokumenty.

Na przykład Aspose.Words pozwala zignorować zmiany wprowadzone podczas operacji porównania dla niektórych typów obiektów w oryginalnym dokumencie. Możesz wybrać odpowiednią właściwość dla typu obiektu, na przykład IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, i innych, ustawiając je na “prawdziwe”.

Ponadto Aspose.Words zapewnia Właściwość Granularity, za pomocą której można określić, czy śledzić zmiany według znaku, czy słowa.

Inną wspólną właściwością jest wybór, w którym dokumencie pokazać zmiany porównania. Na przykład okno dialogowe " Porównaj dokumenty “w Microsoft Word ma opcję” Pokaż zmiany w " – wpływa to również na wyniki porównania. Aspose.Words zapewnia Właściwość Target, która służy temu celowi.

Poniższy przykład kodu pokazuje, jak ustawić zaawansowane właściwości porównywania:

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