Creating a table of contents in a Word document can help readers quickly understand the structure and content of the document, thereby enhancing its readability. The creation of a table of contents also aids authors in organizing the document's content, ensuring a clear structure and strong logical flow. When modifications or additional content need to be made to the document, the table of contents can help authors quickly locate the sections that require editing. This article will explain how to use Spire.Doc for Java to create a table of contents for a newly created Word document in a Java project.

Install Spire.Doc for Java

First, you're required to add the Spire.Doc.jar file as a dependency in your Java program. The JAR file can be downloaded from this link. If you use Maven, you can easily import the JAR file in your application by adding the following code to your project's pom.xml file.

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.doc</artifactId>
        <version>12.11.0</version>
    </dependency>
</dependencies>
    

Java Create a Table Of Contents Using Heading Styles

In Spire.Doc, creating a table of contents using heading styles is the default method for generating a table of contents. By applying different levels of heading styles to sections and subsections in the document, the table of contents is automatically generated. Here are the detailed steps:

  • Create a Document object.
  • Add a section using the Document.addSection() method.
  • Add a paragraph using the Section.addParagraph() method.
  • Create a table of contents object using the Paragraph.appendTOC(int lowerLevel, int upperLevel) method.
  • Create a CharacterFormat character format object and set the font.
  • Apply a heading style to the paragraph using the Paragraph.applyStyle(BuiltinStyle.Heading_1) method.
  • Add text content using the Paragraph.appendText() method.
  • Set character formatting for the text using the TextRange.applyCharacterFormat() method.
  • Update the table of contents using the Document.updateTableOfContents() method.
  • Save the document using the Document.saveToFile() method.
  • Java
import com.spire.doc.*;
import com.spire.doc.documents.*;
import com.spire.doc.fields.*;
import com.spire.doc.formatting.*;

public class CreateTOCByHeadingStyle {
    public static void main(String[] args) {
        // Create a new Document object
        Document doc = new Document();

        // Add a section to the document
        Section section = doc.addSection();

        // Add a table of contents paragraph
        Paragraph TOCparagraph = section.addParagraph();
        TOCparagraph.appendTOC(1, 3);

        // Create a character format object and set the font
        CharacterFormat characterFormat1 = new CharacterFormat(doc);
        characterFormat1.setFontName("Microsoft YaHei");

        // Create another character format object and set the font and font size
        CharacterFormat characterFormat2 = new CharacterFormat(doc);
        characterFormat2.setFontName("Microsoft YaHei");
        characterFormat2.setFontSize(12);

        // Add a paragraph with Heading 1 style
        Paragraph paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(BuiltinStyle.Heading_1);

        // Add text and apply character format
        TextRange textRange1 = paragraph.appendText("Overview");
        textRange1.applyCharacterFormat(characterFormat1);

        // Add regular content
        paragraph = section.getBody().addParagraph();
        TextRange textRange2 = paragraph.appendText("Spire.Doc for Java is a professional Word API that empowers Java applications to create, convert, manipulate and print Word documents without dependency on Microsoft Word.");
        textRange2.applyCharacterFormat(characterFormat2);

        // Add a paragraph with Heading 1 style
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(BuiltinStyle.Heading_1);
        textRange1 = paragraph.appendText("MAIN FUNCTION");
        textRange1.applyCharacterFormat(characterFormat1);

        // Add a paragraph with Heading 2 style
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(BuiltinStyle.Heading_2);
        textRange1 = paragraph.appendText("Only Spire.Doc for Java, No Microsoft Office");
        textRange1.applyCharacterFormat(characterFormat1);

        // Add regular content
        paragraph = section.getBody().addParagraph();
        textRange2 = paragraph.appendText("Spire.Doc for Java is a totally independent Word component, Microsoft Office is not required in order to use Spire.Doc for Java.");
        textRange2.applyCharacterFormat(characterFormat2);

        // Add a paragraph with Heading 3 style
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(BuiltinStyle.Heading_3);
        textRange1 = paragraph.appendText("Word Versions");
        textRange1.applyCharacterFormat(characterFormat1);
        paragraph = section.getBody().addParagraph();
        textRange2 = paragraph.appendText("Word97-03  Word2007  Word2010  Word2013  Word2016  Word2019");
        textRange2.applyCharacterFormat(characterFormat2);

        // Add a paragraph with Heading 2 style
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(BuiltinStyle.Heading_2);
        textRange1 = paragraph.appendText("High Quality File Conversion");
        textRange1.applyCharacterFormat(characterFormat1);

        // Add regular content
        paragraph = section.getBody().addParagraph();
        textRange2 = paragraph.appendText("Spire.Doc for Java allows converting popular file formats like HTML, RTF, ODT, TXT, WordML, WordXML to Word and exporting Word to commonly used file formats such as PDF, XPS, Image, EPUB, HTML, TXT, ODT, RTF, WordML, WordXML in high quality. Moreover, conversion between Doc and Docx is supported as well.");
        textRange2.applyCharacterFormat(characterFormat2);

        // Add a paragraph with Heading 2 style
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(BuiltinStyle.Heading_2);
        textRange1 = paragraph.appendText("Support a Rich Set of Word Elements");
        textRange1.applyCharacterFormat(characterFormat1);

        // Add regular content
        paragraph = section.getBody().addParagraph();
        textRange2 = paragraph.appendText("Spire.Doc for Java supports a rich set of Word elements, including section, header, footer, footnote, endnote, paragraph, list, table, text, TOC, form field, mail merge, hyperlink, bookmark, watermark, image, style, shape, textbox, ole, WordArt, background settings, digital signature, document encryption and many more.");
        textRange2.applyCharacterFormat(characterFormat2);

        // Update the table of contents
        doc.updateTableOfContents();

        // Save the document
        doc.saveToFile("Table of Contents Created Using Heading Styles.docx", FileFormat.Docx_2016);

        // Dispose of resources
        doc.dispose();
    }
}

Java: Create a Table Of Contents for a Newly Created Word Document

Java Create a Table Of Contents Using Outline Level Styles

You can also use outline level styles to create a table of contents in a Word document. In Spire.Doc, by setting the OutlineLevel property of a paragraph, you can specify the hierarchical style of the paragraph in the outline. Then, by calling the TableOfContent.setTOCLevelStyle() method, you can apply these outline level styles to the generation rules of the table of contents. Here are the detailed steps:

  • Create a Document object.
  • Add a section using the Document.addSection() method.
  • Create a ParagraphStyle object and set the outline level using ParagraphStyle.getParagraphFormat().setOutlineLevel(OutlineLevel.Level_1).
  • Add the created ParagraphStyle object to the document using Document.getStyles().add() method.
  • Add a paragraph using Section.addParagraph() method.
  • Create a table of contents object using Paragraph.appendTOC(int lowerLevel, int upperLevel) method.
  • Set the default setting for creating the table of contents using heading styles to false, TableOfContent.setUseHeadingStyles(false).
  • Apply the outline level styles to the table of contents rules using TableOfContent.setTOCLevelStyle(int levelNumber, string styleName) method.
  • Create a CharacterFormat object and set the font.
  • Apply the style to the paragraph using Paragraph.applyStyle(ParagraphStyle.getName()) method.
  • Add text content using Paragraph.appendText() method.
  • Apply character formatting to the text using TextRange.applyCharacterFormat() method.
  • Update the table of contents using Document.updateTableOfContents() method.
  • Save the document using Document.saveToFile() method.
  • Java
import com.spire.doc.*;
import com.spire.doc.documents.*;
import com.spire.doc.fields.*;
import com.spire.doc.formatting.*;

