Einführung und Tabellenerstellung

Aspose.Words ermöglicht Benutzern das Erstellen von Tabellen in einem Dokument von Grund auf und bietet hierfür verschiedene Methoden. Dieser Artikel enthält Einzelheiten zum Hinzufügen formatierter Tabellen zu Ihrem Dokument mit den einzelnen Methoden sowie einen Vergleich der einzelnen Methoden am Ende des Artikels.

Standardtabellenstile

Die neu erstellte Tabelle erhält Standardwerte, die denen in Microsoft Word ähneln:

Tabelleneigenschaft Standard in Aspose.Words
Border Style Single
Border Width 1/2 pt
Border Color Black
Left and Right Padding 5.4 pts
AutoFit Mode AutoFit to Window
Allow AutoFit True

Erstellen Sie eine Tabelle mit DocumentBuilder

In Aspose.Words können Benutzer mithilfe von DocumentBuilder eine Tabelle in einem Dokument erstellen. Der grundlegende Algorithmus zum Erstellen einer Tabelle ist wie folgt:

  1. Starten Sie die Tabelle mit StartTable
  2. Fügen Sie mit InsertCell eine Zelle zur Tabelle hinzu – dadurch beginnt automatisch eine neue Zeile
  3. Optional können Sie die CellFormat-Eigenschaft verwenden, um die Zellformatierung anzugeben
  4. Fügen Sie den Zellinhalt mit den entsprechenden DocumentBuilder-Methoden wie Writeln, InsertImage und anderen ein
  5. Wiederholen Sie die Schritte 2–4, bis die Reihe vollständig ist
  6. Rufen Sie EndRow auf, um die aktuelle Zeile zu beenden
  7. Optional können Sie die RowFormat-Eigenschaft verwenden, um die Zeilenformatierung anzugeben
  8. Wiederholen Sie die Schritte 2–7, bis die Tabelle vollständig ist
  9. Rufen Sie EndTable auf, um den Aufbau der Tabelle abzuschließen

Der Prozess der Tabellenerstellung ist im folgenden Bild deutlich zu erkennen:

Erstellungstabellenprozess

Das folgende Codebeispiel zeigt, wie Sie mit DocumentBuilder eine einfache Tabelle mit Standardformatierung erstellen:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
# Start building the table.
builder.start_table()
builder.insert_cell()
builder.write("Row 1, Cell 1 Content.")
# Build the second cell.
builder.insert_cell()
builder.write("Row 1, Cell 2 Content.")
# Call the following method to end the row and start a new row.
builder.end_row()
# Build the first cell of the second row.
builder.insert_cell()
builder.write("Row 2, Cell 1 Content")
# Build the second cell.
builder.insert_cell()
builder.write("Row 2, Cell 2 Content.")
builder.end_row()
# Signal that we have finished building the table.
builder.end_table()
doc.save(ARTIFACTS_DIR + "WorkingWithTables.create_simple_table.docx")

Das folgende Codebeispiel zeigt, wie Sie mit DocumentBuilder eine formatierte Tabelle erstellen:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
table = builder.start_table()
builder.insert_cell()
# Table wide formatting must be applied after at least one row is present in the table.
table.left_indent = 20.0
# Set height and define the height rule for the header row.
builder.row_format.height = 40.0
builder.row_format.height_rule = aw.HeightRule.AT_LEAST
builder.cell_format.shading.background_pattern_color = drawing.Color.from_argb(198, 217, 241)
builder.paragraph_format.alignment = aw.ParagraphAlignment.CENTER
builder.font.size = 16
builder.font.name = "Arial"
builder.font.bold = True
builder.cell_format.width = 100.0
builder.write("Header Row,\n Cell 1")
# We don't need to specify this cell's width because it's inherited from the previous cell.
builder.insert_cell()
builder.write("Header Row,\n Cell 2")
builder.insert_cell()
builder.cell_format.width = 200.0
builder.write("Header Row,\n Cell 3")
builder.end_row()
builder.cell_format.shading.background_pattern_color = drawing.Color.white
builder.cell_format.width = 100.0
builder.cell_format.vertical_alignment = aw.tables.CellVerticalAlignment.CENTER
# Reset height and define a different height rule for table body.
builder.row_format.height = 30.0
builder.row_format.height_rule = aw.HeightRule.AUTO
builder.insert_cell()
# Reset font formatting.
builder.font.size = 12
builder.font.bold = False
builder.write("Row 1, Cell 1 Content")
builder.insert_cell()
builder.write("Row 1, Cell 2 Content")
builder.insert_cell()
builder.cell_format.width = 200.0
builder.write("Row 1, Cell 3 Content")
builder.end_row()
builder.insert_cell()
builder.cell_format.width = 100.0
builder.write("Row 2, Cell 1 Content")
builder.insert_cell()
builder.write("Row 2, Cell 2 Content")
builder.insert_cell()
builder.cell_format.width = 200.0
builder.write("Row 2, Cell 3 Content.")
builder.end_row()
builder.end_table()
doc.save(ARTIFACTS_DIR + "WorkingWithTables.formatted_table.docx")

