Comparar Documentos
La comparación de documentos es un proceso que identifica los cambios entre dos documentos y contiene los cambios como revisiones. Este proceso compara dos documentos cualesquiera, incluidas las versiones de un documento específico, luego los cambios entre ambos documentos se mostrarán como revisiones en el primer documento.
El método de comparación se logra comparando palabras a nivel de carácter o a nivel de palabra. Si una palabra contiene un cambio de al menos un carácter, en el resultado, la diferencia se mostrará como un cambio de toda la palabra, no de un carácter. Este proceso de comparación es una tarea habitual en las industrias legal y financiera.
En lugar de buscar manualmente diferencias entre documentos o entre diferentes versiones de ellos, puede usar Aspose.Words para comparar documentos y obtener cambios de contenido en el formato, encabezado/pie de página, tablas y más.
En este artículo se explica cómo comparar documentos y cómo especificar propiedades de comparación avanzadas.
Pruébalo en línea
Puede comparar dos documentos en línea utilizando el Comparación de documentos en línea herramienta.
Tenga en cuenta que el método de comparación, que se describe a continuación, se utiliza en esta herramienta para garantizar la obtención de resultados iguales. Por lo tanto, obtendrá los mismos resultados incluso utilizando la herramienta de comparación en línea o utilizando el método de comparación en Aspose.Words.
Limitaciones y Formatos de Archivo Admitidos
Comparar documentos es una característica muy compleja. Hay varias partes de la combinación de contenido que deben analizarse para reconocer todas las diferencias. La razón de esta complejidad es porque Aspose.Words tiene como objetivo obtener los mismos resultados de comparación que el algoritmo de comparación Microsoft Word.
La limitación general para dos documentos que se comparan es que no deben tener revisiones antes de llamar al método compare, ya que esta limitación existe en Microsoft Word.
Comparar Dos Documentos
Cuando compara documentos, las diferencias entre el último documento y el primero se muestran como revisiones del primero. Cuando modifica un documento, cada edición tendrá su propia revisión después de ejecutar el método de comparación.
Aspose.Words le permite identificar diferencias en los documentos utilizando el método Compare; esto es similar a la función de comparación de documentos Microsoft Word. Le permite verificar documentos o versiones de documentos para encontrar diferencias y cambios, incluidas modificaciones de formato como cambios de fuente, cambios de espaciado, adición de palabras y párrafos.
Como resultado de la comparación, los documentos pueden determinarse como iguales o no iguales. El término documentos “iguales” significa que el método de comparación no puede representar los cambios como revisiones. Esto significa que tanto el texto del documento como el formato del texto son iguales. Pero puede haber otras diferencias entre documentos. Por ejemplo, Microsoft Word solo admite revisiones de formato para estilos y no puede representar la inserción/eliminación de estilos. Por lo tanto, los documentos pueden tener un conjunto diferente de estilos y el método Compare aún no produce revisiones.
El siguiente ejemplo de código muestra cómo verificar si dos documentos son iguales o no:
// 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"); |
El siguiente ejemplo de código muestra cómo aplicar simplemente el método Compare
a dos documentos:
// 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"); |
Especificar Opciones Avanzadas de Comparación
Hay muchas propiedades diferentes de la clase CompareOptions que puede aplicar cuando desee comparar documentos.
Por ejemplo, Aspose.Words le permite ignorar los cambios realizados durante una operación de comparación para ciertos tipos de objetos dentro del documento original. Puede seleccionar la propiedad adecuada para el tipo de objeto, como IgnoreHeadersAndFooters, IgnoreFormatting, IgnoreComments, y otros al establecerlos en “verdadero”.
Además, Aspose.Words proporciona la propiedad Granularity con la que puede especificar si desea realizar un seguimiento de los cambios por carácter o por palabra.
Otra propiedad común es elegir en qué documento mostrar los cambios de comparación. Por ejemplo, el " Cuadro de diálogo Comparar documentos “en Microsoft Word tiene la opción “Mostrar cambios en”; esto también afecta los resultados de la comparación – Aspose.Words proporciona la propiedad Target que sirve para este propósito.
El siguiente ejemplo de código muestra cómo establecer las propiedades de comparación avanzadas:
// 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"); |