public class CreateTOCByOutlineLevelStyle {
    public static void main(String[] args) {
        // Create a new Document object
        Document doc = new Document();
        Section section = doc.addSection();

        // Define Outline Level 1
        ParagraphStyle titleStyle1 = new ParagraphStyle(doc);
        titleStyle1.setName("T1S");
        titleStyle1.getParagraphFormat().setOutlineLevel(OutlineLevel.Level_1);
        titleStyle1.getCharacterFormat().setBold(true);
        titleStyle1.getCharacterFormat().setFontName("Microsoft YaHei");
        titleStyle1.getCharacterFormat().setFontSize(18f);
        titleStyle1.getParagraphFormat().setHorizontalAlignment(HorizontalAlignment.Left);
        doc.getStyles().add(titleStyle1);

        // Define Outline Level 2
        ParagraphStyle titleStyle2 = new ParagraphStyle(doc);
        titleStyle2.setName("T2S");
        titleStyle2.getParagraphFormat().setOutlineLevel(OutlineLevel.Level_2);
        titleStyle2.getCharacterFormat().setBold(true);
        titleStyle2.getCharacterFormat().setFontName("Microsoft YaHei");
        titleStyle2.getCharacterFormat().setFontSize(16f);
        titleStyle2.getParagraphFormat().setHorizontalAlignment(HorizontalAlignment.Left);
        doc.getStyles().add(titleStyle2);

        // Define Outline Level 3
        ParagraphStyle titleStyle3 = new ParagraphStyle(doc);
        titleStyle3.setName("T3S");
        titleStyle3.getParagraphFormat().setOutlineLevel(OutlineLevel.Level_3);
        titleStyle3.getCharacterFormat().setBold(true);
        titleStyle3.getCharacterFormat().setFontName("Microsoft YaHei");
        titleStyle3.getCharacterFormat().setFontSize(14f);
        titleStyle3.getParagraphFormat().setHorizontalAlignment(HorizontalAlignment.Left);
        doc.getStyles().add(titleStyle3);

        // Add Table of Contents paragraph
        Paragraph TOCparagraph = section.addParagraph();
        TableOfContent toc = TOCparagraph.appendTOC(1, 3);
        toc.setUseHeadingStyles(false);
        toc.setUseHyperlinks(true);
        toc.setUseTableEntryFields(false);
        toc.setRightAlignPageNumbers(true);
        toc.setTOCLevelStyle(1, titleStyle1.getName());
        toc.setTOCLevelStyle(2, titleStyle2.getName());
        toc.setTOCLevelStyle(3, titleStyle3.getName());

        // Define Character Format
        CharacterFormat characterFormat = new CharacterFormat(doc);
        characterFormat.setFontName("Microsoft YaHei");
        characterFormat.setFontSize(12);

        // Add paragraph and apply Outline Level Style 1
        Paragraph paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(titleStyle1.getName());
        paragraph.appendText("Overview");

        // Add paragraph and set text content
        paragraph = section.getBody().addParagraph();
        TextRange textRange = paragraph.appendText("Spire.Doc for Java is a professional Word API that empowers Java applications to create, convert, manipulate and print Word documents without dependency on Microsoft Word.");
        textRange.applyCharacterFormat(characterFormat);

        // Add paragraph and apply Outline Level Style 1
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(titleStyle1.getName());
        paragraph.appendText("MAIN FUNCTION");

        // Add paragraph and apply Outline Level Style 2
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(titleStyle2.getName());
        paragraph.appendText("Only Spire.Doc for Java, No Microsoft Office");

        // Add paragraph and set text content
        paragraph = section.getBody().addParagraph();
        textRange = paragraph.appendText("Spire.Doc for Java is a totally independent Word component, Microsoft Office is not required in order to use Spire.Doc for Java.");
        textRange.applyCharacterFormat(characterFormat);

        // Add paragraph and apply Outline Level Style 3
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(titleStyle3.getName());
        paragraph.appendText("Word Versions");

        // Add paragraph and set text content
        paragraph = section.getBody().addParagraph();
        textRange = paragraph.appendText("Word97-03  Word2007  Word2010  Word2013  Word2016  Word2019");
        textRange.applyCharacterFormat(characterFormat);

        // Add paragraph and apply Outline Level Style 2
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(titleStyle2.getName());
        paragraph.appendText("High Quality File Conversion");

        // Add paragraph and set text content
        paragraph = section.getBody().addParagraph();
        textRange = paragraph.appendText("Spire.Doc for Java allows converting popular file formats like HTML, RTF, ODT, TXT, WordML, WordXML to Word and exporting Word to commonly used file formats such as PDF, XPS, Image, EPUB, HTML, TXT, ODT, RTF, WordML, WordXML in high quality. Moreover, conversion between Doc and Docx is supported as well.");
        textRange.applyCharacterFormat(characterFormat);

        // Add paragraph and apply Outline Level Style 2
        paragraph = section.getBody().addParagraph();
        paragraph.applyStyle(titleStyle2.getName());
        paragraph.appendText("Support a Rich Set of Word Elements");

        // Add paragraph and set text content
        paragraph = section.getBody().addParagraph();
        textRange = paragraph.appendText("Spire.Doc for Java supports a rich set of Word elements, including section, header, footer, footnote, endnote, paragraph, list, table, text, TOC, form field, mail merge, hyperlink, bookmark, watermark, image, style, shape, textbox, ole, WordArt, background settings, digital signature, document encryption and many more.");
        textRange.applyCharacterFormat(characterFormat);

        // Update the table of contents
        doc.updateTableOfContents();

        // Save the document
        doc.saveToFile("Creating Table of Contents with Outline Level Styles.docx", FileFormat.Docx_2016);

        // Dispose of resources
        doc.dispose();
    }
}

Java: Create a Table Of Contents for a Newly Created Word Document

Java Create a Table Of Contents Using Image Captions

Using the Spire.Doc library, you can create a table of contents based on image titles using the TableOfContent tocForImage = new TableOfContent(Document, " \\h \\z \\c \"Image\"") method. Here are the detailed steps:

  • Create a Document object.
  • Add a section using the Document.addSection() method.
  • Create a table of contents object TableOfContent tocForImage = new TableOfContent(Document, " \\h \\z \\c \"Image\"") and specify the style of the table of contents.
  • Add a paragraph using the Section.addParagraph() method.
  • Add the table of contents object to the paragraph using the Paragraph.getItems().add(tocForImage) method.
  • Add a field separator using the Paragraph.appendFieldMark(FieldMarkType.Field_Separator) method.
  • Add the text content "TOC" using the Paragraph.appendText("TOC") method.
  • Add a field end mark using the Paragraph.appendFieldMark(FieldMarkType.Field_End) method.
  • Add an image using the Paragraph.appendPicture() method.
  • Add a paragraph for the image title, including product information and formatting, using the DocPicture.addCaption() method.
  • Update the table of contents to reflect changes in the document using the Document.updateTableOfContents(tocForImage) method.
  • Save the document using the Document.saveToFile() method.
  • Java
import com.spire.doc.*;
import com.spire.doc.documents.*;
import com.spire.doc.fields.*;

public class CreateTOCByImageCaption {
    public static void main(String[] args) {
        // Create a new document object
        Document doc = new Document();

        // Add a section to the document
        Section section = doc.addSection();

        // Create a table of content object for images
        TableOfContent tocForImage = new TableOfContent(doc, " \\h \\z \\c \"Images\"");

        // Add a paragraph to the section
        Paragraph tocParagraph = section.getBody().addParagraph();

        // Add the table of content object to the paragraph
        tocParagraph.getItems().add(tocForImage);

        // Add a field separator
        tocParagraph.appendFieldMark(FieldMarkType.Field_Separator);

        // Add text content
        tocParagraph.appendText("TOC");

        // Add a field end mark
        tocParagraph.appendFieldMark(FieldMarkType.Field_End);

        // Add a blank paragraph to the section
        section.getBody().addParagraph();

        // Add a paragraph to the section
        Paragraph paragraph = section.getBody().addParagraph();

        // Add an image
        DocPicture docPicture = paragraph.appendPicture("images/Doc-Java.png");
        docPicture.setWidth(100);
        docPicture.setHeight(100);

        // Add a paragraph for the image caption
        Paragraph pictureCaptionParagraph = (Paragraph) docPicture.addCaption("Images", CaptionNumberingFormat.Number, CaptionPosition.Below_Item);
        pictureCaptionParagraph.appendText("  Spire.Doc for Java Product ");
        pictureCaptionParagraph.getFormat().setAfterSpacing(20);

        // Continue adding paragraphs to the section
        paragraph = section.getBody().addParagraph();
        docPicture = paragraph.appendPicture("images/PDF-Java.png");
        docPicture.setWidth(100);
        docPicture.setHeight(100);
        pictureCaptionParagraph = (Paragraph) docPicture.addCaption("Images", CaptionNumberingFormat.Number, CaptionPosition.Below_Item);
        pictureCaptionParagraph.appendText("  Spire.PDF for Java Product ");
        pictureCaptionParagraph.getFormat().setAfterSpacing(20);
        paragraph = section.getBody().addParagraph();
        docPicture = paragraph.appendPicture("images/XLS-Java.png");
        docPicture.setWidth(100);
        docPicture.setHeight(100);
        pictureCaptionParagraph = (Paragraph) docPicture.addCaption("Images", CaptionNumberingFormat.Number, CaptionPosition.Below_Item);
        pictureCaptionParagraph.appendText("  Spire.XLS for Java Product ");
        pictureCaptionParagraph.getFormat().setAfterSpacing(20);
        paragraph = section.getBody().addParagraph();
        docPicture = paragraph.appendPicture("images/PPT-Java.png");
        docPicture.setWidth(100);
        docPicture.setHeight(100);
        pictureCaptionParagraph = (Paragraph) docPicture.addCaption("Images", CaptionNumberingFormat.Number, CaptionPosition.Below_Item);
        pictureCaptionParagraph.appendText("  Spire.Presentation for Java Product ");

        // Update the table of contents
        doc.updateTableOfContents(tocForImage);

        // Save the document to a file
        doc.saveToFile("CreateTOCWithImageCaptions.docx", FileFormat.Docx_2016);

        // Dispose of the document object
        doc.dispose();
    }
}

Java: Create a Table Of Contents for a Newly Created Word Document

Java Create a Table Of Contents Using Table Captions

You can also create a table of contents using table titles by the method TableOfContent tocForImage = new TableOfContent(Document, " \\h \\z \\c \"Table\""). Here are the detailed steps:

  • Create a Document object.
  • Add a section using the Document.addSection() method.
  • Create a table of contents object TableOfContent tocForTable = new TableOfContent(Document, " \\h \\z \\c \"Table\"") and specify the style of the table of contents.
  • Add a paragraph using the Section.addParagraph() method.
  • Add the table of contents object to the paragraph using the Paragraph.getItems().add(tocForTable) method.
  • Add a field separator using the Paragraph.appendFieldMark(FieldMarkType.Field_Separator) method.
  • Add the text "TOC" using the Paragraph.appendText("TOC") method.
  • Add a field end mark using the Paragraph.appendFieldMark(FieldMarkType.Field_End) method.
  • Add a table using the Section.addTable() method and set the number of rows and columns using the Table.resetCells(int rowsNum, int columnsNum) method.
  • Add a caption paragraph to the table using the Table.addCaption() method, including product information and formatting.
  • Update the table of contents to reflect changes in the document using the Document.updateTableOfContents(tocForTable) method.
  • Save the document using the Document.saveToFile() method.
  • Java
import com.spire.doc.*;
import com.spire.doc.documents.*;
import com.spire.doc.fields.*;