Das folgende Codebeispiel zeigt, wie Sie mit DocumentBuilder eine verschachtelte Tabelle einfügen:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
cell = builder.insert_cell()
builder.writeln("Outer Table Cell 1")
builder.insert_cell()
builder.writeln("Outer Table Cell 2")
# This call is important to create a nested table within the first table.
# Without this call, the cells inserted below will be appended to the outer table.
builder.end_table()
# Move to the first cell of the outer table.
builder.move_to(cell.first_paragraph)
# Build the inner table.
builder.insert_cell()
builder.writeln("Inner Table Cell 1")
builder.insert_cell()
builder.writeln("Inner Table Cell 2")
builder.end_table()
doc.save(ARTIFACTS_DIR + "WorkingWithTables.nested_table.docx")
view raw nested-table.py hosted with ❤ by GitHub

Erstellen Sie eine Tabelle über DOM (Document Object Model)

Sie können Tabellen direkt in das DOM einfügen, indem Sie an einer bestimmten Position einen neuen Table-Knoten hinzufügen.

Bitte beachten Sie, dass unmittelbar nach der Erstellung des Tabellenknotens die Tabelle selbst vollständig leer ist, also noch keine Zeilen und Zellen enthält. Um Zeilen und Zellen in eine Tabelle einzufügen, fügen Sie die entsprechenden untergeordneten Row- und Cell-Knoten zum DOM hinzu.

Das folgende Codebeispiel zeigt, wie Sie eine neue Tabelle von Grund auf erstellen, indem Sie der Dokumentstruktur die entsprechenden untergeordneten Knoten hinzufügen:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
doc = aw.Document()
# We start by creating the table object. Note that we must pass the document object
# to the constructor of each node. This is because every node we create must belong
# to some document.
table = aw.tables.Table(doc)
doc.first_section.body.append_child(table)
# Here we could call EnsureMinimum to create the rows and cells for us. This method is used
# to ensure that the specified node is valid. In this case, a valid table should have at least one Row and one cell.
# Instead, we will handle creating the row and table ourselves.
# This would be the best way to do this if we were creating a table inside an algorithm.
row = aw.tables.Row(doc)
row.row_format.allow_break_across_pages = True
table.append_child(row)
# We can now apply any auto fit settings.
table.auto_fit(aw.tables.AutoFitBehavior.FIXED_COLUMN_WIDTHS)
cell = aw.tables.Cell(doc)
cell.cell_format.shading.background_pattern_color = drawing.Color.light_blue
cell.cell_format.width = 80
cell.append_child(aw.Paragraph(doc))
cell.first_paragraph.append_child(aw.Run(doc, "Row 1, Cell 1 Text"))
row.append_child(cell)
# We would then repeat the process for the other cells and rows in the table.
# We can also speed things up by cloning existing cells and rows.
row.append_child(cell.clone(False))
row.last_cell.append_child(aw.Paragraph(doc))
row.last_cell.first_paragraph.append_child(aw.Run(doc, "Row 1, Cell 2 Text"))
doc.save(ARTIFACTS_DIR + "WorkingWithTables.insert_table_directly.docx")

##Create eine Tabelle aus HTML

Aspose.Words unterstützt das Einfügen von Inhalten aus einer HTML-Quelle in ein Dokument mithilfe der InsertHtml-Methode. Die Eingabe kann eine vollständige HTML-Seite oder nur ein Teilausschnitt sein.

Mit der InsertHtml-Methode können Benutzer Tabellen über Tabellen-Tags wie <table>, <tr>, <td> in das Dokument einfügen.

