Confronta documenti

Il confronto dei documenti è un processo che identifica le modifiche tra due documenti e contiene le modifiche come revisioni. Questo processo confronta due documenti, incluse le versioni di un documento specifico, quindi le modifiche tra entrambi i documenti verranno visualizzate come revisioni nel primo documento.

Il metodo di confronto si ottiene confrontando le parole a livello di carattere o a livello di parola. Se una parola contiene una modifica di almeno un carattere, nel risultato, la differenza verrà visualizzata come una modifica dell’intera parola, non come un carattere. Questo processo di confronto è un compito abituale nel settore legale e finanziario.

Invece di cercare manualmente le differenze tra i documenti o tra le diverse versioni di essi, è possibile utilizzare Aspose.Words per confrontare i documenti e ottenere modifiche al contenuto in formattazione, intestazione/piè di pagina, tabelle e altro ancora.

Questo articolo spiega come confrontare i documenti e come specificare le proprietà di confronto avanzate.

Prova online

È possibile confrontare due documenti online utilizzando il Confronto documenti online strumento.

Si noti che il metodo di confronto, descritto di seguito, viene utilizzato in questo strumento per garantire risultati uguali. Quindi otterrai gli stessi risultati anche utilizzando lo strumento di confronto online o utilizzando il metodo di confronto in Aspose.Words.

Limitazioni e formati di file supportati

Confrontare i documenti è una caratteristica molto complessa. Ci sono varie parti della combinazione di contenuti che devono essere analizzate per riconoscere tutte le differenze. La ragione di questa complessità è dovuta al fatto che Aspose.Words mira a ottenere gli stessi risultati di confronto dell’algoritmo di confronto Microsoft Word.

La limitazione generale per due documenti che vengono confrontati è che non devono avere revisioni prima di chiamare il metodo di confronto poiché questa limitazione esiste in Microsoft Word.

Si noti che è possibile confrontare due documenti qualsiasi all’interno del formati di file supportati. È possibile confrontare gli oggetti del documento e anche è possibile creare tali oggetti da zero senza avere alcun formato specifico.

Confronta due documenti

Quando si confrontano i documenti, le differenze di quest’ultimo documento rispetto al primo vengono visualizzate come revisioni al primo. Quando si modifica un documento, ogni modifica avrà una propria revisione dopo aver eseguito il metodo di confronto.

Aspose.Words consente di identificare le differenze dei documenti utilizzando il metodo Compare, simile alla funzione di confronto dei documenti Microsoft Word. Esso consente di controllare i documenti o le versioni dei documenti per trovare le differenze e le modifiche, comprese le modifiche di formattazione come le modifiche dei caratteri, le modifiche di spaziatura, l’aggiunta di parole e paragrafi.

Come risultato del confronto, i documenti possono essere determinati come uguali o non uguali. Il termine documenti" uguali " significa che il metodo di confronto non è in grado di rappresentare le modifiche come revisioni. Ciò significa che sia il testo del documento che la formattazione del testo sono uguali. Ma ci possono essere altre differenze tra i documenti. Ad esempio, Microsoft Word supporta solo le revisioni del formato per gli stili e non è possibile rappresentare l’inserimento/l’eliminazione degli stili. Quindi i documenti possono avere un diverso insieme di stili e il metodo Compare non produce ancora revisioni.

Il seguente esempio di codice mostra come verificare se due documenti sono uguali o meno:

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

Il seguente esempio di codice mostra come applicare semplicemente il metodo Compare a due documenti:

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;

Specificare opzioni di confronto avanzate

Esistono molte proprietà diverse della classe CompareOptions che è possibile applicare quando si desidera confrontare i documenti.

Ad esempio, Aspose.Words consente di ignorare le modifiche apportate durante un’operazione di confronto per determinati tipi di oggetti all’interno del documento originale. È possibile selezionare la proprietà appropriata per il tipo di oggetto, ad esempio IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, e altri impostandoli su “vero”.

Inoltre, Aspose.Words fornisce la proprietà Granularity con cui è possibile specificare se tenere traccia delle modifiche per carattere o per parola.

Un’altra proprietà comune è una scelta in quale documento mostrare le modifiche di confronto. Ad esempio, la" Finestra di dialogo Confronta documenti “in Microsoft Word ha l’opzione” Mostra modifiche in " - questo influisce anche sui risultati del confronto. Aspose.Words fornisce la proprietà Target che serve a questo scopo.

L’esempio di codice seguente mostra come impostare le proprietà di confronto avanzate:

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