השוואת מסמכים

השוואת מסמכים היא תהליך שמזהה שינויים בין שני מסמכים ומכיל את השינויים כתיקונים. תהליך זה משווה בין שני מסמכים, כולל גרסאות של מסמך ספציפי אחד, ואז השינויים בין שני המסמכים יוצגו כתיקונים במסמך הראשון.

שיטת ההשוואה מושגת על ידי השוואת מילים ברמת התו או ברמת המילה. אם מילה מכילה שינוי של תו אחד לפחות, בתוצאה, ההבדל יוצג כשינוי של המילה כולה, לא תו. תהליך השוואה זה הוא משימה רגילה בענפים המשפטיים והפיננסיים.

במקום לחפש באופן ידני הבדלים בין מסמכים או בין גרסאות שונות שלהם, אתה יכול להשתמש Aspose.Words להשוואת מסמכים ולקבל שינויים בתוכן בעיצוב, כותרת עליונה/תחתונה, טבלאות ועוד.

מאמר זה מסביר כיצד להשוות מסמכים וכיצד לציין מאפייני השוואה מתקדמים.

נסה באינטרנט

ניתן להשוות בין שני מסמכים באופן מקוון באמצעות השוואת מסמכים באינטרנט כלי.

שים לב ששיטת ההשוואה, המתוארת להלן, משמשת בכלי זה כדי להבטיח קבלת תוצאות שוות. כך תקבלו את אותן תוצאות גם באמצעות כלי ההשוואה המקוון או באמצעות שיטת ההשוואה ב Aspose.Words.

מגבלות ותבניות קבצים נתמכות

השוואת מסמכים היא תכונה מורכבת מאוד. ישנם חלקים מגוונים של שילוב תוכן שצריך לנתח כדי לזהות את כל ההבדלים. הסיבה למורכבות זו נובעת מהעובדה ש Aspose.Words שואף להשיג את אותן תוצאות השוואה כמו אלגוריתם ההשוואה Microsoft Word.

המגבלה הכללית לשני מסמכים שנשווים היא שאסור להם לבצע שינויים לפני שהם קוראים לשיטת ההשוואה, שכן המגבלה הזו קיימת ב - Microsoft Word.

שים לב שאתה יכול להשוות כל שני מסמכים בתוך פורמטים של קבצים נתמכים. אתה יכול להשוות אובייקטים של מסמכים ואפילו אתה יכול ליצור אובייקטים אלה מאפס מבלי שיהיה לך פורמט ספציפי.

השווה בין שני מסמכים

כאשר אתה משווה מסמכים, ההבדלים של המסמך האחרון מהראשון מופיעים כתיקונים לראשון. בעת שינוי מסמך, לכל עריכה תהיה גרסה משלה לאחר הפעלת שיטת ההשוואה.

Aspose.Words מאפשר לך לזהות הבדלי מסמכים באמצעות שיטת Compare - זה דומה לתכונה Microsoft Word השוואת מסמכים. זה מאפשר לך לבדוק מסמכים או גרסאות מסמכים כדי למצוא הבדלים ושינויים, כולל שינויי עיצוב כגון שינויי גופן, שינויי ריווח, הוספת מילים ופסקאות.

כתוצאה מההשוואה, ניתן לקבוע מסמכים כשווים או לא שווים. המונח מסמכים “שווים” פירושו ששיטת ההשוואה אינה מסוגלת לייצג שינויים כתיקונים. המשמעות היא שגם טקסט המסמך וגם עיצוב הטקסט זהים. אבל יכולים להיות הבדלים אחרים בין מסמכים. לדוגמה, Microsoft Word תומך רק בתיקונים בפורמט עבור סגנונות, ואינך יכול לייצג הכנסת / מחיקה של סגנון. אז מסמכים יכולים להיות קבוצה שונה של סגנונות, ושיטת Compare עדיין לא מייצרת שינויים.

דוגמת הקוד הבאה מראה כיצד לבדוק אם שני מסמכים שווים או לא:

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

דוגמת הקוד הבאה מראה כיצד פשוט ליישם את שיטת Compare לשני מסמכים:

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;

ציין אפשרויות השוואה מתקדמות

ישנם מאפיינים רבים ושונים של הכיתה CompareOptions שניתן להחיל כאשר ברצונך להשוות מסמכים.

לדוגמה, Aspose.Words מאפשר לך להתעלם משינויים שבוצעו במהלך פעולת השוואה עבור סוגים מסוימים של אובייקטים במסמך המקורי. באפשרותך לבחור את המאפיין המתאים לסוג האובייקט, כגון IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, ואחרים על ידי הגדרת אותם “נכון”.

בנוסף, Aspose.Words מספק את המאפיין Granularity שבעזרתו ניתן לציין אם לעקוב אחר שינויים לפי תו או לפי מילה.

מאפיין משותף נוסף הוא בחירה באיזה מסמך להציג שינויים בהשוואה. לדוגמה, בתיבת הדו – שיח" השווה מסמכים “ב Microsoft Word יש את האפשרות” הצג שינויים ב " - זה משפיע גם על תוצאות ההשוואה. Aspose.Words מספק את המאפיין Target שמשרת מטרה זו.

דוגמת הקוד הבאה מראה כיצד להגדיר את מאפייני ההשוואה המתקדמים:

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