{"id":55000350,"date":"2023-02-01T00:00:00","date_gmt":"2023-03-02T20:58:52","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=350"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Word_Lesen_und_Schreiben_von_Absaetzen_per_VBA","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Word_Lesen_und_Schreiben_von_Absaetzen_per_VBA\/","title":{"rendered":"Word: Lesen und Schreiben von Absätzen per VBA"},"content":{"rendered":"

Nachdem wir in zwei weiteren Artikeln beschrieben haben, wie man auf Word-Dokumente zugreift und die Ereignisse von Word und den angezeigten Dokumenten nutzt, gehen wir nun einen Schritt weiter: Wir schauen uns an, wie wir die Inhalte von Word-Dokumenten lesen und schreiben können. Das ist nicht ganz trivial, denn natürlich enthält ein Word-Dokument nicht einfach nur Text, den wir in eine Variable übertragen und weiterverarbeiten können. Stattdessen gibt es eine Unterteilung in Absätze, Bereiche, Tabellen und viele weitere Elemente. Der Fokus dieses Artikels liegt daher auf der Untersuchung dieser Elemente und wie wir diese am besten per VBA programmieren können.<\/b><\/p>\n

Vorbereitung für die Programmierung von Dokumentinhalten<\/h2>\n

Da wir bisher per VBA weder Texte in ein Word-Dokument geschrieben noch gelesen haben, starten wir systematisch – wir schreiben diese zuerst in ein Dokument und lesen die Inhalte dann ebenfalls per VBA aus.<\/p>\n

Die nachfolgenden Prozeduren wollen wir nicht von einer anderen Anwendung aus ausführen, sondern diese einfach in das VBA-Projekt des geöffneten Word-Dokuments eintragen und dort aufrufen. Wir greifen dabei mit dem Verweis ThisDocument <\/b>auf das aktuelle Word-Dokument zu.<\/p>\n

Dokument explizit referenzieren<\/h2>\n

Wenn Du die nachfolgenden Beispiele auf ein anderes Dokument anwenden möchtest als das mit ThisDocument <\/b>referenzierte Dokument, weil Du beispielsweise von einer anderen Anwendung aus arbeiten möchtest, verwendest Du eine wie folgt deklarierte Variable dazu:<\/p>\n

Dim <\/span>objDocument As <\/span>Word.Document<\/pre>\n
Dieses referenzierst Du bei einem neu zu erstellenden Dokument beispielsweise wie folgt:<\/p>\n
Dim <\/span>objWord As <\/span>Word.Application\r\nSet<\/span> objWord = New<\/span> Word.Application\r\nSet<\/span> objDocument = objWord.Documents.Add<\/pre>\n
Weitere Möglichkeiten zum Referenzieren eines Word-Dokuments zeigen wir im Artikel Word mit VBA programmieren <\/b>(www.vbentwickler.de\/348<\/b>).<\/p>\n
Text in ein Dokument einfügen<\/h2>\n
Die einfachste Möglichkeit, einen Text in das neue Word-Dokument einzufügen, ist die folgende Anweisung:<\/p>\n
ThisDocument.Range.Text = \"Dies ist ein erster Text.\"<\/pre>\n
Wir greifen also über ThisDocument <\/b>auf das Document<\/b>-Objekt zu, referenzieren dann das Range<\/b>-Objekt des Dokuments und legen seinen Text fest.<\/p>\n
Diese und die folgenden Anweisungen kannst Du in den meisten Fällen innerhalb einer Prozedur ausführen, aber auch als einzelne Anweisung in den Direktbereich des VBA-Editors eingeben und ausführen. Wir können übrigens auch die abgekürzte Form der obigen Anweisung nutzen, denn Text ist die Standardeigenschaft des Range<\/b>-Objekts und kann somit weggelassen werden:<\/p>\n
ThisDocument.Range = \"Dies ist ein erster Text.\"<\/pre>\n
Was ist das Range-Objekt?<\/h2>\n
Ein Range<\/b>-Objekt markiert verschiedene Bereiche eines Dokuments. Dabei liefert die Eigenschaft vieler verschiedener Objekte aus dem Word<\/b>-Objektmodell jeweils ein eigenes Range<\/b>-Objekt.<\/p>\n
Das Range<\/b>-Objekt des Document<\/b>-Objekts beispielsweise markiert den kompletten Inhalt des Dokuments. Wenn wir der Text<\/b>-Eigenschaft dieses Range<\/b>-Objekts einen Text zuweisen, wird der komplette Bereich mit dem angegebenen Text überschrieben.<\/p>\n
Wenn wir also nach der obigen Anweisung noch die folgende Anweisung absetzen, wird der vorhandene Inhalt gelöscht und durch den neuen Text ersetzt:<\/p>\n
ThisDocument.Range.Text = \"Noch ein Text.\"<\/pre>\n
Welchen Bereich umfasst das Range-Objekt?<\/h2>\n
Um zu erkennen, welchen Bereich die Range<\/b>-Eigenschaft jeweils zurückgibt, können wir den Bereich per VBA markieren:<\/p>\n
ThisDocument.Range.Select<\/pre>\n
Die Markierung wird erst sichtbar, wenn Word den Fokus erhält. Das erledigen wir in einer zweiten Anweisung:<\/p>\n
Public Sub <\/span>RangeMarkieren()\r\n     ThisDocument.Range.Select\r\n     AppActivate ThisDocument.Name\r\nEnd Sub<\/span><\/pre>\n
Wenn wir diese Prozedur ausführen, nachdem wir die vorherige Anweisung genutzt haben, erhalten wir die Ansicht aus Bild 1. Wir wir sehen, wird tatsächlich der komplette Inhalt markiert, das Range<\/b>-Objekt des Document<\/b>-Elements umfasst also den entsprechenden Bereich.<\/p>\n
\"Schreiben<\/p>\n
Bild 1: Schreiben eines einfachen Textes<\/span><\/b><\/p>\n
Komplettes Dokument mit Range erfassen<\/h2>\n
Das komplette Dokument können wir mit der Eigenschaft Content <\/b>des Document<\/b>-Objekts erfassen. Durch anschließendes Aufrufen von Select <\/b>sehen wir den Range<\/b> des in Content <\/b>enthaltenen Bereich:<\/p>\n
Public Sub <\/span>KomplettesDokument()\r\n     Dim <\/span>objRange As <\/span>Range\r\n     Set<\/span> objRange = ActiveDocument.Content\r\n     objRange.Select\r\nEnd Sub<\/span><\/pre>\n
Hier sehen wir, dass wir nicht etwa mit Content.Range <\/b>auf den Range<\/b> des Content <\/b>Elements zugreifen. Bei einigen Elementen gibt es keine Range<\/b>-Eigenschaft – diese liefern direkt ein Range<\/b>-Objekt zurück.<\/p>\n
Ob ein Element selbst den Typ Range <\/b>aufweist, finden wir mit der TypeName<\/b>-Funktion für das entsprechende Element heraus:<\/p>\n
  TypeName(ActiveDocument.Content)\r\nRange<\/pre>\n
Range-Elemente anderer Objekte<\/h2>\n
Wie erwähnt, hat nicht nur das Document<\/b>-Objekt ein Range<\/b>-Element. Ein Word-Dokument besteht zum Beispiel aus einem oder mehreren Absätzen und auch diese Absätze können wir mit dem Range<\/b>-Objekt markieren, lesen oder bearbeiten.<\/p>\n
Wie wir im Objektkatalog sehen können, gibt es vielleicht mehr Word-Elemente mit Range<\/b>-Eigenschaft als ohne diese Eigenschaft (siehe Bild 2).<\/p>\n
\"Range-Objekte<\/p>\n
Bild 2: Range-Objekte verschiedener Objekte<\/span><\/b><\/p>\n
Mit Paragraph auf Absätze zugreifen<\/h2>\n
In den folgenden Abschnitten schauen wir uns erst einmal an, wie wir das Range<\/b>-Objekt in Zusammenhang mit verschiedenen Absätzen nutzen können.<\/p>\n
Um einem Dokument mehrere Absätze hinzuzufügen, können wir – wie oben gezeigt – nicht einfach nacheinander Absätze zu ThisDocument.Range.Text <\/b>zuweisen.<\/p>\n
Bevor wir eine bessere Lösung finden, fügen wir einen Text aus drei Absätzen zusammen und weisen diesen dann dem Range<\/b>-Objekt des Dokuments zu:<\/p>\n
Public Sub <\/span>MehrereAbsaetzeSchreiben()\r\n     Dim <\/span>strAbsaetze As String<\/span>\r\n     strAbsaetze = \"Dies ist ein erster Text.\" & vbCrLf<\/span>\r\n     strAbsaetze = strAbsaetze & \"Noch ein Text.\" & vbCrLf<\/span>\r\n     strAbsaetze = strAbsaetze & \"Und ein letzter Absatz.\"\r\n     ThisDocument.Range.Text = strAbsaetze\r\n     AppActivate ThisDocument.Name\r\nEnd Sub<\/span><\/pre>\n
Das Ergebnis sehen wir in Bild 3.<\/p>\n
\"Mehrere<\/p>\n
Bild 3: Mehrere Absätze gleichzeitig schreiben<\/span><\/b><\/p>\n
Anzahl der Absätze eines Dokuments ermitteln<\/h2>\n
Die Anzahl der Paragraph<\/b>-Objekte eines Dokuments können wir mit der Count<\/b>-Eigenschaft der Paragraphs<\/b>-Auflistung ermitteln – hier als Ausgabe in den Direktbereich:<\/p>\n
Debug.Print<\/span> ThisDocument.Paragraphs.Count<\/pre>\n
Absätze durchlaufen<\/h2>\n
Damit können wir alle Absätze bereits in einer For…Next<\/b>-Schleife durchlaufen:<\/p>\n
Public Sub <\/span>AbsaetzeForNext()\r\n     Dim <\/span>objParagraph As <\/span>Paragraph\r\n     Dim <\/span>i As Long<\/span>\r\n     For i = 1 To ThisDocument.Paragraphs.Count\r\n         Set<\/span> objParagraph = ThisDocument.Paragraphs.Item(i)\r\n         Debug.Print<\/span> objParagraph.Range\r\n     Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n
Sehen wir uns das Ergebnis im Direktbereich an, sehen wir allerdings einige leere Zeilen (siehe Bild 4). Der Grund ist, dass wir die kompletten Zeilen ausgeben lassen – und diese enthalten eben auch noch das Zeilenumbruchszeichen, das wir beim Schreiben des Textes mit vbCrLf <\/b>angegeben haben.<\/p>\n
\"Ausgabe<\/p>\n
Bild 4: Ausgabe von Absätzen im Direktbereich<\/span><\/b><\/p>\n
Wollen wir nur die Texte in jeweils eine Zeile des Direktbereichs schreiben, müssen wir das Zeilenumbruchszeichen erst noch entfernen, beispielsweise mit der Replace<\/b>-Funktion.<\/p>\n
Allerdings stellen wir dann fest, dass Word gar nicht die Zeichenfolge vbCrLf <\/b>beziehungsweise Chr(13) & Chr(10) <\/b>als Zeilenumbruch nutzt, sondern nur Chr(13)<\/b>. Das finden wir mit folgender Prüfung heraus:<\/p>\n
Debug.Print<\/span> Asc(Right<\/span>(ThisDocument.Paragraphs(1).Range,1))\r\n   13<\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t