public class CreateTOCByTableCaption {
    public static void main(String[] args) {
        // Create a new document
        Document doc = new Document();

        // Add a section to the document
        Section section = doc.addSection();

        // Create a table of content object
        TableOfContent tocForTable = new TableOfContent(doc, " \\h \\z \\c \"Table\"");

        // Add a paragraph in the section to place the table of content
        Paragraph tocParagraph = section.getBody().addParagraph();
        tocParagraph.getItems().add(tocForTable);
        tocParagraph.appendFieldMark(FieldMarkType.Field_Separator);
        tocParagraph.appendText("TOC");
        tocParagraph.appendFieldMark(FieldMarkType.Field_End);

        // Add two empty paragraphs in the section
        section.getBody().addParagraph();
        section.getBody().addParagraph();

        // Add a table in the section
        Table table = section.getBody().addTable(true);
        table.resetCells(1, 3);

        // Add a title for the table
        Paragraph tableCaptionParagraph = (Paragraph) table.addCaption("Table", CaptionNumberingFormat.Number, CaptionPosition.Below_Item);
        tableCaptionParagraph.appendText("  One row, three columns");
        tableCaptionParagraph.getFormat().setAfterSpacing(18);

        // Add a new table in the section
        table = section.getBody().addTable(true);
        table.resetCells(3, 3);

        // Add a title for the second table
        tableCaptionParagraph = (Paragraph) table.addCaption("Table", CaptionNumberingFormat.Number, CaptionPosition.Below_Item);
        tableCaptionParagraph.appendText("  Three rows, three columns");
        tableCaptionParagraph.getFormat().setAfterSpacing(18);

        // Add another new table in the section
        table = section.getBody().addTable(true);
        table.resetCells(5, 3);

        // Add a title for the third table
        tableCaptionParagraph = (Paragraph) table.addCaption("Table", CaptionNumberingFormat.Number, CaptionPosition.Below_Item);
        tableCaptionParagraph.appendText("  Five rows, three columns");

        // Update the table of contents
        doc.updateTableOfContents(tocForTable);

        // Save the document to a specified file
        doc.saveToFile("CreateTableOfContentsUsingTableCaptions.docx", FileFormat.Docx_2016);

        // Dispose of resources
        doc.dispose();
    }
}

Java: Create a Table Of Contents for a Newly Created Word Document

Apply for a Temporary License

If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.

We are glad to announce the release of Spire.Doc for Java 12.4.14. This version enhances the conversion from DOCX to PDF. Moreover, it also fixes the issue that the content appeared different when it was opened with WPS tool after loading and saving the document. More details are listed below.

Here is a list of changes made in this release

Category ID Description
Bug SPIREDOC-9330
SPIREDOC-10446
Fixes the issue that the text was garbled after converting a DOCX document to a PDF document.
Bug SPIREDOC-9309 Fixes the issue that the content was messed up after converting a DOCX document to a PDF document.
Bug SPIREDOC-9349 Fixes the issue that the content appeared different when it was opened with WPS tool after loading and saving the document.
Click the link below to download Spire.Doc for Java 12.4.14:

Accurate counting of words, characters, paragraphs, lines, and pages is essential in achieving precise document analysis. By meticulously tracking these metrics, writers can gain valuable insights into the length, structure, and overall composition of their work. In this article, we will explain how to count words, characters, paragraphs, lines, and pages in Word documents in C# using Spire.Doc for .NET.

Install Spire.Doc for .NET

To begin with, you need to add the DLL files included in the Spire.Doc for .NET package as references in your .NET project. The DLL files can be either downloaded from this link or installed via NuGet.

PM> Install-Package Spire.Doc

Count Words, Characters, Paragraphs, Lines, and Pages in a Word Document in C#

Spire.Doc for .NET provides the BuiltinDocumentProperties class that enables you to retrieve crucial information from your Word documents. By using this class, you can access a wealth of details, including both the built-in and custom properties, as well as the precise counts of words, characters, paragraphs, lines, and pages contained within the document. The detailed steps are as follows.

  • Initialize an object of the Document class.
  • Load a sample Word document using the Document.LoadFromFile() method.
  • Get the BuiltinDocumentProperties object using the Document.BuiltinDocumentProperties property.
  • Get the numbers of words, characters, paragraphs, lines, and pages in the document using the WordCount, CharCount, ParagraphCount, LinesCount and PageCount properties of the BuiltinDocumentProperties class.
  • Initialize an object of the StringBuilder class and append the results to it using the StringBuilder.AppendLine() method.
  • Write the content in the StringBuilder to a text file using the File.WriteAllText() method.
  • C#
using Spire.Doc;
using System.IO;
using System.Text;

namespace CountWordsCharactersEtcInWord
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //Initialize an object of the Document class
            Document document = new Document();
            //Load a sample Word document
            document.LoadFromFile("Input.docx");

            //Get the BuiltinDocumentProperties object
            BuiltinDocumentProperties properties = document.BuiltinDocumentProperties;

            //Get the numbers of words, characters, paragraphs, lines, and pages in the document
            int wordCount = properties.WordCount;
            int charCount = properties.CharCount;
            int paraCount = properties.ParagraphCount;
            int lineCount = properties.LinesCount;
            int pageCount = properties.PageCount;

            //Initialize an object of the StringBuilder class
            StringBuilder sb = new StringBuilder();
            //Append the results to the StringBuilder
            sb.AppendLine("The number of words: " + wordCount);
            sb.AppendLine("The number of characters: " + charCount);
            sb.AppendLine("The number of paragraphs: " + paraCount);
            sb.AppendLine("The number of lines: " + lineCount);
            sb.AppendLine("The number of pages: " + pageCount);

            //Write the content of the StringBuilder to a text file
            File.WriteAllText("result.txt", sb.ToString());
            document.Close();
        }
    }
}

C#: Count Words, Characters, Paragraphs, Lines, and Pages in Word Documents

Count Words and Characters in a Specific Paragraph of a Word Document in C#

In addition to counting the words and characters in an entire Word document, Spire.Doc for .NET enables you to count the words and characters of a specific paragraph by using the Paragraph.WordCount and Paragraph.CharCount properties. The detailed steps are as follows.

  • Initialize an object of the Document class.
  • Load a sample Word document using the Document.LoadFromFile() method.
  • Get a specific paragraph using the Document.Sections[sectionindex].Paragraphs[paragraphIndex] property.
  • Get the numbers of words and characters in the paragraph using the Paragraph.WordCount and Paragraph.CharCount properties.
  • Initialize an object of the StringBuilder class and append the results to it using the StringBuilder.AppendLine() method.
  • Write the content in the StringBuilder to a text file using the File.WriteAllText() method.
  • C#
using Spire.Doc;
using Spire.Doc.Documents;
using System.IO;
using System.Text;

namespace CountWordsAndCharactersForParagraph
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //Initialize an object of the Document class
            Document document = new Document();
            //Load a sample Word document
            document.LoadFromFile("Input.docx");

            //Get a specific paragraph
            Paragraph paragraph = document.Sections[0].Paragraphs[0];

            //Get the numbers of words and characters in the paragraph
            int wordCount = paragraph.WordCount;
            int charCount = paragraph.CharCount;
           

            //Initialize an object of the StringBuilder class
            StringBuilder sb = new StringBuilder();
            //Append the results to the StringBuilder
            sb.AppendLine("The number of words: " + wordCount);
            sb.AppendLine("The number of characters: " + charCount);

            //Write the content of the StringBuilder to a text file
            File.WriteAllText("result.txt", sb.ToString());
            document.Close();
        }
    }
}

C#: Count Words, Characters, Paragraphs, Lines, and Pages in Word Documents

Apply for a Temporary License

If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.

We're pleased to announce the release of Spire.PDF for Java 10.4.9. This version supports retrieving Javascript content from PDF documents, and adds a constructor method to address the issue of PdfInkAnnotation not displaying in the browser. Furthermore, it also fixes two issue that occurred when extracting tables from PDFs and flattening form fields. More details are listed below.

Here is a list of changes made in this release

Category ID Description
New feature SPIREPDF-6644 Adds a constructor method "PdfInkAnnotation ink = new PdfInkAnnotation(Rectangle2D rect, List<int[]> inkList)" to address the issue of PdfInkAnnotation not displaying in the browser.
PdfDocument doc = new PdfDocument();
PdfPageBase pdfPage = doc.getPages().add();
ArrayList inkList = new ArrayList();
int[] intPoints = new int[]
     {
         100,800,
         200,800,
         200,700
     };
inkList.add(intPoints);
Rectangle2D rect = new Rectangle2D.Float();
rect.setFrame(new Point2D.Float(0, 0), new Dimension((int)pdfPage.getActualSize().getWidth(), (int)pdfPage.getActualSize().getHeight()));
PdfInkAnnotation ink= new PdfInkAnnotation(rect,inkList);
ink.setColor(new PdfRGBColor(Color.RED));
ink.getBorder().setWidth(12);
ink.setText("e-iceblue");
pdfPage.getAnnotations().add(ink);
doc.saveToFile("inkAnnotation.pdf");
New feature SPIREPDF-6672 Supports retrieving Javascript content from PDF documents.
PdfPageBase page = pdf.getPages().get(0);
StringBuilder stringBuilder = new StringBuilder();
java.util.List<PdfJavaScriptAction> list = pdf.getNames().getJavaScripts();
stringBuilder.append(list.get(2).getScript()+"\r\n");
list.get(0).setScript("new javaScript code");
PdfAnnotationCollection annotationCollection = page.getAnnotations();
for(int i = 0;i < annotationCollection.getCount();i++){
    PdfLinkAnnotationWidget annotation = (PdfLinkAnnotationWidget) annotationCollection.get(i);
    stringBuilder.append("Method name:"+"\r\n");
    String script = ((PdfJavaScriptAction) annotation.getAction()).getScript();
    stringBuilder.append(script+"\r\n");
}
Bug SPIREPDF-6662
SPIREPDF-6667
Fixes the issue that the text in tables was not being extracted completely.
Bug SPIREPDF-6675 Fixes the issue that the application threw a "java.lang.NullPointerException" exception when saving a PDF document after flattening form fields.
Click the link below to download Spire.PDF for Java 10.4.9:

We are excited to announce the release of Spire.XLS for Python 14.4.4. This version supports adding FindAll() method to CellRange. Besides, some known issues are fixed in this version, such as the issue that retrieving custom font files failed. More details are listed below.

Here is a list of changes made in this release

Category ID Description
New feature SPIREXLS-5165 Supports adding FindAll() method to CellRange.
workbook = Workbook()
workbook.LoadFromFile("test.xlsx")
sheet = workbook.Worksheets[0]
sheet.Range["A1"].FindAll("Hello", FindType.Text, ExcelFindOptions.MatchEntireCellContent)
Bug SPIREXLS-5092 Fixes the issue that retrieving custom font files failed.
Bug SPIREXLS-5194 Fixes the issue that the program threw spire.xls.common.SpireException:
Arg_NullReferenceException when creating a drop-down list.
Click the link below to get Spire.XLS for Python 14.4.4:
Tuesday, 30 April 2024 01:07

