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à è perché 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. Fondamentalmente, puoi confrontare gli oggetti del documento e persino creare quegli 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-Java
Document docA = new Document(dataDir + "DocumentA.doc");
Document docB = new Document(dataDir + "DocumentB.doc");
docA.compare(docB, "user", new Date());
if (docA.getRevisions().getCount() == 0)
	System.out.println("Documents are equal");
else
	System.out.println("Documents are not equal");

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-Java
// 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.getRevisions().getCount() == 0 && doc2.getRevisions().getCount() == 0)
	doc1.compare(doc2, "authorName", new Date());

// If doc1 and doc2 are different, doc1 now has some revisions after the comparison, which can now be viewed and processed
if (doc1.getRevisions().getCount() == 2)
	System.out.println("Documents are equal");
		
for (Revision r : doc1.getRevisions())
{
	System.out.println("Revision type: " + r.getRevisionType() + ", on a node of type " + r.getParentNode().getNodeType() + "");
	System.out.println("\tChanged text: " + r.getParentNode().getText() + "");
}

// All the revisions in doc1 are differences between doc1 and doc2, so accepting them on doc1 transforms doc1 into doc2
doc1.getRevisions().acceptAll();
		
// doc1, when saved, now resembles doc2
doc1.save(dataDir + "Document.Compare.docx");
doc1 = new Document(dataDir + "Document.Compare.docx");
		
if (doc1.getRevisions().getCount() == 0)
	System.out.println("Documents are equal");
		
if (doc2.getText().trim() == doc1.getText().trim())
	System.out.println("Documents are equal");

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-Java
// 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.TEXT_BOX, 150, 20);
builder.moveTo(textBox.getFirstParagraph());
builder.write("Original textbox contents");

// Insert a DATE field
builder.moveTo(docOriginal.getFirstSection().getBody().appendParagraph(""));
builder.insertField(" DATE ");

// Insert a comment
Comment newComment = new Comment(docOriginal, "John Doe", "J.D.", new Date());
newComment.setText("Original comment.");
builder.getCurrentParagraph().appendChild(newComment);

// Insert a header
builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY);
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.deepClone(true);
Paragraph firstParagraph = docEdited.getFirstSection().getBody().getFirstParagraph();

// Change the formatting of the first paragraph, change casing of original characters and add text
firstParagraph.getRuns().get(0).setText("hello world! this is the first paragraph, after editing.");
firstParagraph.getParagraphFormat().setStyle(docEdited.getStyles().get(StyleIdentifier.HEADING_1));
            
// Edit the footnote
Footnote footnote = (Footnote)docEdited.getChild(NodeType.FOOTNOTE, 0, true);
footnote.getFirstParagraph().getRuns().get(1).setText("Edited endnote text.");

// Edit the table
Table table = (Table)docEdited.getChild(NodeType.TABLE, 0, true);
table.getFirstRow().getCells().get(1).getFirstParagraph().getRuns().get(0).setText("Edited Cell 2 contents");

// Edit the textbox
textBox = (Shape)docEdited.getChild(NodeType.SHAPE, 0, true);
textBox.getFirstParagraph().getRuns().get(0).setText("Edited textbox contents");

// Edit the DATE field
FieldDate fieldDate = (FieldDate)docEdited.getRange().getFields().get(0);
fieldDate.setUseLunarCalendar(true);

// Edit the comment
Comment comment = (Comment)docEdited.getChild(NodeType.COMMENT, 0, true);
comment.getFirstParagraph().getRuns().get(0).setText("Edited comment.");

// Edit the header
docEdited.getFirstSection().getHeadersFooters().getByHeaderFooterType(HeaderFooterType.HEADER_PRIMARY).getFirstParagraph().getRuns().get(0).setText("Edited header contents.");

// Apply different comparing options
CompareOptions compareOptions = new CompareOptions();
compareOptions.setIgnoreFormatting(false);
compareOptions.setIgnoreCaseChanges(false);
compareOptions.setIgnoreComments(false);
compareOptions.setIgnoreTables(false);
compareOptions.setIgnoreFields(false);
compareOptions.setIgnoreFootnotes(false);
compareOptions.setIgnoreTextboxes(false);
compareOptions.setIgnoreHeadersAndFooters(false);
compareOptions.setTarget(ComparisonTargetType.NEW);

// compare both documents
docOriginal.compare(docEdited, "John Doe", new Date(), compareOptions);
docOriginal.save(dataDir + "Document.CompareOptions.docx");