Das folgende Codebeispiel zeigt, wie Sie aus einer Zeichenfolge mit HTML-Tags eine Tabelle in ein Dokument einfügen:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
# Note that AutoFitSettings does not apply to tables inserted from HTML.
builder.insert_html("<table>" +
"<tr>" +
"<td>Row 1, Cell 1</td>" +
"<td>Row 1, Cell 2</td>" +
"</tr>" +
"<tr>" +
"<td>Row 2, Cell 2</td>" +
"<td>Row 2, Cell 2</td>" +
"</tr>" +
"</table>")
doc.save(ARTIFACTS_DIR + "WorkingWithTables.insert_table_from_html.docx")

Fügen Sie eine Kopie einer vorhandenen Tabelle ein

Es kommt häufig vor, dass Sie eine Tabelle basierend auf einer bereits vorhandenen Tabelle in einem Dokument erstellen müssen. Der einfachste Weg, eine Tabelle zu duplizieren und dabei die gesamte Formatierung beizubehalten, besteht darin, den Tabellenknoten mithilfe der Clone-Methode zu klonen.

Die gleiche Technik kann verwendet werden, um einer Tabelle Kopien einer vorhandenen Zeile oder Zelle hinzuzufügen.

Das folgende Codebeispiel zeigt, wie eine Tabelle mithilfe von Knotenkonstruktoren dupliziert wird:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
# Clone the table and insert it into the document after the original.
table_clone = table.clone(True).as_table()
table.parent_node.insert_after(table_clone, table)
# Insert an empty paragraph between the two tables,
# or else they will be combined into one upon saving this has to do with document validation.
table.parent_node.insert_after(aw.Paragraph(doc), table)
doc.save(ARTIFACTS_DIR + "WorkingWithTables.clone_complete_table.docx")

Das folgende Codebeispiel zeigt, wie Sie die letzte Zeile einer Tabelle klonen und an die Tabelle anhängen:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
cloned_row = table.last_row.clone(True).as_row()
# Remove all content from the cloned row's cells. This makes the row ready for new content to be inserted into.
for cell in cloned_row.cells:
cell = cell.as_cell()
cell.remove_all_children()
table.append_child(cloned_row)
doc.save(ARTIFACTS_DIR + "WorkingWithTables.clone_last_row.docx")

Wenn Sie Tabellen in einem Dokument erstellen möchten, die mit jedem Datensatz aus Ihrer Datenquelle dynamisch wachsen, ist die oben beschriebene Methode nicht zu empfehlen. Stattdessen lässt sich die gewünschte Ausgabe einfacher erreichen, indem Mail merge mit Regionen verwendet wird.

Vergleichen Sie Möglichkeiten zum Erstellen einer Tabelle

Aspose.Words bietet mehrere Methoden zum Erstellen neuer Tabellen in einem Dokument. Jede Methode hat ihre eigenen Vor- und Nachteile, sodass die Wahl der zu verwendenden Methode häufig von der jeweiligen Situation abhängt.

Schauen wir uns diese Möglichkeiten zum Erstellen von Tabellen genauer an und vergleichen ihre Vor- und Nachteile:

Methode Vorteile Nachteile
Über DocumentBuilder Die Standardmethode zum Einfügen von Tabellen und anderen Dokumentinhalten Manchmal ist es schwierig, mit derselben Builder-Instanz viele verschiedene Tabellen gleichzeitig zu erstellen
Über DOM Passt besser zu umgebendem Code, der Knoten direkt in das DOM erstellt und einfügt, ohne ein DocumentBuilder zu verwenden Die Tabelle wird “leer” erstellt: Bevor Sie die meisten Vorgänge ausführen, müssen Sie EnsureMinimum aufrufen, um fehlende untergeordnete Knoten zu erstellen
Aus HTML Kann eine neue Tabelle aus einer HTML-Quelle mit Tags wie <table>, <tr>, <td> erstellen Nicht alle möglichen Microsoft Word-Tabellenformate können auf HTML angewendet werden
Klonen einer vorhandenen Tabelle Sie können eine Kopie einer vorhandenen Tabelle erstellen und dabei alle Zeilen- und Zellenformatierungen beibehalten Die entsprechenden untergeordneten Knoten müssen entfernt werden, bevor die Tabelle verwendet werden kann