Documenten invoegen en toevoegen

Soms is het nodig om meerdere documenten te combineren in een. U kunt dit handmatig of u kunt gebruiken Aspose.Words functie invoegen of toevoegen.

Met de invoegoperatie kunt u de inhoud van eerder aangemaakte documenten in een nieuwe of bestaande invoegen.

Met de functie toevoegen kunt u een document alleen aan het einde van een ander document toevoegen.

Dit artikel legt uit hoe je een document op verschillende manieren invoegt of toevoegt aan een ander en beschrijft de gemeenschappelijke eigenschappen die je kunt toepassen tijdens het invoegen of toevoegen van documenten.

Document invoegen

Zoals hierboven vermeld, in Aspose.Words een document wordt weergegeven als een boom van knooppunten, en de werking van het invoegen van een document in een ander document is het kopiëren van knooppunten van de eerste documentboom naar de tweede.

U kunt documenten op verschillende locaties op verschillende manieren invoegen. U kunt bijvoorbeeld een document invoegen via een vervangende bewerking, een merge-veld tijdens een merge-operatie of via een bladwijzer.

U kunt ook de insert_document of insert_document_inline methode, die lijkt op het invoegen van een document in Microsoft Word, om een heel document in te voegen op de huidige cursorpositie zonder eerdere import.

Het volgende voorbeeld van code laat zien hoe een document met behulp van de _document invoegen methode:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
src_doc = aw.Document(MY_DIR + "Document source.docx")
dst_doc = aw.Document(MY_DIR + "Northwind traders.docx")
builder = aw.DocumentBuilder(dst_doc)

builder.move_to_document_end()
builder.insert_break(aw.BreakType.PAGE_BREAK)

builder.insert_document(src_doc, aw.ImportFormatMode.KEEP_SOURCE_FORMATTING)
builder.document.save(ARTIFACTS_DIR + "JoinAndAppendDocuments.insert_document.docx")

Het volgende voorbeeld van code laat zien hoe een document met behulp van de invoegen_document_inline methode:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
src_doc = aw.DocumentBuilder()
src_doc.write("[src content]")

# Create destination document.
dst_doc = aw.DocumentBuilder()
dst_doc.write("Before ")
dst_doc.insert_node(aw.BookmarkStart(dst_doc.document, "src_place"))
dst_doc.insert_node(aw.BookmarkEnd(dst_doc.document, "src_place"))
dst_doc.write(" after")

self.assertEqual("Before  after", dst_doc.document.get_text().strip())

# Insert source document into destination inline.
dst_doc.move_to_bookmark("src_place")
dst_doc.insert_document_inline(src_doc.document, aw.ImportFormatMode.USE_DESTINATION_STYLES, aw.ImportFormatOptions())

self.assertEqual("Before [src content] after", dst_doc.document.get_text().strip())

De volgende subsecties beschrijven de opties waarin u het ene document in een ander kunt invoegen.

Een document invoegen bij bladwijzer

U kunt een tekstbestand importeren in een document en het direct invoegen na een bladwijzer die u in het document hebt gedefinieerd. Om dit te doen, maak een paragraaf met bladwijzers waar u wilt dat het document wordt ingevoegd.

Het volgende coderingsvoorbeeld laat zien hoe je de inhoud van het ene document in een bladwijzer in een ander document invoegt:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
main_doc = aw.Document(MY_DIR + "Document insertion 1.docx")
sub_doc = aw.Document(MY_DIR + "Document insertion 2.docx")

bookmark = main_doc.range.bookmarks.get_by_name("insertionPlace")
self.insert_document(bookmark.bookmark_start.parent_node, sub_doc)

main_doc.save(ARTIFACTS_DIR + "CloneAndCombineDocuments.insert_document_at_bookmark.docx")

Merk op dat de bladwijzer niet meerdere alinea’s of tekst moet omsluiten die u wilt dat ze verschijnen in uw uiteindelijke resulterende document.

Een document toevoegen

U kunt een use case hebben waarin u extra pagina’s moet opnemen van een document tot het einde van een bestaand document. Om dit te doen, moet je gewoon de append_document methode om een document aan het einde van een ander document toe te voegen.

Merk op dat append_child is een nodeniveau methode binnen een document. U kunt bijvoorbeeld een alinea maken, formatteren eigenschappen instellen, en vervolgens toevoegen als een kind aan het lichaam met behulp van de append_child methode.

Het volgende voorbeeld van code laat zien hoe je een document toevoegt aan het einde van een ander document:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
dst_doc = aw.Document()
dst_doc.first_section.body.append_paragraph("Destination document text. ")

src_doc = aw.Document()
src_doc.first_section.body.append_paragraph("Source document text. ")

# Append the source document to the destination document.
# Pass format mode to retain the original formatting of the source document when importing it.
dst_doc.append_document(src_doc, aw.ImportFormatMode.KEEP_SOURCE_FORMATTING)

dst_doc.save(ARTIFACTS_DIR + "JoinAndAppendDocuments.keep_source_formatting.docx")

Knoppen handmatig importeren en invoegen

Aspose.Words Hiermee kunt u documenten automatisch invoegen en toevoegen zonder eerdere importvereisten. Echter, als u een specifieke node van uw document moet invoegen of toevoegen, zoals een sectie of een paragraaf, dan moet u eerst deze node handmatig importeren.