Python: Add or Remove Shapes in Word

In the modern office environment, Microsoft Word has become an indispensable part of our daily work and study. Whether it's writing reports, creating resumes, or designing promotional materials, Word provides us with a rich set of features and tools. Among them, the function of adding shapes is particularly popular among users because it allows us to easily enhance the visual appeal and expressiveness of documents. Manipulating shape elements is one of the highlights of Spire.Doc functionality, and this article will introduce you to how to add or delete shapes in Word using Spire.Doc for Python.

Install Spire.Doc for Python

This scenario requires Spire.Doc for Python and plum-dispatch v1.7.4. They can be easily installed in your Windows through the following pip command.

pip install Spire.Doc

If you are unsure how to install, please refer to this tutorial: How to Install Spire.Doc for Python on Windows

Add Shapes in Word Document in Python

Spire.Doc for Python supports adding various shapes such as rectangles, trapezoids, triangles, arrows, lines, emoticons, and many other predefined shape types. By calling the Paragraph.AppendShape(width: float, height: float, shapeType: 'ShapeType') method, you can not only easily insert these shapes at any position in the document but also customize various properties of the shapes, such as fill color, border style, rotation angle, transparency, etc., to meet different typesetting needs and visual effects. Below are the detailed steps:

  • Create a new Document object.
  • Call Document.AddSection() and Section.AddParagraph() methods to add a section and a paragraph within the section, respectively.
  • Call the Paragraph.AppendShape(width: float, height: float, shapeType: 'ShapeType') method to add a shape on the paragraph, where width and height represent the dimensions of the shape, and shapeType enum is used to specify the type of shape.
  • Define the style of the shape, such as fill color, border color, border style, and width.
  • Set the horizontal and vertical position of the shape relative to the page.
  • Add multiple other types of shapes using the same method.
  • Save the document using the Document.SaveToFile() method.
  • Python
from spire.doc import *
from spire.doc.common import *

# Create a new Document object
doc = Document()

# Add a new section in the document
sec = doc.AddSection()

# Add a paragraph in the new section
para = sec.AddParagraph()

# Add a rectangle shape in the paragraph with width and height both 60
shape1 = para.AppendShape(60, 60, ShapeType.Rectangle)

# Define the fill color of the shape
shape1.FillColor = Color.get_YellowGreen()

# Define the border color
shape1.StrokeColor = Color.get_Gray()

# Define the border style and width
shape1.LineStyle = ShapeLineStyle.Single
shape1.StrokeWeight = 1

# Set the horizontal and vertical position of the shape relative to the page
shape1.HorizontalOrigin = HorizontalOrigin.Page
shape1.HorizontalPosition = 100
shape1.VerticalOrigin = VerticalOrigin.Page
shape1.VerticalPosition = 200

# Similarly, add a triangle shape in the same paragraph and set its properties
shape2 = para.AppendShape(60, 60, ShapeType.Triangle)
shape2.FillColor = Color.get_Green()
shape2.StrokeColor = Color.get_Gray()
shape2.LineStyle = ShapeLineStyle.Single
shape2.StrokeWeight = 1
shape2.HorizontalOrigin = HorizontalOrigin.Page
shape2.HorizontalPosition = 200
shape2.VerticalOrigin = VerticalOrigin.Page
shape2.VerticalPosition = 200

# Add an arrow shape and set its properties
shape3 = para.AppendShape(60, 60, ShapeType.Arrow)
shape3.FillColor = Color.get_SeaGreen()
shape3.StrokeColor = Color.get_Gray()
shape3.LineStyle = ShapeLineStyle.Single
shape3.StrokeWeight = 1
shape3.HorizontalOrigin = HorizontalOrigin.Page
shape3.HorizontalPosition = 300
shape3.VerticalOrigin = VerticalOrigin.Page
shape3.VerticalPosition = 200

# Add a smiley face shape and set its properties
shape4 = para.AppendShape(60, 60, ShapeType.SmileyFace)
shape4.FillColor = Color.get_LightGreen()
shape4.StrokeColor = Color.get_Gray()
shape4.LineStyle = ShapeLineStyle.Single
shape4.StrokeWeight = 1
shape4.HorizontalOrigin = HorizontalOrigin.Page
shape4.HorizontalPosition = 400
shape4.VerticalOrigin = VerticalOrigin.Page
shape4.VerticalPosition = 200

# Save the document
outputFile = "AddShapes.docx"
doc.SaveToFile(outputFile, FileFormat.Docx2016)

# Release the document
doc.Close()

Python: Add or Remove Shapes in Word

Add Shape Group in Word Document

Spire.Doc for Python not only provides the functionality to add individual shapes (such as rectangles, circles, lines, etc.) but also supports creating and managing grouped shapes. A grouped shape is a special collection of shapes that organizes multiple independent shapes together to form a whole, sharing the same transformation properties (such as position, rotation angle, etc.). Here are the specific steps to achieve this:

  • Create an object of the Document class.
  • Call the Document.AddSection() method to add a blank section.
  • Call the Section.AddParagraph() method to add a blank paragraph in the section.
  • Call Paragraph.AppendShapeGroup() to add a shape group and specify its dimensions.
  • Create a Textbox and specify its shape type, dimensions, position, fill color, and other properties.
  • Add paragraphs within the Textbox and insert text, setting the paragraph's horizontal alignment to center.
  • Add the Textbox to the list of child objects of the shape group.
  • Similar to the above steps, create shapes for symbols like arrows, diamond-shaped text boxes, octagonal text boxes, and set their properties, adding them to the list of child objects of the shape group.
  • Save the document using the Document.SaveToFile() method.
  • Python
from spire.doc import *
from spire.doc.common import *

# Create a Document object
doc = Document()

# Add a section to the document
sec = doc.AddSection()

# Add a paragraph to the section
para = sec.AddParagraph()

# Add a shape group to the paragraph and specify its horizontal position
shapegroup = para.AppendShapeGroup(375, 350)
shapegroup.HorizontalPosition = 180

# Calculate the relative unit scale X and Y for the shape group for subsequent element size positioning
X = float((shapegroup.Width / 1000.0))
Y = float((shapegroup.Height / 1000.0))

# Create a rounded rectangle text box
txtBox = TextBox(doc)

# Set the shape type of the text box
txtBox.SetShapeType(ShapeType.RoundRectangle)

# Set the width and height of the text box
txtBox.Width = 125 / X
txtBox.Height = 54 / Y

# Add a paragraph inside the text box and set its horizontal alignment to center
paragraph = txtBox.Body.AddParagraph()
paragraph.Format.HorizontalAlignment = HorizontalAlignment.Center

# Add the text "Step One" to the paragraph
paragraph.AppendText("Step One")

# Set the horizontal and vertical position of the text box
txtBox.HorizontalPosition = 19 / X
txtBox.VerticalPosition = 27 / Y

# Set the fill color of the text box and remove the border line
txtBox.Format.FillColor = Color.FromRgb(153, 255, 255)
txtBox.Format.NoLine = True

# Add the text box to the list of child objects of the shape group
shapegroup.ChildObjects.Add(txtBox)

# Create a downward arrow shape and specify its shape type
arrowLineShape = ShapeObject(doc, ShapeType.DownArrow)

# Set the width and height of the arrow shape
arrowLineShape.Width = 16 / X
arrowLineShape.Height = 40 / Y

# Set the horizontal and vertical position of the arrow shape
arrowLineShape.HorizontalPosition = 73 / X
arrowLineShape.VerticalPosition = 87 / Y

# Set the stroke color of the arrow shape
arrowLineShape.StrokeColor = Color.get_CadetBlue()

# Add the arrow shape to the list of child objects of the shape group
shapegroup.ChildObjects.Add(arrowLineShape)

# (Similar subsequent code, creating diamond-shaped text boxes, downward arrow shapes, and octagonal text boxes, with corresponding property settings and positioning)

txtBox = TextBox(doc)
txtBox.SetShapeType(ShapeType.Diamond)
txtBox.Width = 125 / X
txtBox.Height = 54 / Y
paragraph = txtBox.Body.AddParagraph()
paragraph.Format.HorizontalAlignment = HorizontalAlignment.Center
paragraph.AppendText("Step Two")
txtBox.HorizontalPosition = 19 / X
txtBox.VerticalPosition = 131 / Y
txtBox.Format.FillColor = Color.FromRgb(0, 102, 102)
txtBox.Format.NoLine = True
shapegroup.ChildObjects.Add(txtBox)

arrowLineShape = ShapeObject(doc, ShapeType.DownArrow)
arrowLineShape.Width = 16 / X
arrowLineShape.Height = 40 / Y
arrowLineShape.HorizontalPosition = 73 / X
arrowLineShape.VerticalPosition = 192 / Y
arrowLineShape.StrokeColor = Color.get_CadetBlue()
shapegroup.ChildObjects.Add(arrowLineShape)

txtBox = TextBox(doc)
txtBox.SetShapeType(ShapeType.Octagon)
txtBox.Width = 149 / X
txtBox.Height = 59 / Y
paragraph = txtBox.Body.AddParagraph()
paragraph.Format.HorizontalAlignment = HorizontalAlignment.Center
paragraph.AppendText("Step Three")
txtBox.HorizontalPosition = 7 / X
txtBox.VerticalPosition = 236 / Y
txtBox.Format.FillColor = Color.FromRgb(51, 204, 204)
txtBox.Format.NoLine = True
shapegroup.ChildObjects.Add(txtBox)

# Define the output file name
outputFile = "ShapeGroup.docx"

# Save the document
doc.SaveToFile(outputFile, FileFormat.Docx2016)

# Close the document object
doc.Close()

Python: Add or Remove Shapes in Word

Remove Shapes from Word Document

