Aspose.Words Document Object Model (DOM)

Aspose.Words Document Object Model (DOM) adalah representasi dokumen Word dalam memori. Aspose.Words DOM memungkinkan Anda membaca, memanipulasi, dan memodifikasi konten dan format dokumen Word secara terprogram.

Bagian ini menjelaskan kelas utama Aspose.Words DOM dan hubungannya. Dengan menggunakan kelas Aspose.Words DOM, Anda bisa mendapatkan akses terprogram ke elemen dan pemformatan dokumen.

Buat {#create-a-document-objects-tree} Pohon Objek Document

Ketika sebuah dokumen dibaca ke dalam Aspose.Words DOM, maka pohon objek dibangun dan berbagai jenis elemen dokumen sumber memiliki objek pohon DOM sendiri dengan berbagai properti.

Bangun Pohon Node Dokumen

Saat Aspose.Words membaca dokumen Word ke dalam memori, Aspose.Words membuat objek dengan tipe berbeda yang mewakili berbagai elemen dokumen. Setiap rangkaian teks, paragraf, tabel, atau bagian adalah sebuah simpul, dan bahkan dokumen itu sendiri adalah sebuah simpul. Aspose.Words mendefinisikan kelas untuk setiap tipe node dokumen.

Pohon dokumen di Aspose.Words mengikuti Pola Desain Komposit:

• Semua kelas node pada akhirnya berasal dari kelas Node, yang merupakan kelas dasar dalam Document Object Model Aspose.Words.
• Node yang dapat berisi node lain, misalnya Section atau Paragraph, berasal dari kelas CompositeNode, yang selanjutnya berasal dari kelas Node.

Diagram di bawah ini menunjukkan pewarisan antar kelas node Aspose.Words Document Object Model (DOM). Nama kelas abstrak dicetak miring.

Aspose.Words DOM juga berisi kelas non-node, seperti Style atau Font, yang digunakan untuk menyesuaikan tampilan dan gaya dalam dokumen. Kelas-kelas ini tidak ditampilkan dalam diagram ini karena tidak diwarisi dari kelas Node.

Mari kita lihat sebuah contoh. Gambar berikut menunjukkan dokumen Microsoft Word dengan tipe konten berbeda.

Saat membaca dokumen di atas ke dalam Aspose.Words DOM, pohon objek dibuat, seperti yang ditunjukkan pada skema di bawah ini.

Document, Section, Paragraph, Table, Shape, Run, dan semua elips lainnya pada diagram adalah objek Aspose.Words yang mewakili elemen dokumen Word.

Dapatkan Node Tipe

Meskipun kelas Node cukup memadai untuk membedakan node yang berbeda satu sama lain, Aspose.Words menyediakan enumerasi NodeType untuk menyederhanakan beberapa tugas API, seperti memilih node dengan tipe tertentu.

Jenis setiap node dapat diperoleh dengan menggunakan properti Node.node_type. Properti ini mengembalikan nilai enumerasi NodeType. Misalnya, node paragraf yang diwakili oleh kelas Paragraph mengembalikan NodeType.PARAGRAPH, dan node tabel yang diwakili oleh kelas Table mengembalikan NodeType.TABLE.

Contoh berikut menunjukkan cara mendapatkan tipe node menggunakan enumerasi NodeType:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET
doc = aw.Document()
    
type = doc.node_type

Navigasi Pohon Dokumen

Aspose.Words mewakili dokumen sebagai pohon simpul, yang memungkinkan Anda bernavigasi antar simpul. Bagian ini menjelaskan cara menjelajahi dan menavigasi pohon dokumen di Aspose.Words.

Saat Anda membuka dokumen sampel, yang disajikan sebelumnya, di Penjelajah Dokumen, pohon simpul muncul persis seperti yang direpresentasikan dalam Aspose.Words.

Anda dapat mempelajari contoh proyek “Document Explorer” di Aspose.Words GitHub.

Hubungan Node Dokumen

Node-node pada pohon mempunyai hubungan di antara mereka:

• Sebuah node yang berisi node lain adalah parent.
• Node yang terdapat pada node induk adalah child. Node anak dari induk yang sama adalah node sibling.
• Node root selalu merupakan node Document.

Node yang dapat berisi node lain berasal dari kelas CompositeNode, dan semua node pada akhirnya berasal dari kelas Node. Kedua kelas dasar ini menyediakan metode dan properti umum untuk navigasi dan modifikasi struktur pohon.

Diagram objek UML berikut memperlihatkan beberapa node dari dokumen sampel dan hubungannya satu sama lain melalui properti induk, anak, dan saudara:

Dokumen adalah Pemilik Node

Sebuah node selalu menjadi milik dokumen tertentu, meskipun baru saja dibuat atau dihapus dari pohon, karena struktur penting seluruh dokumen seperti gaya dan daftar disimpan di node Document. Misalnya, tidak mungkin memiliki Paragraph tanpa Document karena setiap paragraf memiliki gaya yang ditentukan secara global untuk dokumen tersebut. Aturan ini digunakan saat membuat node baru. Menambahkan Paragraph baru langsung ke DOM memerlukan objek dokumen yang diteruskan ke konstruktor.

Properti Node.document mengembalikan dokumen milik node tersebut.

Saat membuat paragraf baru menggunakan DocumentBuilder, pembuatnya selalu memiliki kelas Document yang ditautkan melalui properti DocumentBuilder.document.

Contoh kode berikut menunjukkan bahwa saat membuat node apa pun, dokumen yang akan memiliki node tersebut selalu ditentukan:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET
doc = aw.Document()

# Creating a new node of any type requires a document passed into the constructor.
para = aw.Paragraph(doc)

# The new paragraph node does not yet have a parent.
print(f"Paragraph has no parent node: {para.parent_node == None}")

# But the paragraph node knows its document.
print(f"Both nodes' documents are the same: {para.document == doc}")

# The fact that a node always belongs to a document allows us to access and modify
# properties that reference the document-wide data, such as styles or lists.
para.paragraph_format.style_name = "Heading 1"

# Now add the paragraph to the main text of the first section.
doc.first_section.body.append_child(para)

# The paragraph node is now a child of the Body node.
print(f"Paragraph has a parent node: {para.parent_node != None}")

Node Induk

Setiap node memiliki induk yang ditentukan oleh properti parent_node. Sebuah node tidak memiliki node induk, yaitu parent_node adalah None, dalam kasus berikut:

• Node baru saja dibuat dan belum ditambahkan ke pohon.
• Node telah dihapus dari pohon.
• Ini adalah node root Document yang selalu memiliki node induk Tidak Ada.

Anda dapat menghapus sebuah node dari induknya dengan memanggil metode Node.remove. Contoh kode berikut menunjukkan cara mengakses node induk:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET
doc = aw.Document()

# The section is the first child node of the document.
section = doc.first_child

# The section's parent node is the document.
print(f"Section parent is the document: {doc == section.parent_node}")

Node Anak

Cara paling efisien untuk mengakses node anak CompositeNode adalah melalui properti first_child dan last_child yang masing-masing mengembalikan node anak pertama dan terakhir. Jika tidak ada node anak, properti ini mengembalikan None.

CompositeNode juga menyediakan koleksi get_child_nodes yang memungkinkan akses yang diindeks atau dihitung ke node anak. Metode get_child_nodes mengembalikan kumpulan node yang aktif, yang berarti setiap kali dokumen diubah, misalnya saat node dihapus atau ditambahkan, koleksi dapatkan_child_nodes secara otomatis diperbarui.

Jika sebuah node tidak memiliki anak, maka metode dapatkan_child_nodes mengembalikan koleksi kosong. Anda dapat memeriksa apakah CompositeNode berisi node anak menggunakan properti has_child_nodes.

Contoh kode berikut menunjukkan cara menghitung node anak langsung dari CompositeNode menggunakan enumerator yang disediakan oleh koleksi dapatkan_child_nodes:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET
doc = aw.Document()
paragraph = doc.get_child(aw.NodeType.PARAGRAPH, 0, True).as_paragraph()

children = paragraph.child_nodes
for child in children :
    
    # A paragraph may contain children of various types such as runs, shapes, and others.
    if child.node_type == aw.NodeType.RUN :
        
        run = child.as_run()
        print(run.text)
        
    

Node Saudara

Anda bisa mendapatkan node yang mendahului atau mengikuti node tertentu menggunakan properti previous_sibling dan next_sibling. Jika sebuah node adalah anak terakhir dari induknya, maka properti next_sibling adalah None. Sebaliknya, jika node adalah anak pertama dari induknya, properti previous_sibling-nya adalah None.

Contoh kode berikut menunjukkan cara mengunjungi semua node turunan langsung dan tidak langsung dari node komposit secara efisien:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET
def test_recurse_all_nodes(self) :
    
    doc = aw.Document(docs_base.my_dir + "Paragraphs.docx")

    # Invoke the recursive function that will walk the tree.
    self.traverse_all_nodes(doc)
    

# <summary>
# A simple function that will walk through all children of a specified node recursively 
# and print the type of each node to the screen.
# </summary>
def traverse_all_nodes(self, parentNode) :
    
    # This is the most efficient way to loop through immediate children of a node.
    for childNode in parentNode.child_nodes :
        
        print(aw.Node.node_type_to_string(childNode.node_type))

        # Recurse into the node if it is a composite node.
        if childNode.is_composite :
            self.traverse_all_nodes(childNode.as_composite_node())
        
    

Akses yang Diketik ke Node Anak dan Induk

Sejauh ini, kita telah membahas properti yang mengembalikan salah satu tipe dasar – Node atau CompositeNode. Namun terkadang ada situasi di mana Anda mungkin perlu memberikan nilai ke kelas node tertentu, seperti Run atau Paragraph. Artinya, Anda tidak dapat sepenuhnya melepaskan diri dari casting saat bekerja dengan Aspose.Words DOM, yang merupakan komposit.

Untuk mengurangi kebutuhan casting, sebagian besar kelas Aspose.Words menyediakan properti dan koleksi yang menyediakan akses yang diketik dengan kuat. Ada tiga pola dasar akses yang diketik:

• Node induk memperlihatkan properti pertama_XXX dan terakhir_XXX yang diketik. Misalnya, Document memiliki properti first_section dan last_section. Begitu pula Table yang memiliki properti seperti first_row, last_row, dan lain-lain.
• Node induk memperlihatkan kumpulan node anak yang diketik, seperti Document.sections, Body.paragraphs, dan lainnya.
• Node anak memberikan akses yang diketik ke induknya, seperti Run.parent_paragraph, Paragraph.parent_section, dan lainnya.

Properti yang diketik hanyalah pintasan berguna yang terkadang memberikan akses lebih mudah daripada properti umum yang diwarisi dari Node.parent_node dan CompositeNode.first_child.

Contoh kode berikut menunjukkan cara menggunakan properti yang diketik untuk mengakses node pohon dokumen:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET
doc = aw.Document()

section = doc.first_section
body = section.body
    
# Quick typed access to all Table child nodes contained in the Body.
tables = body.tables

for table in tables :
    
    # Quick typed access to the first row of the table.
    if table.first_row != None :
        table.first_row.remove()

    # Quick typed access to the last row of the table.
    if table.last_row != None :
        table.last_row.remove()