Comparar Documentos

A comparação de documentos é um processo que identifica as alterações entre dois documentos e contém as alterações como revisões. Este processo compara quaisquer dois documentos, incluindo versões de um documento específico, e as alterações entre ambos os documentos serão apresentadas como revisões no primeiro documento.

O método de comparação é obtido comparando palavras no nível do caractere ou no nível da palavra. Se uma palavra contiver uma mudança de pelo menos um caractere, no resultado, a diferença será exibida como uma mudança da palavra inteira, não como um caractere. Este processo de comparação é uma tarefa habitual nos sectores jurídico e financeiro.

Em vez de procurar manualmente diferenças entre documentos ou entre diferentes versões deles, pode utilizar Aspose.Words para comparar documentos e obter alterações de conteúdo na formatação, cabeçalho/rodapé, tabelas e muito mais.

Este artigo explica como comparar documentos e como especificar propriedades de comparação avançadas.

Experimente online

Você pode comparar dois documentos on-line usando o Comparação de documentos online ferramenta.

Note-se que o método de comparação, descrito a seguir, é utilizado nesta ferramenta para garantir a obtenção de resultados iguais. Assim, você obterá os mesmos resultados, mesmo usando a ferramenta de comparação on-line ou usando o método de comparação em Aspose.Words.

Limitações e formatos de ficheiro suportados

A comparação de documentos é uma característica muito complexa. Existem várias partes da combinação de conteúdo que precisam ser analisadas para reconhecer todas as diferenças. A razão para esta complexidade deve-se ao facto de Aspose.Words Ter como objectivo obter os mesmos resultados de comparação que o algoritmo de comparação Microsoft Word.

A limitação geral para dois documentos que estão a ser comparados é que eles não devem ter revisões antes de chamar o método compare, uma vez que esta limitação existe em Microsoft Word.

Observe que você pode comparar quaisquer dois documentos dentro do formatos de ficheiro suportados. Você pode comparar objetos de documento e até mesmo criar esses objetos do zero sem ter nenhum formato específico.

Comparar Dois Documentos

Quando se compara documentos, as diferenças entre o último documento e o primeiro aparecem como revisões do primeiro. Ao modificar um documento, cada edição terá a sua própria revisão depois de executar o método de comparação.

Aspose.Words permite identificar diferenças de documentos utilizando o método Compare – isto é semelhante à funcionalidade de comparação de documentos Microsoft Word. Ele permite que você verifique documentos ou versões de documentos para encontrar diferenças e alterações, incluindo modificações de formatação, como alterações de fonte, alterações de espaçamento, adição de palavras e parágrafos.

Como resultado da comparação, os documentos podem ser determinados como iguais ou não iguais. O termo documentos “iguais” significa que o método de comparação não é capaz de representar alterações como revisões. Isso significa que tanto o texto do documento quanto a formatação do texto são iguais. Mas pode haver outras diferenças entre os documentos. Por exemplo, Microsoft Word suporta apenas revisões de formato para estilos e não pode representar a inserção/eliminação de estilos. Portanto, os documentos podem ter um conjunto diferente de estilos e o método Compare ainda não produz revisões.

O exemplo de código a seguir mostra como verificar se dois documentos são iguais ou não:

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

O exemplo de código a seguir mostra como simplesmente aplicar o método Compare a dois documentos:

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;

Especificar Opções Avançadas De Comparação

Existem muitas propriedades diferentes da classe CompareOptions que pode aplicar quando pretender comparar documentos.

Por exemplo, Aspose.Words permite ignorar alterações feitas durante uma operação de comparação para determinados tipos de objetos no documento original. Você pode selecionar a propriedade apropriada para o tipo de objeto, como IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, e outros, definindo-os como"verdadeiros".

Além disso, Aspose.Words fornece a propriedade Granularity com a qual você pode especificar se deseja rastrear alterações por caractere ou por palavra.

Outra propriedade comum é a escolha de qual documento mostrar as alterações de comparação. Por exemplo, a caixa de diálogo “comparar documentos” em Microsoft Word tem a opção “Mostrar alterações em” – isso também afeta os resultados da comparação. Aspose.Words fornece a propriedade Target que serve a esse propósito.

O exemplo de código a seguir mostra como definir as propriedades de comparação avançadas:

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