Spire.Doc for Python supports efficiently removing individual shapes and shape groups from a Word document. Below are the detailed steps:

  • Create an object of the Document class.
  • Call the Document.LoadFromFile() method to load a document containing shapes.
  • Traverse through all the sections of the document and the body elements within the sections to get paragraphs.
  • Check if the child elements under the paragraph are shape objects or shape group objects.
  • Call the Paragraph.ChildObjects.Remove() method to remove the shape object.
  • Save the document using the Document.SaveToFile() method.
  • Python
from spire.doc import *
from spire.doc.common import *

# Create an object of the Document class
doc = Document()

# Load a Word document
doc.LoadFromFile("ShapeGroup.docx")

# Iterate through all sections of the document
for s in range(doc.Sections.Count):    
    # Get the current section
    section = doc.Sections[s]
    
    # Iterate through all child objects within the section
    for i in range(section.Body.ChildObjects.Count):
        # Get the current child object
        document_object = section.Body.ChildObjects[i]
        
        # If the current child object is a paragraph
        if isinstance(document_object, Paragraph):
            # Convert the child object to a paragraph object
            paragraph = document_object
            
            # Initialize the inner loop index
            j = 0
            
            # Iterate through all child objects within the paragraph
            while j < paragraph.ChildObjects.Count:
                # Get the current child object within the paragraph
                c_obj = paragraph.ChildObjects[j]
                
                # If the current child object is a shape group or shape object
                if isinstance(c_obj, ShapeGroup) or isinstance(c_obj, ShapeObject):
                    # Remove the shape object from the paragraph
                    paragraph.ChildObjects.Remove(c_obj)
                    
                    # Update the inner loop index
                    j -= 1
                    
                # Increment the inner loop index
                j += 1

# Save the document
doc.SaveToFile("RemovedShapes.docx", FileFormat.Docx2016)

# Close the document object
doc.Close()

Apply for a Temporary License

If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.

A comparação de documentos do Word ajuda os usuários a identificar e analisar diferenças entre duas versões de um documento, o que é particularmente valioso em contextos profissionais e colaborativos onde as revisões ou atualizações devem ser gerenciadas cuidadosamente. Ao comparar documentos do Word com ferramentas como Microsoft Word, Google Docs, ferramentas online e até mesmo abordagens de codificação em Python, os usuários podem identificar discrepâncias de forma rápida e fácil, acompanhar o progresso e manter um documento unificado. Este artigo analisa os vários métodos produtivos para comparar documentos do Word e suas limitações para ajudá-lo a escolher a melhor abordagem para suas necessidades específicas.

Comparando documentos do Word com o Microsoft Word

O Microsoft Word oferece um recurso de comparação integrado que permite aos usuários comparar duas versões de um documento lado a lado. Este recurso é facilmente acessível e conveniente para usuários familiarizados com a interface do Word.

Para comparar documentos do Word com o Microsoft Word, siga as etapas:

1. Abra o Microsoft Word e o recurso de comparação do Access : Inicie o Microsoft Word e abra o documento original (ou qualquer outro documento). Vá para a guia "Revisão", clique no botão "Comparar" e escolha "Comparar..." no menu suspenso.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Selecione Documentos Originais e Revisados : Na caixa de diálogo "Comparar Documentos", use o botão "Navegar" para escolher o documento original e o documento revisado que deseja comparar.

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Personalizar configurações (opcional) : Clique em "Mais" para ajustar as opções de comparação, como incluir alterações de maiúsculas e minúsculas, comparar a formatação ou ignorar espaços em branco.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Iniciar comparação : Clique em "OK" na caixa de diálogo "Comparar documentos" para iniciar a comparação. O Word abrirá uma nova janela exibindo as alterações entre as versões original e revisada.

5. Revise e aceite/rejeite alterações:

  • Revise as alterações destacadas (as exclusões são riscadas, as adições são marcadas) na nova janela.
  • Use os botões "Alteração anterior" e "Próxima alteração" (ou atalhos de teclado) para navegar.
  • Aceite ou rejeite as alterações conforme necessário usando os botões correspondentes ou opções do menu de contexto.

Compare Word Documents and Find the Differences with User-Friendly Tools

Limitações:

  • É necessária a instalação de software pago : O Microsoft Office pago deve estar instalado no computador para usar o recurso de comparação.
  • Interfaces complexas : o Microsoft Word fornece uma interface complexa para processar resultados de comparação de documentos, o que não é amigável para edição simples.

Compare documentos do Word com o Google Docs

O Google Docs oferece uma ferramenta poderosa para comparar documentos diretamente em seu editor. No entanto, é importante lembrar que o recurso de comparação do Google Docs foi projetado para funcionar com o formato Google Docs e não pode comparar diretamente documentos do Word (formato Doc ou Docx). Para aproveitar esse recurso de forma eficaz, você precisará converter seus documentos do Word para o formato Google Docs.

Siga estas etapas simples para usar o Google Docs para comparar documentos do Word:

1. Faça upload de documentos do Word para o Google Drive : Faça login na sua conta do Google e vá para o Google Drive . Carregue as versões original e revisada dos documentos do Word clicando no botão "Novo", selecionando "Upload de arquivo" e escolhendo os respectivos arquivos em seu computador.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Abra os documentos do Word com o Google Docs : Após o upload, clique com o botão direito em cada arquivo e escolha "Abrir com" > "Google Docs".

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Converta os documentos do Word para o formato do Google Docs : Escolha "Arquivo"> ​​"Salvar como Google Docs" no menu do editor do Google Docs e os documentos do Word serão convertidos para o formato do Google Docs e salvos na mesma pasta.

A formatação pode variar ligeiramente entre as duas plataformas. Revise seu documento e faça os ajustes necessários.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Acesse o recurso Comparar : Abra o documento original no Google Docs. Vá ao menu "Ferramentas" e clique em "Comparar documentos".

Compare Word Documents and Find the Differences with User-Friendly Tools

5. Selecione o documento revisado : Na caixa de diálogo "Comparar documentos", clique no botão "Escolher arquivo". Navegue em seu Google Drive e selecione o documento revisado que deseja comparar com o original.

Compare Word Documents and Find the Differences with User-Friendly Tools

6. Inicie a comparação : Clique em "Comparar". O Google Docs criará um novo documento mesclado. As alterações feitas na versão revisada serão mostradas no documento mesclado e listadas à direita da janela do editor.

Compare Word Documents and Find the Differences with User-Friendly Tools

7. Revisar e aceitar/rejeitar alterações: Percorra o documento mesclado e aceite ou rejeite as alterações individualmente clicando nos itens de alteração e escolhendo a marca de seleção ou cruz.

Limitações:

  • Conversão de formato necessária : o Google Docs não pode comparar diretamente documentos do Word. É necessário converter documentos Word para o formato Google Docs para comparação, o que pode provocar alterações na formatação do conteúdo.
  • Sem comparação bilateral para os documentos : o Google Docs não oferece a capacidade de comparar duas versões de um documento nos dois lados e exibe apenas os resultados da comparação em um documento.

Compare documentos do Word com ferramentas online

Além de usar software nativo, existem inúmeras ferramentas baseadas na web disponíveis para comparar documentos do Word, como Draftable Copyleaks. Esses serviços online oferecem conveniência e compatibilidade entre plataformas e muitas vezes não exigem instalação de software. No entanto, as ferramentas de comparação de documentos online geralmente não oferecem a capacidade de aceitar e rejeitar alterações trazidas por um editor.

Usando o Draftable como exemplo, as etapas para comparar documentos usando uma ferramenta online são as seguintes:

1. Acesse a plataforma Draftable : Abra o comparador de documentos online fornecido pela Draftable.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Carregar documentos do Word : Escolha e carregue o documento original e o documento revisado.

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Compare os documentos e obtenha o resultado : Clique em "Comparar" para comparar os dois documentos. A exclusão, inserção e substituição serão mostradas no resultado.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Revise e salve os resultados da comparação : a ferramenta de comparação de documentos rascunhos permite aos usuários salvar o resultado da comparação em formato PDF e filtrar os tipos de alterações mostrados no resultado.

Compare Word Documents and Find the Differences with User-Friendly Tools

Compare Word Documents and Find the Differences with User-Friendly Tools

Limitações:

  • Nenhum recurso para aceitar ou cancelar alterações : as ferramentas de comparação de documentos on-line geralmente mostram apenas as diferenças e não oferecem a capacidade de aceitar e cancelar alterações fornecidas pelos editores.

Compare documentos do Word com código Python

Usar o código Python para comparação de documentos do Word é ideal para desenvolvedores e para realizar um grande número de operações de comparação de documentos. Com a poderosa biblioteca Spire.Doc para Python, os desenvolvedores podem criar scripts personalizados para comparar documentos do Word de forma programática, automatizar o processo e até mesmo integrá-lo a fluxos de trabalho ou aplicativos maiores.

Aqui está um guia passo a passo sobre como comparar documentos do Word usando Spire.Doc para Python :

  1. Importe os módulos necessários.
  2. Crie duas instâncias da classe Document .
  3. Carregue o documento Word original e o documento revisado usando o método Document.LoadFromFile() .
  4. Compare os dois documentos usando o método Document.Compare(Document: document, str: author) .
  5. Salve o resultado da comparação usando o método Document.SaveToFile() .
  6. Liberar recursos.
  • Exemplo de código
from spire.doc import *
from spire.doc.common import *

# Create two instances of Document class
originalDoc = Document()
revisedDoc = Document()

# Load two Word documents
originalDoc.LoadFromFile("Invitation.docx")
revisedDoc.LoadFromFile("Revision.docx")

# Compare two documents
originalDoc.Compare(revisedDoc, "Sarah")

# Save the comparison results in a new document
originalDoc.SaveToFile("Output/Differences.docx", FileFormat.Docx2016)

# Release resources
originalDoc.Dispose()
revisedDoc.Dispose()

Compare Word Documents and Find the Differences with User-Friendly Tools

Limitações:

  • Noções básicas de programação : Comparar documentos do Word usando Python requer que o usuário tenha algumas habilidades básicas de programação.

