<\/p>\n
Im Beitrag „Von Access nach WordPress“ (Heft 6\/2019) haben wir Routinen entwickelt, mit denen wir den Inhalt eines Textfeldes in SQL-Anweisungen exportiert und damit eine WordPress-Webseite gefüllt haben. Der Weg dorthin war nicht so einfach, wie es in diesem Beitrag beschrieben wurde. In der Tag lag der HTML-Code mit den Artikeln so vor, dass er in einem anderen Content Management System, hier Typo3, optimal angezeigt wurde. Wenn wir diesen HTML-Code in das WordPress-System importiert haben, sah das optisch allerdings nicht so ansprechend aus. Wir mussten also noch einige Änderungen am HTML-Code vornehmen. Für Handarbeit war das bei rund 1.000 Artikel zu viel, also war die Programmierung entsprechender Konvertierungsroutinen angezeigt. Wie das grundlegend funktioniert, zeigen wir im vorliegenden Beitrag.<\/b><\/p>\n
Beispiele für notwendige Konvertierungen<\/b><\/p>\n
Typo3 war als Content Management System sehr nachsichtig, was die anzuzeigenden Inhalte anging. So konnten Sie ihm beispielsweise die deutschen Umlaute wie ä<\/b>, ö <\/b>und ü <\/b>sowie das scharfe s (ß<\/b>) unterjubeln und es zeigte diese problemlos an. Unter WordPress funktioniert das nicht. Hier werden entsprechende HTML-Entitäten erwartet, die wie folgt aussehen:<\/p>\n Auch der Vorname des Autors dieser Zeilen führte zu Problemen: Also musste André <\/b>überall in André <\/b>geändert werden. Und davon gab es noch viele weitere Beispiele.<\/p>\n Größer- und Kleiner-Zeichen<\/b><\/p>\n Ein weiteres Problem sind im Text abgebildete HTML-Codes wie der folgende:<\/p>\n Dies wurde unter Typo3 problemlos angezeigt, unter WordPress jedoch wurden die HTML-Auszeichnungen mehr oder weniger sinnvoll als solche interpretiert und nicht einfach ausgegeben. Also muss man auch hier die Kleiner- und Größer-Zeichen durch entsprechende Entitäten ersetzen:<\/p>\n Andere Zeichen<\/b><\/p>\n Desweiteren haben wir noch einige andere Zeichen gefunden, die wir in den rund 1.000 Artikeln mehr oder weniger konsistent verwendet haben – zum Beispiel verschiedene Anführungszeichen wie “, „“, „“ oder „“. Hier haben wir versucht, die Anführungszeichen auf diesem Wege zu vereinheitlichen.<\/p>\n Mit Anführungszeichen gab es vor allem Probleme, weil diese ja irgendwie in die INSERT INTO<\/b>-Anweisungen integriert werden mussten, die ja ihrerseits die Werte für Textfelder in Anführungszeichen angeben. Unter dem SQL-Dialekt von MySQL kann man Zeichenketten sowohl in Hochkommata (‚) also auch in Anführungszeichen angeben („). Je nachdem, welches man verwendet, muss man aber im zu speichernden Text die Hochkommata oder Anführungszeichen „escapen“, also durch ein zusätzliches Zeichen so codieren, dass es nicht als Ende der Zeichenkette interpretiert wird – denn das führt regelmäßig zu Fehlern, da so der Rest der SQL-Anweisung fehlinterpretiert wird. Ein Beispiel:<\/p>\n Das führt zu einem Fehler, weil der SQL-Interpreter das Hochkomma vor lustiger <\/b>als Ende der Zeichenkette erkennt. Danach wird ein Komma erwartet, aber es folgt noch weiterer Text, was den Fehler auslöst.<\/p>\n Abhilfe schafft es an dieser Stelle, einfach das Hochkomma in dem Text, der in das Feld eingefügt werden soll, durch ein doppeltes Hochkomma zu ersetzen. Alternativ können Sie auch ein Anführungszeichen verwenden – zumindest, wenn zur Markierung der einzufügenden Texte Hochkommata verwendet werden.<\/p>\n HTML-Auszeichnungen<\/b><\/p>\n Außerdem hatte ich die interessante Idee, nicht die üblichen HTML-Auszeichnungen etwa für Überschriften zu verwenden, sondern ein Absatz-Element mit einer bestimmten CSS-Klasse (wobei: vermutlich war das gar nicht meine Idee, sondern die des Exports aus Word oder InDesign, das natürlich nicht erkennen konnte, dass die Absatzformatklasse titel <\/b>eine Überschrift beinhaltet):<\/p>\n Dennoch sollten solche Elemente so umformatiert werden, dass Folgendes herauskam:<\/p>\n Damit können dann auch die Suchmaschinen viel mehr anfangen – sonst wäre es nicht möglich, zu erkennen, in welchem Element sich die Überschrift eines Textes befindet.<\/p>\n Es gibt noch weitere, ähnliche Beispiele – zum Beispiel für Zwischenüberschriften:<\/p>\n Diese Auszeichnung soll beispielsweise zu dieser werden:<\/p>\n Für Quellcode gab es die folgende Auszeichnung:<\/p>\n Diese soll so umformatiert werden:<\/p>\n Innerhalb des Fließtextes wurde die folgende Auszeichnung verwendet, um Begriffe hervorzuheben:<\/p>\n Das wollen wir durch fette Schrift ersetzen:<\/p>\n Nicht sichtbare Zeichen<\/b><\/p>\n Die bisher beschriebenen notwendigen Änderungen waren leicht zu erkennen. Entweder führten Sie schon beim Versuch, die Texte in die Textfelder der MySQL-Tabelle zu importieren, zu Fehlern oder sie fielen dann beim manuellen Sichten der Texte auf der WordPress-Webseite auf. Einige Zeichen sorgten jedoch dafür, dass der Text in WordPress einfach an einer bestimmten Stelle endete. Diese Zeichen mussten wir erst aufwendig ermitteln, indem wir die betroffene Stelle eingegrenzt haben und dann Zeichen für Zeichen die ASCII-Codes analysiert haben. Dabei zeigte sich, dass so manche Steuerzeichen aus dem Originaltext aus Word oder InDesign im HTML-Code gelandet sind, die von Typo3 ignoriert wurden – und unter WordPress dazu führten, dass der Rest des Textes inklusive dieses Zeichens schlicht nicht mehr abgebildet wurde. Die ASCII-Codes dieser Zeichen lauten beispielsweise 7<\/b>, 22<\/b>, 30<\/b>, 63<\/b>, 141 <\/b>oder 157<\/b>.<\/p>\n Umwandlungen per VBA<\/b><\/p>\n Die meisten Änderungen, die notwendig sind, um die oben genannten, nicht in WordPress funktionierenden Zeichen und Elemente anzupassen, sind mit dem Aufruf der Replace<\/b>-Funktion zu erledigen. Andere verlangen nach mehr Aufwand, zum Beispiel wenn es um das Ersetzen von Elementen wie <\/p>\n …<\/p>\n <\/b>durch <\/b>geht.<\/p>\n Einzelne Zeichen ersetzen<\/b><\/p>\n Wir haben diese alle in eine einzige Funktion geschrieben, mit der wir einen Text entgegennehmen, diesen auf die zu ersetzenden Zeichen durchsuchen und diese direkt mit der Replace<\/b>-Funktion ersetzen. Das sieht dann beispielsweise wie folgt aus:<\/p>\n Für die meisten Sonderzeichen lassen sich leicht die passenden HTML-Entitäten finden. Wenn das nicht gelingt, ist die Chance hoch, dass Sie das Ersetzen über den ASCII-Code des Zeichens wie folgt bewerkstelligen können:<\/p>\n Sie ermitteln den ASCII-Code des Zeichens mit der Asc<\/b>-Funktion:<\/p>\n Dann stellen Sie den Ersetzungscode aus den Zeichen &#<\/b>, dem ASCII-Code und dem Semikolon (;<\/b>) zusammen:<\/p>\n Dementsprechend sieht dann die Ersetzung aus:<\/p>\n oder<\/p>\n Umfangreichere Ersetzungen<\/b><\/p>\n Etwas komplizierter wird es, wenn Sie öffnende und schließende HTML-Tags ersetzen wollen.<\/p>\n Soll nur der öffnende Tag angepasst werden, etwa <p class=“Fliess-text“><\/b> durch <p><\/b>, kann man das genau wie oben mit der Replace<\/b>-Funktion erledigen:<\/p>\n Zu beachten ist in diesem Fall, dass Sie das einfache Anführungszeichen in der zu ersetzenden Zeichenkette durch doppelte Anführungszeichen ersetzen, damit das Anführungszeichen hinter class=<\/b> nicht als schließendes Anführungszeichen erkannt wird.<\/p>\n <\/p>\n Ein Beispiel für einen komplizierteren Fall ist der folgende:<\/p>\n soll ersetzt werden durch:<\/p>\n Das erledigen wir mit der Funktion aus Listing 1. Hier ermitteln wir mit der InStr<\/b>-Funktion zunächst die Position im Text, an der das erste Mal die gesuchte Zeichenkette auftaucht und speichern diese in der Variablen lngStart<\/b>. Danach steigen wir in eine Do While<\/b>-Schleife ein. Warum eine Schleife Weil wir davon ausgehen, dass es nicht nur ein Vorkommen des zu ersetzenden Textes gibt. Deshalb läuft die Do While<\/b>-Schleife solange, wie lngStart <\/b>größer als 0 <\/b>ist. Wenn wir beim ersten Aufruf von InStr <\/b>also kein Vorkommen finden, hat lngStart <\/b>den Wert 0 <\/b>und die Schleife wird gar nicht erst durchlaufen.<\/p>\n Listing 1: Ersetzen öffnender und schließender Tags<\/span><\/b><\/p>\n Wenn der erste Aufruf der InStr<\/b>-Funktion jedoch einen Treffer liefert, was wir durch einen Wert größer 0 <\/b>für die Variable lngStart <\/b>erkennen, starten wir in die Do While<\/b>-Schleife. Wir suchen dann nach dem entsprechenden schließenden Element mit dem Text <\/p><\/b>. Bei diesem Aufruf der InStr<\/b>-Funktion verwenden wir nicht den Wert 1 <\/b>als Startposition für die Suche, sondern den Wert der Variablen lngStart <\/b>plus eins, damit wir auf jeden Fall ein Vorkommen von <\/p> <\/b>finden, das hinter dem öffnenden Element liegt.<\/p>\n Dann folgt eine Anweisung mit Zeichenkettenfunktionen, die folgendes erledigt: Sie ermittelt zunächst den Text, der sich vor der Startposition des zuletzt gefundenen Auftretens von <p class=““titel““> <\/b>befindet, und verwendet diesen als ersten Teil des neuen Inhalts der Variablen strText<\/b>. Als nächstes folgt der ersetzende Ausdruck, nämlich <h1><\/b>. Dann liefert die Mid<\/b>-Funktion den Text vom Ende des aktuell gefundenen Vorkommens von <p class=““titel““> <\/b>bis zum Anfang des schließenden Tags <\/p><\/b>. Danach folgt der neue schließende Tag, also <\/h1><\/b>. Und schließlich fügt die Mid<\/b>-Funktion noch den gesamten Text hinzu, der sich hinter dem schließenden Tag <\/p> <\/b>befindet:<\/p>\n Hier finden wir einige Zahlenwerte, nämlich 4 <\/b>und 17<\/b>. Der Teil zwischen dem öffnenden und dem schließenden Tag soll beispielsweise 17 Zeichen hinter dem ersten Vorkommen des öffnenden Tags beginnen. Woher kommt diese Zahl Ganz einfach: Der Text <p class=““titel““><\/b> ist genau 17 Zeichen lang. Deshalb suchen wir das erste Zeichen des Textes zwischen dem öffnenden und dem schließenden Tag 17 Zeichen hinter dem Beginn des öffnenden Tags. Und das Ende befindet sich an der Position, die durch die Startposition des schließenden Tags <\/p><\/b> minus der Startposition des öffnenden Tags minus der Länge des öffnenden Tags ermittelt wird.<\/p>\n Und das Ende des Textes hinter dem schließenden Tag <\/p> <\/b>ermitteln wir durch die Startposition dieses Tags plus der Länge der Zeichenkette, also 4<\/b>.<\/p>\n Nachdem wir das erste Vorkommen in strText <\/b>ersetzt haben, suchen wir mit der InStr<\/b>-Funktion nach dem nächsten Vorkommen und steigen damit, wenn lngStart <\/b>danach einen Wert größer 0 <\/b>hat, in den nächsten Schleifendurchlauf ein. Falls nicht, haben wir alle Vorkommen ersetzt und die Funktion endet mit dem Zurückgeben von strText <\/b>mit den ersetzten Elementen.<\/p>\n Parametrisieren der Funktion<\/b><\/p>\n Beim Aktualisieren der HTML-Codes von der Version, die in Typo3 lief, zu der, die unter WordPress so aussah wie gewünscht, haben wir die zu ersetzenden Elemente Stück für Stück zu einer großen Ersetzen-Funktion hinzugefügt, bis schließlich alle nicht funktionierenden Elemente ersetzt waren. Dabei haben wir die obigen Codezeilen für alle zu ersetzenden öffnenden und schließenden Tags erneut kopiert und angepasst. Das können wir allerdings auch besser, und zwar indem wir die die Anweisungen der Funktion auslagern und diese parametrisieren.<\/p>\n Die Parameter sind schnell gefunden:<\/p>\n Dann brauchen wir nur noch die Funktion zu ersetzen, die anschließend wie in Listing 2 aussieht.<\/p>\n Listing 2: Ersetzen öffnender und schließender Tags mit einer parametrisierten Funktion<\/span><\/b><\/p>\n Der Aufruf dieser Funktion sieht nun beispielsweise wie folgt aus:<\/p>\n Das Ergebnis lautet nun, wie auch mit der vorherigen Funktion:<\/p>\n Dank dieser Funktion brauchen wir nur noch eine Anweisung für jedes Paar zu ersetzender Start- und Endtags. Außerdem entfällt das Ausrechnen beziehungsweise ermitteln der Längen von Start- und Endtags und somit entfallen auch viele Fehler, die sonst beim Ausprobieren der entsprechenden Zahlenwerte passiert sind.<\/p>\n Wir können nun also einfach mehrere Aufrufe der gleichen Form in eine Funktion schreiben, die dann auch die Anweisungen zum Ersetzen der einfachen Elemente enthält.<\/p>\n HTML-Texte per DOM bearbeiten<\/b><\/p>\n Eine andere Idee, die mir gekommen ist, als ich in diesem Beitrag das Ersetzen von Start- und Endtags beschrieben habe, ist das Document Object Model zum Bearbeiten von XML-Dokumenten. Mit den Befehlen dieses Objektmodells kann man ja gezielt auf die Elemente eines XML-Dokuments zugreifen und diese gegebenenfalls auch manipulieren. Aber ist das geeignet, um HTML-Dokumente zu manipulieren, wie wir diese vorliegen haben Wir probieren mit folgender Prozedur aus, ein solches Dokument in eine Objektvariable des Typs DOMDocument <\/b>zu laden und lassen wohlweislich auch direkt die Fehlermeldung im Falle eines Fehlers beim Parsen ausgeben:<\/p>\n Hier haben wir zunächst den Inhalt eines Artikels in die Variable strText <\/b>geladen, dann ein neues DOMDocument<\/b>-Objekt erstellt und mit der Variablen objXML <\/b>referenziert und dann mit seiner LoadXML<\/b>-Methode den Inhalt von strText <\/b>eingelesen. Dies liefert den Wert False und die Ausgabe von objXML.parseError.reason <\/b>liefert diese Antwort:<\/p>\n Logisch – wir haben in unserer Tabelle kein öffnendes und schließendes HTML-Element, was dem geforderten Element höchster Ebene entsprechen würde, denn die Inhalte sollen ja in anderen HTML-Dokumenten, die vom jeweiligen Content Management System zur Verfügung gestellt werden, eingebettet werden.<\/p>\n Also fügen wir zuvor ein öffnendes und ein schließendes HTML-Element zu strText <\/b>hinzu:<\/p>\n Danach erhalten wir diesen Fehler:<\/p>\n Offensichtlich haben wir hier also noch nicht einmal ein sauberes HTML-Dokument, bei dem alle öffnenden Elemente auch auf der gleichen Ebene wieder geschlossen werden. Wir fügen also noch eine weitere Zeile zu unserer Prozedur hinzu, um herauszufinden, an welcher Stelle der Fehler aufgetreten ist:<\/p>\n Das liefert für unser Beispiel Zeile 6, Zeichen 220. Das können wir uns nun in einem Texteditor ansehen. Hier stellen wir dann auch direkt fest, dass hier ein überzähliges schließendes <\/p><\/b>-Tag enthalten ist. In der Folge stellte sich heraus, dass die angedachte Vorgehensweise zumindest für unseren Fall zu viel Vorarbeit erfordert. Oder anders formuliert: Man müsste zunächst dennoch mit einigen Replace<\/b>-Aufrufen die für ein valides HTML-\/XML-Dokument erforderliche Form herbeiführen. Dann kann man auch direkt die benötigten Änderungen auf die gleiche Weise vornehmen.<\/p>\n Und wenn wir nun ein valides Dokument hätten Können wir dann Änderungen an den Start- und Endtags wie geplant vornehmen, ohne unzählige Aufrufe von Zeichenkettenfunktionen<\/p>\n Das geht, aber es ist durchaus mit Programmieraufwand verbunden. Da wir solche Herausforderungen lieben, haben wir uns angesehen, wie das funktionieren kann. Das Ergebnis finden Sie in Listing 3.<\/p>\n Listing 3: Elemente ersetzen per XML-Document Object Model<\/span><\/b><\/p>\n Wir haben ein kleines HTML-Dokument erzeugt, das folgenden Code hat:<\/p>\n Wir wollen für das Element mit dem Starttag <p class=“titel“> <\/b>den Elementnamen auf h2 <\/b>ändern und das Attribut class <\/b>entfernen. Dazu laden wir das Dokument zuerst in das DOMDocument<\/b>-Objekt objXML<\/b>. Dann ermitteln wir mit SelectSingleNode <\/b>das Element mit dem Namen p <\/b>und dem Wert titel <\/b>für das Attribut class<\/b>.<\/p>\n Dieses referenzieren wir mit der Variablen objP<\/b>. Dann erstellen wir ein neues Element mit dem Namen h2 <\/b>und referenzieren es mit der Variablen objPNeu<\/b>. Dieses Element ist nun noch frei, also nicht irgendeinem anderen Element des XML-Dokuments untergeordnet. Wenn Sie nun mit der Eigenschaft XML <\/b>den Inhalt von objXML <\/b>ausgeben lassen, erscheint das neue Element noch nicht im Elementbaum.<\/p>\n Deshalb nutzen wir nun die Methode InsertBefore <\/b>des übergeordneten Elements von objP<\/b>, das wir über die Eigenschaft ParentNode <\/b>referenzieren. Als ersten Parameter geben wir das neue Objekt an (objPNeu<\/b>), als zweiten das Objekt, zu dem es relativ an der vorherigen Position erscheinen soll (objP<\/b>).<\/p>\n Nun haben wir das neue Objekt objPNeu <\/b>an die Stelle vor dem zu ersetzenden Objekt objP <\/b>verschoben. Wenn wir nun den XML-Code ausgeben, erhalten wir Folgendes:<\/p>\n Der Inhalt des Elements objP<\/b>, also der Text Bla<\/b>, befindet sich noch an Ort und Stelle, soll aber in das Objekt objPNeu <\/b>verschoben werden. Das erledigen wir, indem wir in einer For Each<\/b>-Schleife alle Elemente durchlaufen, die sich in objP <\/b>befinden. Diese referenzieren wir mit der Eigenschaft ChildNodes<\/b>. Beim Durchlaufen hängen wir das mit objChild <\/b>referenzierte Element dann jeweils an objPNeu <\/b>an. Wird der Inhalt dadurch verschoben oder kopiert Das ergibt eine erneute Ausgabe von objXML.XML<\/b>:<\/p>\n Hier wird deutlich, dass der Inhalt verschoben wird. Nun müssen wir nur noch das Element aus objP <\/b>löschen. Das erledigen wir mit einem Aufruf der Methode RemoveChild <\/b>des übergeordneten Elements von objP<\/b>, das wir mit ParentNode <\/b>referenzieren. Das Ergebnis sieht dann folgendermaßen aus:<\/p>\n\n
<p>Beispieltext<\/p><\/pre>\n
\n
INSERT INTO wp_posts(ID, post_content, ...) \r\nVALUES (55000999, 'Dies ist ein 'lustiger' Beispieltext', ...)<\/pre>\n
<p class=\"\"titel\"\">...<\/p><\/pre>\n
<h1>...<\/h1><\/pre>\n
<p class=\"zwischenueberschrift\">...<\/p><\/pre>\n
<h2>...<\/h2><\/pre>\n
<p class=\"Quellcode\">...<\/p><\/pre>\n
<pre>...<\/pre><\/pre>\n
...<span class=\"kursiv\">...<\/span>...<\/pre>\n
...<b>...<\/b>...<\/pre>\n
Public Function <\/span>Ersetzen(strText As String<\/span>) As String<\/span>\r\n strText = Replace<\/span>(strText, \"'\", \"'\")\r\n strText = Replace<\/span>(strText, \"'\", \"''\")\r\n strText = Replace<\/span>(strText, \"\", \">\/font<\")\r\n strText = Replace<\/span>(strText, \"ä\", \"ä\")\r\n strText = Replace<\/span>(strText, \"ö\", \"ö\")\r\n strText = Replace<\/span>(strText, \"ü\", \"ü\")\r\n strText = Replace<\/span>(strText, \"Ä\", \"Ä\")\r\n strText = Replace<\/span>(strText, \"Ö\", \"Ö\")\r\n strText = Replace<\/span>(strText, \"Ü\", \"Ü\")\r\n strText = Replace<\/span>(strText, \"ß\", \"ß\")\r\n strText = Replace<\/span>(strText, \"é\", \"é\")\r\n strText = Replace<\/span>(strText, \"\"\", \"\"\"\")\r\n strText = Replace<\/span>(strText, \"\"\", \"\"\"\")\r\n strText = Replace<\/span>(strText, \"§\", \"§\")\r\n strText = Replace<\/span>(strText, \"-\", \"-\")\r\n strText = Replace<\/span>(strText, \"€\", \"€\")\r\n strText = Replace<\/span>(strText, \"á\", \"á\")\r\n strText = Replace<\/span>(strText, \"\"\", \"\"\"\")\r\n strText = Replace<\/span>(strText, \"\"\", \"\"\"\")\r\n ...\r\n Ersetzen = strText\r\nEnd Function<\/span><\/pre>\n Asc(\"š\")\r\n 154 <\/pre>\n
š<\/pre>\n
strText = Replace<\/span>(strText, \"š\", \"š\")<\/pre>\nstrText = Replace<\/span>(strText, Chr(154), \"š\")<\/pre>\nstrText = Replace<\/span>(strText, \"<p class=\"\"Fliesstext\"\">\", \"<p>\")<\/pre>\n<p class=\"\"titel\"\">...<\/p><\/pre>\n
<h1>...<\/h1><\/pre>\n
Public Function <\/span>ErsetzenH1(strText As String<\/span>) As String<\/span>\r\n Dim <\/span>lngStart As Long<\/span>\r\n Dim <\/span>lngEnde As Long<\/span>\r\n lngStart = InStr<\/span>(1, strText, \"<p class=\"\"titel\"\">\")\r\n Do While<\/span> lngStart > 0\r\n lngEnde = InStr<\/span>(lngStart + 1, strText, \"<\/p>\")\r\n strText = Left<\/span>(strText, lngStart - 1) & \"<h1>\" & Mid<\/span>(strText, lngStart + 17, lngEnde - lngStart - 17) _\r\n & \"<\/h1>\" & Mid<\/span>(strText, lngEnde + 4)\r\n lngStart = InStr<\/span>(lngStart + 1, strText, \"<p class=\"\"titel\"\">\")\r\n Loop<\/span>\r\n ErsetzenH1 = strText\r\nEnd Function<\/span><\/pre>\nLeft<\/span>(strText, lngStart - 1) _\r\n & \"<h1>\" _\r\n & Mid<\/span>(strText, lngStart + 17, lngEnde - lngStart - 17) _\r\n & \"<\/h1>\" _\r\n & Mid<\/span>(strText, lngEnde + 4)<\/pre>\n\n
Public Function <\/span>ErsetzenStartUndEndTag(strText As String<\/span>, strStarttagAlt As String<\/span>, strEndtagAlt As String<\/span>, _\r\n strStartTagNeu As String<\/span>, strEndtagNeu As String<\/span>) As String<\/span>\r\n Dim <\/span>lngStart As Long<\/span>\r\n Dim <\/span>lngEnde As Long<\/span>\r\n lngStart = InStr<\/span>(1, strText, strStarttagAlt)\r\n Do While<\/span> lngStart > 0\r\n lngEnde = InStr<\/span>(lngStart + 1, strText, strEndtagAlt)\r\n strText = Left<\/span>(strText, lngStart - 1) & strStartTagNeu & Mid<\/span>(strText, lngStart + Len<\/span>(strStarttagAlt), _\r\n lngEnde - lngStart - Len<\/span>(strStarttagAlt)) & strEndtagNeu & Mid<\/span>(strText, lngEnde + Len<\/span>(strEndtagAlt))\r\n lngStart = InStr<\/span>(lngStart + 1, strText, strStarttagAlt)\r\n Loop<\/span>\r\n ErsetzenStartUndEndTag = strText\r\nEnd Function<\/span><\/pre>\n ErsetzenstartUndEndtag(\"xxx<p class=\"\"titel\"\">bla<\/p>yyy\", \"<p class=\"\"titel\"\">\", \"<\/p>\", \"<h1>\", \"<\/h1>\")<\/pre>\n
xxx<h1>bla<\/h1>yyy<\/pre>\n
Public Sub <\/span>ErsetzenPerXMLDOM()\r\n Dim <\/span>strText As String<\/span>\r\n Dim <\/span>objXML As <\/span>MSXML2.DOMDocument60\r\n strText = DLookup(\"InhaltOffen\", \"tblBeitraege\", _\r\n \"BeitragID = 1000\")\r\n Set<\/span> objXML = New<\/span> DOMDocument60\r\n Debug.Print<\/span> Left<\/span>(strText, 1000)\r\n Debug.Print<\/span> objXML.LoadXML(strText)\r\n Debug.Print<\/span> objXML.parseError, _\r\n objXML.parseError.reason\r\nEnd Sub<\/span><\/pre>\n-1072896683 In einem XML-Dokument ist nur ein Element höchster Ebene zugelassen.<\/pre>\n
strText = \"<html>\" & vbCrLf<\/span> & strText & vbCrLf<\/span> & \"<\/html>\"<\/pre>\n-1072896659 Das Endtag 'p' stimmt nicht mit dem Starttag 'html' überein.<\/pre>\n
Debug.Print<\/span> objXML.parseError.Line, objXML.parseError.linepos<\/pre>\nPublic Sub <\/span>ErsetzenPerXMLDOM()\r\n Dim <\/span>strText As String<\/span>\r\n Dim <\/span>objXML As <\/span>MSXML2.DOMDocument60\r\n Dim <\/span>objP As <\/span>MSXML2.IXMLDOMNode\r\n Dim <\/span>objPNeu As <\/span>MSXML2.IXMLDOMNode\r\n Dim <\/span>objChild As <\/span>MSXML2.IXMLDOMNode\r\n strText = \"<html>\" & vbCrLf<\/span>\r\n strText = strText & \"<h1>\" & vbCrLf<\/span>\r\n strText = strText & \"<p class=\"\"titel\"\">Bla<\/p>\" & vbCrLf<\/span>\r\n strText = strText & \"<\/h1>\" & vbCrLf<\/span>\r\n strText = strText & \"<\/html>\" & vbCrLf<\/span>\r\n Set<\/span> objXML = New<\/span> DOMDocument60\r\n If <\/span>objXML.loadXML(strText) = True<\/span> Then<\/span>\r\n Set<\/span> objP = objXML.SelectSingleNode(\"\/\/p[@class='titel']\")\r\n Set<\/span> objPNeu = objXML.createElement(\"h2\")\r\n objP.ParentNode.InsertBefore objPNeu, objP\r\n For Each objChild In objP.ChildNodes\r\n objPNeu.appendChild objChild\r\n Next<\/span> objChild\r\n objP.ParentNode.RemoveChild objP\r\n Debug.Print<\/span> objXML.XML\r\n Else<\/span>\r\n MsgBox<\/span> \"Das Dokument konnte nicht gelesen werden.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n<html>\r\n <h1>\r\n <p class=\"titel\">Bla<\/p>\r\n <\/h1>\r\n<\/html><\/pre>\n
<html>\r\n <h1>\r\n <h2\/>\r\n <p class=\"titel\">Bla<\/p>\r\n <\/h1>\r\n<\/html><\/pre>\n
<html>\r\n <h1>\r\n <h2>Bla<\/h2>\r\n <p class=\"titel\"\/>\r\n <\/h1>\r\n<\/html><\/pre>\n