Porównaj dokumenty
Porównywanie dokumentów to proces, który identyfikuje zmiany między dwoma dokumentami i traktuje zmiany jako poprawki. W procesie tym porównywane są dowolne dwa dokumenty, w tym wersje jednego konkretnego dokumentu, a następnie zmiany między obydwoma dokumentami zostaną pokazane jako poprawki w pierwszym dokumencie.
Metodę porównania osiąga się poprzez porównywanie słów na poziomie znaku lub na poziomie słowa. Jeśli słowo zawiera zmianę przynajmniej jednego znaku, w rezultacie różnica zostanie wyświetlona jako zmiana całego słowa, a nie znaku. Ten proces porównywania jest typowym zadaniem w branży prawniczej i finansowej.
Zamiast ręcznie wyszukiwać różnice między dokumentami lub między ich różnymi wersjami, możesz użyć Aspose.Words do porównywania dokumentów i uzyskiwania zmian w treści w formatowaniu, nagłówku/stopce, tabelach i nie tylko.
W tym artykule wyjaśniono, jak porównywać dokumenty i jak określać zaawansowane właściwości porównywania.
Spróbuj online
Możesz porównać dwa dokumenty online, korzystając z narzędzia Porównanie dokumentów online.
Należy pamiętać, że w tym narzędziu zastosowano metodę porównania opisaną poniżej, aby zapewnić uzyskanie jednakowych wyników. Dzięki temu takie same wyniki uzyskasz nawet korzystając z porównywarki online lub metody porównawczej 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. Powodem 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 dotyczące dwóch porównywanych dokumentów polega na tym, że przed wywołaniem metody porównywania nie można w nich wprowadzać poprawek, ponieważ takie ograniczenie istnieje w Microsoft Word.
Porównaj dwa dokumenty
Kiedy porównujesz dokumenty, różnice między drugim dokumentem a pierwszym ukazują się jako poprawki do pierwszego. Kiedy modyfikujesz dokument, każda edycja będzie miała własną wersję po uruchomieniu metody porównania.
Aspose.Words umożliwia identyfikację różnic w dokumentach za pomocą metody Compare – jest to podobne do funkcji porównywania dokumentów Microsoft Word. Umożliwia sprawdzanie dokumentów lub wersji dokumentów pod kątem różnic i zmian, w tym modyfikacji formatowania, takich jak zmiany czcionki, zmiany odstępów, dodanie słów i akapitów.
W wyniku porównania dokumenty można określić jako równe lub nierówne. Termin “równe” dokumenty oznacza, że metoda porównawcza nie jest w stanie przedstawić zmian jako poprawek. Oznacza to, że zarówno tekst dokumentu, jak i formatowanie tekstu są takie same. Pomiędzy dokumentami mogą jednak występować inne różnice. Na przykład Microsoft Word obsługuje tylko wersje formatu stylów i nie można reprezentować wstawiania/usuwania stylu. Dlatego 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-.NET | |
Document docA = new Document(dataDir + "TestFile.doc"); | |
Document docB = new Document(dataDir + "TestFile - Copy.doc"); | |
// DocA now contains changes as revisions. | |
docA.Compare(docB, "user", DateTime.Now); | |
if (docA.Revisions.Count == 0) | |
Console.WriteLine("Documents are equal"); | |
else | |
Console.WriteLine("Documents are not equal"); |
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-.NET | |
// 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.Revisions.Count == 0 && doc2.Revisions.Count == 0) | |
doc1.Compare(doc2, "authorName", DateTime.Now); | |
// If doc1 and doc2 are different, doc1 now has some revisions after the comparison, which can now be viewed and processed. | |
Assert.AreEqual(2, doc1.Revisions.Count); | |
foreach (Revision r in doc1.Revisions) | |
{ | |
Console.WriteLine($"Revision type: {r.RevisionType}, on a node of type \"{r.ParentNode.NodeType}\""); | |
Console.WriteLine($"\tChanged text: \"{r.ParentNode.GetText()}\""); | |
} | |
// All the revisions in doc1 are differences between doc1 and doc2, so accepting them on doc1 transforms doc1 into doc2. | |
doc1.Revisions.AcceptAll(); | |
// doc1, when saved, now resembles doc2. | |
doc1.Save(dataDir + "Document.Compare.docx"); | |
doc1 = new Document(dataDir + "Document.Compare.docx"); | |
Assert.AreEqual(0, doc1.Revisions.Count); | |
Assert.AreEqual(doc2.GetText().Trim(), doc1.GetText().Trim()); |
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ównywania dla niektórych typów obiektów w oryginalnym dokumencie. Możesz wybrać odpowiednią właściwość dla typu obiektu, taką jak IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments i inne, ustawiając je na “true”.
Dodatkowo Aspose.Words udostępnia właściwość Granularity, za pomocą której można określić, czy zmiany mają być śledzone po znaku, czy po słowie.
Inną wspólną właściwością jest wybór, w którym dokumencie mają być pokazane zmiany porównawcze. Przykładowo w oknie dialogowym “Porównaj dokumenty” w Microsoft Word dostępna jest opcja “Pokaż zmiany w” – ma to również wpływ na wyniki porównania. Aspose.Words udostępnia 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-.NET | |
// 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.TextBox, 150, 20); | |
builder.MoveTo(textBox.FirstParagraph); | |
builder.Write("Original textbox contents"); | |
// Insert a DATE field. | |
builder.MoveTo(docOriginal.FirstSection.Body.AppendParagraph("")); | |
builder.InsertField(" DATE "); | |
// Insert a comment. | |
Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", DateTime.Now); | |
newComment.SetText("Original comment."); | |
builder.CurrentParagraph.AppendChild(newComment); | |
// Insert a header. | |
builder.MoveToHeaderFooter(HeaderFooterType.HeaderPrimary); | |
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.Clone(true); | |
Paragraph firstParagraph = docEdited.FirstSection.Body.FirstParagraph; | |
// Change the formatting of the first paragraph, change casing of original characters and add text. | |
firstParagraph.Runs[0].Text = "hello world! this is the first paragraph, after editing."; | |
firstParagraph.ParagraphFormat.Style = docEdited.Styles[StyleIdentifier.Heading1]; | |
// Edit the footnote. | |
Footnote footnote = (Footnote)docEdited.GetChild(NodeType.Footnote, 0, true); | |
footnote.FirstParagraph.Runs[1].Text = "Edited endnote text."; | |
// Edit the table. | |
Table table = (Table)docEdited.GetChild(NodeType.Table, 0, true); | |
table.FirstRow.Cells[1].FirstParagraph.Runs[0].Text = "Edited Cell 2 contents"; | |
// Edit the textbox. | |
textBox = (Shape)docEdited.GetChild(NodeType.Shape, 0, true); | |
textBox.FirstParagraph.Runs[0].Text = "Edited textbox contents"; | |
// Edit the DATE field. | |
FieldDate fieldDate = (FieldDate)docEdited.Range.Fields[0]; | |
fieldDate.UseLunarCalendar = true; | |
// Edit the comment. | |
Comment comment = (Comment)docEdited.GetChild(NodeType.Comment, 0, true); | |
comment.FirstParagraph.Runs[0].Text = "Edited comment."; | |
// Edit the header. | |
docEdited.FirstSection.HeadersFooters[HeaderFooterType.HeaderPrimary].FirstParagraph.Runs[0].Text = "Edited header contents."; | |
// Apply different comparing options. | |
CompareOptions compareOptions = new CompareOptions(); | |
compareOptions.IgnoreFormatting = false; | |
compareOptions.IgnoreCaseChanges = false; | |
compareOptions.IgnoreComments = false; | |
compareOptions.IgnoreTables = false; | |
compareOptions.IgnoreFields = false; | |
compareOptions.IgnoreFootnotes = false; | |
compareOptions.IgnoreTextboxes = false; | |
compareOptions.IgnoreHeadersAndFooters = false; | |
compareOptions.Target = ComparisonTargetType.New; | |
// compare both documents. | |
docOriginal.Compare(docEdited, "John Doe", DateTime.Now, compareOptions); | |
docOriginal.Save(dataDir + "Document.CompareOptions.docx"); | |
docOriginal = new Document(dataDir + "Document.CompareOptions.docx"); | |
// If you set compareOptions to ignore certain types of changes, | |
// then revisions done on those types of nodes will not appear in the output document. | |
// You can tell what kind of node a revision was done on by looking at the NodeType of the revision's parent nodes. | |
Assert.AreNotEqual(compareOptions.IgnoreFormatting, docOriginal.Revisions.Any(rev => rev.RevisionType == RevisionType.FormatChange)); | |
Assert.AreNotEqual(compareOptions.IgnoreCaseChanges, docOriginal.Revisions.Any(s => s.ParentNode.GetText().Contains("hello"))); | |
Assert.AreNotEqual(compareOptions.IgnoreComments, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.Comment))); | |
Assert.AreNotEqual(compareOptions.IgnoreTables, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.Table))); | |
Assert.AreNotEqual(compareOptions.IgnoreFields, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.FieldStart))); | |
Assert.AreNotEqual(compareOptions.IgnoreFootnotes, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.Footnote))); | |
Assert.AreNotEqual(compareOptions.IgnoreTextboxes, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.Shape))); | |
Assert.AreNotEqual(compareOptions.IgnoreHeadersAndFooters, docOriginal.Revisions.Any(rev => HasParentOfType(rev, NodeType.HeaderFooter))); |