Conclusão

Em resumo, este artigo apresenta uma exploração abrangente de diversas ferramentas para comparação de documentos Word , atendendo a usuários com diversos níveis de habilidade e requisitos. Ele oferece orientação passo a passo para os usuários compararem documentos do Word com Microsoft Word, Google Docs, ferramentas online e código Python. Ao fornecer uma visão abrangente dessas diversas ferramentas e técnicas, o artigo capacita os leitores a escolher o método mais adequado para comparar documentos do Word com precisão, eficiência e flexibilidade.

Veja também

Сравнение документов Word помогает пользователям выявлять и анализировать различия между двумя версиями документа, что особенно ценно в профессиональных контекстах и ​​условиях совместной работы, где необходимо тщательно контролировать изменения и обновления. Сравнивая документы Word с такими инструментами, как Microsoft Word, Google Docs, онлайн-инструментами и даже подходами к кодированию на Python, пользователи могут быстро и легко выявлять несоответствия, отслеживать прогресс и поддерживать единый документ. В этой статье рассматриваются различные эффективные методы сравнения документов Word и их ограничения, чтобы помочь вам выбрать лучший подход для ваших конкретных потребностей.

Сравнение документов Word с Microsoft Word

Microsoft Word предлагает встроенную функцию сравнения, которая позволяет пользователям сравнивать две версии документа рядом. Эта функция легко доступна и удобна для пользователей, знакомых с интерфейсом Word.

Чтобы сравнить документы Word с Microsoft Word, выполните следующие действия:

1. Откройте Microsoft Word и функцию сравнения доступа : запустите Microsoft Word и откройте исходный документ (или любой другой документ). Перейдите на вкладку "Обзор", нажмите кнопку "Сравнить", затем выберите "Сравнить..." в раскрывающемся меню.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Выберите исходные и исправленные документы . В диалоговом окне "Сравнить документы" используйте кнопку "Обзор", чтобы выбрать исходный документ и измененный документ, который вы хотите сравнить.

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Настройте параметры (необязательно) . Нажмите "Дополнительно", чтобы настроить параметры сравнения, например включение изменения регистра, сравнение форматирования или игнорирование пробелов.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Начать сравнение : нажмите "ОК" в диалоговом окне "Сравнить документы", чтобы начать сравнение. Word откроет новое окно, отображающее изменения между исходной и исправленной версиями.

5. Просмотрите и примите/отклоните изменения :

  • Просмотрите выделенные изменения (удаления зачеркнуты, дополнения отмечены) в новом окне.
  • Для навигации используйте кнопки "Предыдущее изменение" и "Следующее изменение" (или сочетания клавиш).
  • При необходимости примите или отклоните изменения с помощью соответствующих кнопок или пунктов контекстного меню.

Compare Word Documents and Find the Differences with User-Friendly Tools

Ограничения:

  • Требуется установка платного программного обеспечения . Для использования функции сравнения на компьютере должен быть установлен платный пакет Microsoft Office.
  • Сложные интерфейсы . Microsoft Word предоставляет сложный интерфейс для обработки результатов сравнения документов, который не удобен для простого редактирования.

Сравните документы Word с Документами Google

Google Docs предоставляет мощный инструмент для сравнения документов прямо в редакторе. Однако важно помнить, что функция сравнения Документов Google предназначена для работы с форматом Документов Google и не может напрямую сравнивать документы Word (формат Doc или Docx). Чтобы эффективно использовать эту функцию, вам необходимо преобразовать документы Word в формат Google Docs.

Выполните следующие простые шаги, чтобы использовать Документы Google для сравнения документов Word:

1. Загрузите документы Word на Google Диск . Войдите в свою учетную запись Google и перейдите на Google Диск . Загрузите исходную и исправленную версии документов Word, нажав кнопку "Новый", выбрав "Загрузка файла" и выбрав соответствующие файлы на своем компьютере.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Откройте документы Word с помощью Документов Google . После загрузки щелкните каждый файл правой кнопкой мыши и выберите "Открыть с помощью" > "Документы Google".

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Преобразование документов Word в формат Документов Google . Выберите "Файл" > "Сохранить как Документы Google" в меню редактора Документов Google, и документы Word будут преобразованы в формат Документов Google и сохранены в той же папке.

Форматирование может незначительно отличаться на разных платформах. Просмотрите документ и внесите необходимые изменения.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Доступ к функции сравнения . Откройте исходный документ в Документах Google. Перейдите в меню "Инструменты" и нажмите "Сравнить документы".

Compare Word Documents and Find the Differences with User-Friendly Tools

5. Выберите измененный документ : в диалоговом окне "Сравнить документы" нажмите кнопку "Выбрать файл". Просмотрите свой Google Диск и выберите исправленный документ, который вы хотите сравнить с оригиналом.

Compare Word Documents and Find the Differences with User-Friendly Tools

6. Запустите сравнение : нажмите "Сравнить". Google Docs создаст новый объединенный документ. Изменения, внесенные в исправленную версию, будут показаны в объединенном документе и перечислены в правой части окна редактора.

Compare Word Documents and Find the Differences with User-Friendly Tools

7. Просмотр и принятие/отклонение изменений. Прокрутите объединенный документ и примите или отклоните изменения по отдельности, щелкнув элементы изменения и установив галочку или крестик.

Ограничения:

  • Требуется преобразование формата : Документы Google не могут напрямую сравнивать документы Word. Необходимо преобразовать документы Word в формат Google Docs для сравнения, что может привести к изменению форматирования контента.
  • Нет двустороннего сравнения документов : Google Docs не предоставляет возможности сравнения двух версий документа с двух сторон, а отображает результаты сравнения только в одном документе.

Сравните документы Word с онлайн-инструментами

Помимо использования собственного программного обеспечения, существует множество веб-инструментов для сравнения документов Word, таких как Draftable Copyleaks. Эти онлайн-сервисы обеспечивают удобство и кросс-платформенную совместимость и часто не требуют установки программного обеспечения. Однако онлайн-инструменты сравнения документов обычно не предоставляют возможности принимать и отклонять изменения, вносимые редактором.

На примере Draftable шаги по сравнению документов с помощью онлайн-инструмента следующие:

1. Получите доступ к платформе Draftable : откройте онлайн-средство сравнения документов, предоставляемое Draftable.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Загрузить документы Word : выберите и загрузите исходный и исправленный документ.

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Сравните документы и получите результат : нажмите "Сравнить", чтобы сравнить два документа. Удаление, вставка и замена будут показаны в результате.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Просмотр и сохранение результатов сравнения . Инструмент сравнения черновых документов позволяет пользователям сохранять результаты сравнения в формате PDF и фильтровать типы изменений, показанные в результате.

Compare Word Documents and Find the Differences with User-Friendly Tools

Compare Word Documents and Find the Differences with User-Friendly Tools

Ограничения:

  • Нет функции принятия или отмены изменений . Онлайн-инструменты сравнения документов обычно показывают только различия и не предоставляют возможности принимать и отменять изменения, которые предоставляют редакторы.

Сравните документы Word с кодом Python

Использование кода Python для сравнения документов Word идеально подходит для разработчиков и для выполнения большого количества операций сравнения документов. С помощью мощной библиотеки Spire.Doc для Python разработчики могут создавать собственные сценарии для программного сравнения документов Word, автоматизировать этот процесс и даже интегрировать его в более крупные рабочие процессы или приложения.

Вот пошаговое руководство по сравнению документов Word с помощью Spire.Doc для Python :

  1. Импортируйте необходимые модули.
  2. Создайте два экземпляра класса Document .
  3. Загрузите исходный документ Word и исправленный документ, используя метод Document.LoadFromFile() .
  4. Сравните два документа, используя метод Document.Compare(Document: document, str:author) .
  5. Сохраните результат сравнения с помощью метода Document.SaveToFile() .
  6. Освободите ресурсы.
  • Пример кода
from spire.doc import *
from spire.doc.common import *

# Create two instances of Document class
originalDoc = Document()
revisedDoc = Document()

# Load two Word documents
originalDoc.LoadFromFile("Invitation.docx")
revisedDoc.LoadFromFile("Revision.docx")

# Compare two documents
originalDoc.Compare(revisedDoc, "Sarah")

# Save the comparison results in a new document
originalDoc.SaveToFile("Output/Differences.docx", FileFormat.Docx2016)

# Release resources
originalDoc.Dispose()
revisedDoc.Dispose()

Compare Word Documents and Find the Differences with User-Friendly Tools

Ограничения:

  • Основы программирования . Сравнение документов Word с использованием Python требует от пользователя некоторых базовых навыков программирования.

Заключение

Таким образом, в этой статье представлено всестороннее исследование различных инструментов для сравнения документов Word , предназначенных для пользователей с разными уровнями навыков и требованиями. Он предлагает пользователям пошаговые инструкции по сравнению документов Word с Microsoft Word, Google Docs, онлайн-инструментами и кодом Python. Предоставляя всесторонний обзор этих разнообразных инструментов и методов, статья дает читателям возможность выбрать наиболее подходящий метод для точного, эффективного и гибкого сравнения документов Word.

Смотрите также

Der Vergleich von Word-Dokumenten hilft Benutzern, Unterschiede zwischen zwei Versionen eines Dokuments zu erkennen und zu analysieren, was besonders in beruflichen und kollaborativen Kontexten wertvoll ist, in denen Überarbeitungen oder Aktualisierungen sorgfältig verwaltet werden müssen. Durch den Vergleich von Word-Dokumenten mit Tools wie Microsoft Word, Google Docs, Online-Tools und sogar Codierungsansätzen in Python können Benutzer schnell und einfach Unstimmigkeiten erkennen, den Fortschritt verfolgen und ein einheitliches Dokument pflegen. Dieser Artikel befasst sich mit den verschiedenen produktiven Methoden zum Vergleichen von Word-Dokumenten und ihren Einschränkungen, um Ihnen bei der Auswahl des besten Ansatzes für Ihre spezifischen Anforderungen zu helfen.