Wanneer u een sectie of paragraaf moet invoegen of toevoegen aan een andere paragraaf, moet u in wezen de knooppunten van de eerste document node boom importeren in de tweede met behulp van de import_node methode. Na het importeren van uw knooppunten, moet u de insert_after ' insert_before methode om een nieuwe knoop in te voegen na/voor het referentieknooppunt. Hiermee kunt u het invoegproces aanpassen door knooppunten uit een document te importeren en het op bepaalde posities in te voegen.

U kunt ook de append_child methode om een nieuw gespecificeerd knooppunt toe te voegen aan het einde van de lijst van kindknooppunten, bijvoorbeeld als u inhoud wilt toevoegen op paragraafniveau in plaats van op sectieniveau.

Het volgende voorbeeld van code laat zien hoe u handmatig knooppunten importeren en invoegen na een specifieke knooppunt met behulp van de insert_after methode:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
@staticmethod
def insert_document(insertion_destination: aw.Node, doc_to_insert: aw.Document):
    """Inserts content of the external document after the specified node.
    Section breaks and section formatting of the inserted document are ignored.

   :param insertion_destination: Node in the destination document after which the content
        Should be inserted. This node should be a block level node (paragraph or table).
   :param doc_to_insert: The document to insert.
    """

    if insertion_destination.node_type not in (aw.NodeType.PARAGRAPH, aw.NodeType.TABLE):
        raise ValueError("The destination node should be either a paragraph or table.")

    destination_parent = insertion_destination.parent_node

    importer = aw.NodeImporter(doc_to_insert, insertion_destination.document, aw.ImportFormatMode.KEEP_SOURCE_FORMATTING)

    # Loop through all block-level nodes in the section's body,
    # then clone and insert every node that is not the last empty paragraph of a section.
    for src_section in doc_to_insert.sections:
        for src_node in src_section.as_section().body.get_child_nodes(aw.NodeType.ANY, False):
            if src_node.node_type == aw.NodeType.PARAGRAPH:
                para = src_node.as_paragraph()
                if para.is_end_of_section and not para.has_child_nodes:
                    continue

            new_node = importer.import_node(src_node, True)

            destination_parent.insert_after(new_node, insertion_destination)
            insertion_destination = new_node

De import maakt een nieuwe node aan die een kopie is van de originele node en geschikt is voor invoeging in het bestemmingsdocument.

Inhoud wordt per sectie in het document van bestemming geïmporteerd, wat betekent dat instellingen, zoals pagina-instellingen en headers of voetteksten, behouden blijven tijdens import. Het is ook handig om op te merken dat u formatteringsinstellingen kunt definiëren wanneer u een document invoegt of toevoegt om aan te geven hoe twee documenten worden samengevoegd.

Gemeenschappelijke eigenschappen voor invoegen en toevoegen van documenten

Beide insert_document en append_document methoden accepteren ImportFormatMode en ImportFormatOptions als inputparameters. De ImportFormatMode kunt u controleren hoe documentopmaak wordt samengevoegd wanneer u inhoud importeren van het ene document in het andere door het selecteren van verschillende indelingsmodi zoals USE_DESTINATION_STYLES, KEEP_SOURCE_FORMATTING, en KEEP_DIFFERENT_STYLES. De ImportFormatOptions stelt u in staat om verschillende opties te selecteren, zoals ignore_header_footer, ignore_text_boxes, keep_source_numbering, merge_pasted_lists, en smart_style_behavior.

Aspose.Words stelt u in staat om de visualisatie van een resulterend document aan te passen wanneer twee documenten samen worden toegevoegd in een invoeg- of voegbewerking door gebruik te maken van de Section en PageSetup. De page_setup eigenschap bevat alle eigenschappen van een sectie zoals section_start restart_page_numbering, page_starting_number, orientation, en anderen. De meest voorkomende use case is het instellen van de section_start eigenschap om te bepalen of de toegevoegde inhoud op dezelfde pagina zal verschijnen of in een nieuwe zal splitsen.

Merk op dat de Section en PageSetup niet bepalen hoe twee documenten samen worden ingevoegd/toegevoegd. Ze laten je alleen toe om het uiterlijk van je resultaatdocument te veranderen.

Het volgende voorbeeld van code laat zien hoe het ene document aan het andere kan worden toegevoegd, terwijl de inhoud niet over twee pagina’s kan worden gesplitst:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
src_doc = aw.Document(MY_DIR + "Document source.docx")
dst_doc = aw.Document(MY_DIR + "Northwind traders.docx")

# Set the source document to continue straight after the end of the destination document.
src_doc.first_section.page_setup.section_start = aw.SectionStart.CONTINUOUS

# Restart the page numbering on the start of the source document.
src_doc.first_section.page_setup.restart_page_numbering = True
src_doc.first_section.page_setup.page_starting_number = 1

# To ensure this does not happen when the source document has different page setup settings, make sure the
# settings are identical between the last section of the destination document.
# If there are further continuous sections that follow on in the source document,
# this will need to be repeated for those sections.
src_doc.first_section.page_setup.page_width = dst_doc.last_section.page_setup.page_width
src_doc.first_section.page_setup.page_height = dst_doc.last_section.page_setup.page_height
src_doc.first_section.page_setup.orientation = dst_doc.last_section.page_setup.orientation

# Iterate through all sections in the source document.
for para in src_doc.get_child_nodes(aw.NodeType.PARAGRAPH, True):
    para = para.as_paragraph()
    para.paragraph_format.keep_with_next = True

dst_doc.append_document(src_doc, aw.ImportFormatMode.KEEP_SOURCE_FORMATTING)

dst_doc.save(ARTIFACTS_DIR + "JoinAndAppendDocuments.different_page_setup.docx")