Vergleich von Word-Dokumenten mit Microsoft Word

Microsoft Word bietet eine integrierte Vergleichsfunktion, mit der Benutzer zwei Versionen eines Dokuments nebeneinander vergleichen können. Diese Funktion ist für Benutzer, die mit der Word-Benutzeroberfläche vertraut sind, leicht zugänglich und praktisch.

Um Word-Dokumente mit Microsoft Word zu vergleichen, befolgen Sie bitte die Schritte:

1. Öffnen Sie Microsoft Word und die Access-Vergleichsfunktion : Starten Sie Microsoft Word und öffnen Sie das Originaldokument (oder ein anderes Dokument). Gehen Sie zur Registerkarte "Überprüfen", klicken Sie auf die Schaltfläche "Vergleichen" und wählen Sie dann "Vergleichen…" aus dem Dropdown-Menü.

Compare Word Documents and Find the Differences with User-Friendly Tools

Wählen Sie Originaldokumente und überarbeitete Dokumente aus : Wählen Sie im Dialogfeld "Dokumente vergleichen" mithilfe der Schaltfläche "Durchsuchen" das Originaldokument und das überarbeitete Dokument aus, die Sie vergleichen möchten.

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Einstellungen anpassen (optional) : Klicken Sie auf "Mehr", um Vergleichsoptionen anzupassen, z. B. Groß-/Kleinschreibung einzubeziehen, Formatierungen zu vergleichen oder Leerzeichen zu ignorieren.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Vergleich starten : Klicken Sie im Dialog "Dokumente vergleichen" auf "OK", um den Vergleich zu starten. Word öffnet ein neues Fenster, in dem die Änderungen zwischen der ursprünglichen und der überarbeiteten Version angezeigt werden.

5. Änderungen prüfen und akzeptieren/ablehnen :

  • Überprüfen Sie die hervorgehobenen Änderungen (Löschungen sind durchgestrichen, Ergänzungen sind markiert) im neuen Fenster.
  • Verwenden Sie zum Navigieren die Schaltflächen "Vorherige Änderung" und "Nächste Änderung" (oder Tastaturkürzel).
  • Akzeptieren oder lehnen Sie Änderungen je nach Bedarf über die entsprechenden Schaltflächen oder Kontextmenüoptionen ab.

Compare Word Documents and Find the Differences with User-Friendly Tools

Einschränkungen:

  • Installation kostenpflichtiger Software erforderlich : Um die Vergleichsfunktion nutzen zu können, muss das kostenpflichtige Microsoft Office auf dem Computer installiert sein.
  • Komplexe Schnittstellen : Microsoft Word bietet eine komplexe Schnittstelle zur Verarbeitung von Dokumentenvergleichsergebnissen, die für eine einfache Bearbeitung nicht geeignet ist.

Vergleichen Sie Word-Dokumente mit Google Docs

Google Docs bietet ein leistungsstarkes Tool zum Vergleichen von Dokumenten direkt im Editor. Beachten Sie jedoch, dass die Vergleichsfunktion von Google Docs für das Google Docs-Format konzipiert ist und Word-Dokumente (Doc- oder Docx-Format) nicht direkt vergleichen kann. Um diese Funktion effektiv nutzen zu können, müssen Sie Ihre Word-Dokumente in das Google Docs-Format konvertieren.

Befolgen Sie diese einfachen Schritte, um Google Docs zum Vergleichen von Word-Dokumenten zu nutzen:

1. Laden Sie Word-Dokumente auf Google Drive hoch : Melden Sie sich bei Ihrem Google-Konto an und gehen Sie zu Google Drive . Laden Sie sowohl die Originalversion als auch die überarbeitete Version der Word-Dokumente hoch, indem Sie auf die Schaltfläche "Neu" klicken, "Datei hochladen" auswählen und die entsprechenden Dateien von Ihrem Computer auswählen.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Öffnen Sie die Word-Dokumente mit Google Docs : Klicken Sie nach dem Hochladen mit der rechten Maustaste auf jede Datei und wählen Sie "Öffnen mit" > "Google Docs".

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Konvertieren Sie die Word-Dokumente in das Google Docs-Format : Wählen Sie "Datei" > "Als Google Docs speichern" im Menü des Google Docs-Editors. Die Word-Dokumente werden in das Google Docs-Format konvertiert und im selben Ordner gespeichert.

Die Formatierung kann zwischen den beiden Plattformen leicht variieren. Überprüfen Sie Ihr Dokument und nehmen Sie gegebenenfalls Anpassungen vor.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Greifen Sie auf die Vergleichsfunktion zu : Öffnen Sie das Originaldokument in Google Docs. Gehen Sie zum Menü "Extras" und klicken Sie auf "Dokumente vergleichen".

Compare Word Documents and Find the Differences with User-Friendly Tools

5. Wählen Sie das überarbeitete Dokument aus : Klicken Sie im Dialogfeld "Dokumente vergleichen" auf die Schaltfläche "Datei auswählen". Durchsuchen Sie Ihr Google Drive und wählen Sie das überarbeitete Dokument aus, das Sie mit dem Original vergleichen möchten.

Compare Word Documents and Find the Differences with User-Friendly Tools

6. Starten Sie den Vergleich : Klicken Sie auf "Vergleichen". Google Docs erstellt ein neues zusammengeführtes Dokument. Die in der überarbeiteten Version vorgenommenen Änderungen werden im zusammengeführten Dokument angezeigt und rechts im Editorfenster aufgelistet.

Compare Word Documents and Find the Differences with User-Friendly Tools

7. Änderungen prüfen und akzeptieren/ablehnen: Scrollen Sie durch das zusammengeführte Dokument und akzeptieren oder lehnen Sie Änderungen einzeln ab, indem Sie auf die Änderungselemente klicken und das Häkchen oder Kreuz auswählen.

Einschränkungen:

  • Formatkonvertierung erforderlich : Google Docs kann Word-Dokumente nicht direkt vergleichen. Zum Vergleich ist es notwendig, Word-Dokumente in das Google Docs-Format zu konvertieren, was zu Änderungen in der Inhaltsformatierung führen kann.
  • Kein zweiseitiger Vergleich der Dokumente : Google Docs bietet keine Möglichkeit, zwei Versionen eines Dokuments auf zwei Seiten zu vergleichen, und zeigt die Ergebnisse des Vergleichs nur in einem Dokument an.

Vergleichen Sie Word-Dokumente mit Online-Tools

Neben der Verwendung nativer Software stehen zahlreiche webbasierte Tools zum Vergleichen von Word-Dokumenten zur Verfügung, beispielsweise Draftable Copyleaks. Diese Online-Dienste bieten Komfort und plattformübergreifende Kompatibilität und erfordern oft keine Softwareinstallation. Allerdings bieten Online-Dokumentvergleichstools in der Regel nicht die Möglichkeit, von einem Redakteur vorgenommene Änderungen zu akzeptieren und abzulehnen.

Am Beispiel von Draftable sind die Schritte zum Vergleichen von Dokumenten mit einem Online-Tool wie folgt:

1. Greifen Sie auf die Draftable-Plattform zu : Öffnen Sie den von Draftable bereitgestellten Online-Dokumentenvergleich .

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Word-Dokumente hochladen : Wählen Sie das Originaldokument und das überarbeitete Dokument aus und laden Sie es hoch.

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Vergleichen Sie die Dokumente und erhalten Sie das Ergebnis : Klicken Sie auf "Vergleichen", um die beiden Dokumente zu vergleichen. Das Löschen, Einfügen und Ersetzen wird im Ergebnis angezeigt.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Vergleichsergebnisse prüfen und speichern : Mit dem Tool zum Vergleichen von Dokumenten können Benutzer die Vergleichsergebnisse im PDF-Format speichern und die im Ergebnis angezeigten Änderungstypen filtern.

Compare Word Documents and Find the Differences with User-Friendly Tools

Compare Word Documents and Find the Differences with User-Friendly Tools

Einschränkungen:

  • Keine Funktion zum Akzeptieren oder Abbrechen von Änderungen : Online-Dokumentvergleichstools zeigen normalerweise nur die Unterschiede an und bieten nicht die Möglichkeit, von Redakteuren vorgenommene Änderungen zu akzeptieren und abzubrechen.

Vergleichen Sie Word-Dokumente mit Python-Code

Die Verwendung von Python-Code für den Vergleich von Word-Dokumenten ist ideal für Entwickler und zur Durchführung einer großen Anzahl von Dokumentvergleichsvorgängen. Mit der leistungsstarken Bibliothek Spire.Doc für Python können Entwickler benutzerdefinierte Skripte erstellen, um Word-Dokumente programmgesteuert zu vergleichen, den Prozess zu automatisieren und ihn sogar in größere Workflows oder Anwendungen zu integrieren.

Hier ist eine Schritt-für-Schritt-Anleitung zum Vergleichen von Word-Dokumenten mit Spire.Doc für Python :

  1. Importieren Sie die erforderlichen Module.
  2. Erstellen Sie zwei Instanzen der Document- Klasse.
  3. Laden Sie das ursprüngliche Word-Dokument und das überarbeitete Dokument mit der Methode Document.LoadFromFile() .
  4. Vergleichen Sie die beiden Dokumente mit der Methode Document.Compare(Document: document, str: author) .
  5. Speichern Sie das Vergleichsergebnis mit der Methode Document.SaveToFile() .
  6. Geben Sie Ressourcen frei.
  • Codebeispiel
from spire.doc import *
from spire.doc.common import *

# Create two instances of Document class
originalDoc = Document()
revisedDoc = Document()

# Load two Word documents
originalDoc.LoadFromFile("Invitation.docx")
revisedDoc.LoadFromFile("Revision.docx")

# Compare two documents
originalDoc.Compare(revisedDoc, "Sarah")

# Save the comparison results in a new document
originalDoc.SaveToFile("Output/Differences.docx", FileFormat.Docx2016)

# Release resources
originalDoc.Dispose()
revisedDoc.Dispose()

Compare Word Documents and Find the Differences with User-Friendly Tools

Einschränkungen:

  • Programmiergrundlagen : Der Vergleich von Word-Dokumenten mit Python erfordert vom Benutzer einige grundlegende Programmierkenntnisse.

Abschluss

Zusammenfassend stellt dieser Artikel eine umfassende Untersuchung verschiedener Tools zum Vergleichen von Word-Dokumenten dar und richtet sich an Benutzer mit unterschiedlichen Fähigkeiten und Anforderungen. Es bietet Benutzern eine Schritt-für-Schritt-Anleitung zum Vergleichen von Word-Dokumenten mit Microsoft Word, Google Docs, Online-Tools und Python-Code. Indem der Artikel einen umfassenden Überblick über diese verschiedenen Tools und Techniken bietet, ermöglicht er es den Lesern, die am besten geeignete Methode für den genauen, effizienten und flexiblen Vergleich von Word-Dokumenten auszuwählen.

Siehe auch

Comparar documentos de Word ayuda a los usuarios a identificar y analizar diferencias entre dos versiones de un documento, lo cual es particularmente valioso en contextos profesionales y colaborativos donde las revisiones o actualizaciones deben gestionarse cuidadosamente. Al comparar documentos de Word con herramientas como Microsoft Word, Google Docs, herramientas en línea e incluso enfoques de codificación en Python, los usuarios pueden identificar rápida y fácilmente discrepancias, realizar un seguimiento del progreso y mantener un documento unificado. Este artículo profundiza en los diversos métodos productivos para comparar documentos de Word y sus limitaciones para ayudarlo a elegir el mejor enfoque para sus necesidades específicas.

Comparar documentos de Word con Microsoft Word

Microsoft Word ofrece una función de comparación incorporada que permite a los usuarios comparar dos versiones de un documento una al lado de la otra. Esta característica es fácilmente accesible y conveniente para los usuarios familiarizados con la interfaz de Word.

Para comparar documentos de Word con Microsoft Word, siga los pasos:

1. Abra Microsoft Word y acceda a la función de comparación : inicie Microsoft Word y abra el documento original (o cualquier otro documento). Vaya a la pestaña "Revisar", haga clic en el botón "Comparar" y luego elija "Comparar..." en el menú desplegable.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Seleccione documentos originales y revisados : en el cuadro de diálogo "Comparar documentos", utilice el botón "Examinar" para elegir el documento original y el documento revisado que desea comparar.

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Personalizar configuración (opcional) : haga clic en "Más" para ajustar las opciones de comparación, como incluir cambios de casos, comparar formatos o ignorar espacios en blanco.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Inicie la comparación : haga clic en "Aceptar" en el cuadro de diálogo "Comparar documentos" para iniciar la comparación. Word abrirá una nueva ventana que muestra los cambios entre la versión original y la revisada.

5. Revisar y aceptar/rechazar cambios :

  • Revise los cambios resaltados (las eliminaciones están tachadas, las adiciones están marcadas) en la nueva ventana.
  • Utilice los botones "Cambio anterior" y "Siguiente cambio" (o métodos abreviados de teclado) para navegar.
  • Acepte o rechace los cambios según sea necesario utilizando los botones correspondientes o las opciones del menú contextual.

Compare Word Documents and Find the Differences with User-Friendly Tools

Limitaciones:

  • Se requiere instalación de software pago : Microsoft Office pago debe estar instalado en la computadora para utilizar la función de comparación.
  • Interfaces complejas : Microsoft Word proporciona una interfaz compleja para procesar resultados de comparación de documentos, que no es fácil de editar.

Comparar documentos de Word con Google Docs

Google Docs proporciona una poderosa herramienta para comparar documentos directamente desde su editor. Sin embargo, es importante recordar que la función de comparación de Google Docs está diseñada para funcionar con el formato de Google Docs y no puede comparar directamente documentos de Word (formato Doc o Docx). Para aprovechar esta función de manera efectiva, deberá convertir sus documentos de Word al formato de Google Docs.

Siga estos sencillos pasos para utilizar Google Docs para comparar documentos de Word:

1. Cargue documentos de Word en Google Drive : inicie sesión en su cuenta de Google y vaya a Google Drive . Cargue las versiones original y revisada de los documentos de Word haciendo clic en el botón "Nuevo", seleccionando "Cargar archivo" y eligiendo los archivos respectivos de su computadora.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Abra los documentos de Word con Google Docs : después de cargarlos, haga clic derecho en cada archivo y seleccione "Abrir con" > "Google Docs".

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Convierta los documentos de Word al formato de Google Docs : elija "Archivo" > "Guardar como Google Docs" en el menú del editor de Google Docs y los documentos de Word se convertirán al formato de Google Docs y se guardarán en la misma carpeta.

El formato puede variar ligeramente entre las dos plataformas. Revise su documento y realice los ajustes necesarios.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Acceda a la función Comparar : abra el documento original en Google Docs. Vaya al menú "Herramientas" y haga clic en "Comparar documentos".

Compare Word Documents and Find the Differences with User-Friendly Tools

5. Seleccione el documento revisado : en el cuadro de diálogo "Comparar documentos", haga clic en el botón "Elegir archivo". Explore su Google Drive y seleccione el documento revisado que desea comparar con el original.

Compare Word Documents and Find the Differences with User-Friendly Tools

6. Inicie la comparación : haga clic en "Comparar". Google Docs creará un nuevo documento combinado. Los cambios realizados en la versión revisada se mostrarán en el documento combinado y se enumerarán a la derecha de la ventana del editor.

Compare Word Documents and Find the Differences with User-Friendly Tools

7. Revisar y aceptar/rechazar cambios: desplácese por el documento combinado y acepte o rechace los cambios individualmente haciendo clic en los elementos de cambio y eligiendo la marca o cruz.

Limitaciones:

  • Se necesita conversión de formato : Google Docs no puede comparar directamente documentos de Word. Es necesario convertir documentos de Word al formato de Google Docs para compararlos, lo que puede provocar cambios en el formato del contenido.
  • No hay comparación de dos caras para los documentos : Google Docs no ofrece la posibilidad de comparar dos versiones de un documento en dos caras y solo muestra los resultados de la comparación en un documento.

Comparar documentos de Word con herramientas en línea

Además de utilizar software nativo, existen numerosas herramientas basadas en web disponibles para comparar documentos de Word, como Draftable Copyleaks. Estos servicios en línea ofrecen comodidad y compatibilidad multiplataforma y, a menudo, no requieren instalación de software. Sin embargo, las herramientas de comparación de documentos en línea generalmente no ofrecen la posibilidad de aceptar y rechazar los cambios que trae un editor.

Usando Draftable como ejemplo, los pasos para comparar documentos usando una herramienta en línea son los siguientes:

1. Acceda a la plataforma Draftable : abra el comparador de documentos en línea proporcionado por Draftable.

Compare Word Documents and Find the Differences with User-Friendly Tools

2. Cargar documentos de Word : elija y cargue el documento original y el documento revisado.

Compare Word Documents and Find the Differences with User-Friendly Tools

3. Compare los documentos y obtenga el resultado : haga clic en "Comparar" para comparar los dos documentos. La eliminación, inserción y reemplazo se mostrarán en el resultado.

Compare Word Documents and Find the Differences with User-Friendly Tools

4. Revisar y guardar los resultados de la comparación : la herramienta de comparación de documentos que se puede redactar permite a los usuarios guardar el resultado de la comparación en formato PDF y filtrar los tipos de cambios que se muestran en el resultado.

Compare Word Documents and Find the Differences with User-Friendly Tools

Compare Word Documents and Find the Differences with User-Friendly Tools

Limitaciones :

  • No hay función para aceptar o cancelar cambios : las herramientas de comparación de documentos en línea generalmente solo muestran las diferencias y no brindan la posibilidad de aceptar y cancelar los cambios que brindan los editores.

Comparar documentos de Word con código Python

El uso de código Python para comparar documentos de Word es ideal para desarrolladores y para realizar una gran cantidad de operaciones de comparación de documentos. Con la poderosa biblioteca Spire.Doc para Python, los desarrolladores pueden crear scripts personalizados para comparar documentos de Word mediante programación, automatizar el proceso e incluso integrarlo en flujos de trabajo o aplicaciones más grandes.

Aquí hay una guía paso a paso sobre cómo comparar documentos de Word usando Spire.Doc para Python :

  1. Importe los módulos necesarios.
  2. Cree dos instancias de la clase Documento .
  3. Cargue el documento de Word original y el documento revisado utilizando el método Document.LoadFromFile() .
  4. Compare los dos documentos utilizando el método Document.Compare(Document: document, str:author) .
  5. Guarde el resultado de la comparación utilizando el método Document.SaveToFile() .
  6. Liberar recursos.
  • Ejemplo de código
from spire.doc import *
from spire.doc.common import *

# Create two instances of Document class
originalDoc = Document()
revisedDoc = Document()

# Load two Word documents
originalDoc.LoadFromFile("Invitation.docx")
revisedDoc.LoadFromFile("Revision.docx")

# Compare two documents
originalDoc.Compare(revisedDoc, "Sarah")

# Save the comparison results in a new document
originalDoc.SaveToFile("Output/Differences.docx", FileFormat.Docx2016)

# Release resources
originalDoc.Dispose()
revisedDoc.Dispose()

Compare Word Documents and Find the Differences with User-Friendly Tools

Limitaciones:

  • Conceptos básicos de programación : comparar documentos de Word usando Python requiere que el usuario tenga algunas habilidades básicas de programación.

Conclusión

En resumen, este artículo presenta una exploración exhaustiva de varias herramientas para comparar documentos de Word , dirigidas a usuarios con diversos niveles de habilidades y requisitos. Ofrece guía paso a paso para que los usuarios comparen documentos de Word con Microsoft Word, Google Docs, herramientas en línea y código Python. Al proporcionar una descripción general completa de estas diversas herramientas y técnicas, el artículo permite a los lectores elegir el método más adecuado para comparar documentos de Word de manera precisa, eficiente y flexible.

Ver también