{"id":55000458,"date":"2019-10-01T00:00:00","date_gmt":"2020-04-06T16:32:44","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=458"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBAFunktionen_testen","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html","title":{"rendered":"VBA-Funktionen testen"},"content":{"rendered":"<p class='introduction'>Wenn Sie VBA-Funktionen entwickeln, sollen diese reproduzierbare und f&uuml;r alle &uuml;bergebenen Parameterwerte korrekte Ergebnisse liefern. Manch einer testet die Funktion dann f&uuml;r einen Wert, erh&auml;lt das gew&uuml;nschte Ergebnis, erh&auml;lt f&uuml;r einen anderen Wert ein falsches Ergebnis, &auml;ndert die Funktion &#8230; und: Irgendwann stellt sich heraus, dass diese nach den &auml;nderungen nicht mehr das korrekte Ergebnis f&uuml;r den eingangs verwenden Parameter liefert. Hier hilft es, wenn Sie das Entwickeln von VBA-Funktionen etwas systematischer angehen, n&auml;mlich mit organisierten Tests. Dabei testen Sie die Funktion mit allen Parameterwerten, die Ihnen einfallen und wiederholen diese Tests auch nach &auml;nderungen an der Funktion, um sicherzustellen, dass die &auml;nderung der Funktion die Ergebnisse nicht beeinflusst. Wie das gelingt, zeigen wir in diesem Artikel.<\/p>\n<h2>Beispieldatenbank<\/h2>\n<p>Die Beispiele dieses Artikels finden Sie in der Datenbank <b>1905_VBAFunktionenTesten.accdb<\/b>.<\/p>\n<h2>Schnell mal programmiert<\/h2>\n<p>Eine VBA-Funktion ist mal mehr, mal weniger anspruchsvoll. Einfache Prozeduren, die vielleicht nur einen Datenbankaufruf kapseln sollen, brauchen kaum f&uuml;r viele verschiedene F&auml;lle getestet zu werden. Aber je mehr verschiedene Eingabewerte eine Funktion hat und desto komplexer und umfangreicher die enthaltenen Anweisungen werden, umso wichtiger w&auml;re es, w&auml;hrend der Entwicklung der Funktion regelm&auml;&szlig;ig zu pr&uuml;fen, ob diese f&uuml;r alle F&auml;lle, f&uuml;r die sie vorgesehen ist, noch funktioniert.<\/p>\n<p>Das ist insbesondere dann gefragt, wenn ein Eingabewert auftaucht, den die Funktion nicht in der gew&uuml;nschten Weise verarbeitet &#8211; was bedeutet, dass sie nicht das erwartete Ergebnis liefert. Dann &auml;ndert man die Funktion so, dass sie auch auf die neuen Eingabewerte wie erwartet reagiert. Aber pr&uuml;ft man dann auch immer automatisch, ob die Eingabe- und Ausgabewerte, an die man die Funktion vorher angepasst hat, noch passen Das ist vielleicht nicht der Fall, und dort liegt eine m&ouml;gliche Fehlerquelle.<\/p>\n<p>Anhand von Funktionen m&ouml;chten wir in diesem Artikel aufzeigen, wie Sie automatisierte Tests von Code aufbauen k&ouml;nnen. Das erfordert zwar auf den ersten Blick zun&auml;chst mehr Programmieraufwand, aber wenn Sie den Code sp&auml;ter anpassen wollen, sparen Sie viel Zeit, weil alle Tests, die Sie bis dahin durchgef&uuml;hrt haben, nun per Mausklick erledigt werden k&ouml;nnen.<\/p>\n<p>Ein Beispiel ist eine Funktion aus dem Artikel <b>Feldinhalte aufteilen<\/b>. Hier haben wir eine Funktion programmiert, mit der wir die Bestandteile einer Adressangabe, in diesem Fall Stra&szlig;e und Hausnummer, auf zwei Zeichenketten mit Stra&szlig;e und Hausnummer aufteilen wollen. Die Funktion hat die folgende Kopfzeile:<\/p>\n<pre><span style=\"color:blue;\">Public Function <\/span>StrasseUndHausnummer(         strStrasseUndHausnummer<span style=\"color:blue;\"> As String<\/span>, strStrasse          <span style=\"color:blue;\"> As String<\/span>, strHausnummer<span style=\"color:blue;\"> As String<\/span>)<span style=\"color:blue;\"> As Boolean<\/span><\/pre>\n<p>Dabei erfasst der erste Parameter die zu verarbeitende Zeichenkette, der zweite und dritte liefert das Ergebnis der Funktion zur&uuml;ck. Der R&uuml;ckgabewert gibt als <b>Boolean<\/b>-Wert an, ob die Funktion &uuml;berhaupt ordnungsgem&auml;&szlig; funktioniert hat.<\/p>\n<p>Das ist eine Form, mit der wir beim automatisierten Testen gut arbeiten k&ouml;nnen. Wenn die Funktion nur einen R&uuml;ckgabewert hat und nicht wie in diesem Fall gleich zwei beziehungsweise drei, k&ouml;nnen Sie den R&uuml;ckgabewert auch direkt als Funktionswert zur&uuml;ckgeben.<\/p>\n<p>Wir wollen die Funktion nun mit verschiedenen Aufrufen testen, wobei wir immer andere Kombinationen aus Stra&szlig;enname und Hausnummer &uuml;bergeben:<\/p>\n<ul>\n<li>Stra&szlig;e und Hausnummer mit Leerzeichen dazwischen,<\/li>\n<li>Stra&szlig;en, die bereits Leerzeichen im Stra&szlig;ennamen enthalten,<\/li>\n<li>Stra&szlig;e und Hausnummer, bei denen zwischen dem Punkt von &#8222;Str.&#8220; und der Hausnummer kein Leerzeichen ist oder auch<\/li>\n<li>Stra&szlig;en, bei denen die Hausnummer selbst Leerzeichen enth&auml;lt (2 a).<\/li>\n<\/ul>\n<p>Wenn wir eine Funktion erstellen wollen, die all diese Konstellationen wie gew&uuml;nscht verarbeitet, m&uuml;ssen wir in der Funktion entsprechend viele F&auml;lle ber&uuml;cksichtigen. Und um sicherzustellen, dass man beim Anpassen der Funktion auf einen neuen Fall auch die anderen F&auml;lle noch ber&uuml;cksichtigt, sollte man alle bekannten F&auml;lle nach jeder &auml;nderung nochmals pr&uuml;fen.<\/p>\n<p>Ich schreibe bewusst von &#8222;allen bekannten F&auml;llen&#8220;, denn der Benutzer ist gnadenlos und wird M&ouml;glichkeiten finden, um Ihre Funktion zum Versagen zu bringen. Doch das ist dann nur eine weitere Aufgabe, die es zu l&ouml;sen gilt und das ist viel einfacher, wenn man wie nachfolgend beschrieben Testroutinen f&uuml;r die zu erstellende Funktion programmiert hat.<\/p>\n<h2>Einfach testen<\/h2>\n<p>Am einfachsten testet man, indem man die Funktion schlicht mit dem zu untersuchenden Parameterwert aufruft und die R&uuml;ckgabewerte der Funktion auf Richtigkeit &uuml;berpr&uuml;ft. Liefert die Funktion die erwarteten Werte zur&uuml;ck, braucht nichts weiter zu geschehen. Wenn diese jedoch andere Werte als erwartet liefert, sollte man durch eine Meldung oder durch eine Ausgabe im Direktbereich darauf hingewiesen werden.<\/p>\n<p>Wie kann das aussehen Im Fall der Funktion <b>StrasseUndHausnummer <\/b>sieht ein einfacher Test so aus wie in Listing 1. Hier pr&uuml;fen wir zun&auml;chst, ob der Aufruf der Funktion den Wert <b>True <\/b>zur&uuml;ckliefert. Falls ja, pr&uuml;fen wir, ob die beiden R&uuml;ckgabeparameter <b>strStrasse <\/b>und <b>strHausnummer <\/b>die erwarteten Werte enthalten. Wenn dies zutrifft, geschieht nichts weiter &#8211; falls nein, erscheint eine Ausgabe, welche die erwarteten Werte sowie die tats&auml;chlich gelieferten Werte ausgibt:<\/p>\n<pre>&lt;font color=blue&gt;Public Sub &lt;\/font&gt;Test_StrasseUndHausnummer()\r\n     &lt;font color=blue&gt;Dim &lt;\/font&gt;strStrasseUndHausnummer&lt;font color=blue&gt; As String&lt;\/font&gt;\r\n     &lt;font color=blue&gt;Dim &lt;\/font&gt;strStrasse&lt;font color=blue&gt; As String&lt;\/font&gt;\r\n     &lt;font color=blue&gt;Dim &lt;\/font&gt;strHausnummer&lt;font color=blue&gt; As String&lt;\/font&gt;\r\n     strStrasseUndHausnummer = \"Gerichtsstr. 27\"\r\n     &lt;font color=blue&gt;If &lt;\/font&gt;StrasseUndHausnummer(strStrasseUndHausnummer, strStrasse, strHausnummer) = &lt;font color=blue&gt;True&lt;\/font&gt;&lt;font color=blue&gt; Then&lt;\/font&gt;\r\n         &lt;font color=blue&gt;If &lt;\/font&gt;&lt;font color=blue&gt;Not&lt;\/font&gt; (strStrasse = \"Gerichtsstr.\" And strHausnummer = \"27\")&lt;font color=blue&gt; Then&lt;\/font&gt;\r\n             &lt;font color=blue&gt;Debug.Print&lt;\/font&gt; \"Aufruf mit Parameter '\" & strStrasseUndHausnummer & \"' fehlgeschlagen.\"\r\n             &lt;font color=blue&gt;Debug.Print&lt;\/font&gt; \"Erwartet: 'Gerichtsstr.' Geliefert: '\" & strStrasse & \"'\"\r\n             &lt;font color=blue&gt;Debug.Print&lt;\/font&gt; \"Erwartet: '27' Geliefert: '\" & strHausnummer & \"'\"\r\n         &lt;font color=blue&gt;End If&lt;\/font&gt;\r\n     &lt;font color=blue&gt;Else&lt;\/font&gt;\r\n         &lt;font color=blue&gt;Debug.Print&lt;\/font&gt; \"Funktionsaufruf mit Parameter '\" & strStrasseUndHausnummer & \"' nicht erfolgreich.\"\r\n     &lt;font color=blue&gt;End If&lt;\/font&gt;\r\n<span style=\"color:blue;\">End Sub<\/span><\/pre>\n<p class='imagetext'>Listing 1: Erster Entwurf einer Prozedur zum Testen einer Funktion<\/p>\n<pre>Aufruf mit Parameter 'Gerichtsstr. 27 a' fehlgeschlagen.\r\nErwartet: 'Gerichtsstr.' Geliefert: 'Gerichtsstr. 27'\r\nErwartet: '27' Geliefert: 'a'<\/pre>\n<h2>Weitere Testf&auml;lle hinzuf&uuml;gen<\/h2>\n<div class=\"rcp_restricted\"><p><span style=\"color: #ff0000;\">M&ouml;chten Sie weiterlesen? Dann l&ouml;sen Sie Ihr Ticket!<\/span><br \/>\n<span style=\"color: #ff0000;\">Hier geht es zur Bestellung des Jahresabonnements des Magazins <strong>Access &#091;basics&#093;<\/strong>:<\/span><br \/>\n<span style=\"color: #ff0000;\"><a style=\"color: #ff0000;\" href=\"https:\/\/shop.minhorst.com\/magazine\/282\/access-basics?c=77\">Zur Bestellung ...<\/a><\/span><br \/>\n<span style=\"color: #ff0000;\">Danach greifen Sie sofort auf <strong>alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span><br \/>\n<span style=\"color: #000000;\">Oder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t<form id=\"rcp_login_form\"  class=\"rcp_form\" method=\"POST\" action=\"https:\/\/access-basics.de\/data\/wp\/v2\/posts\/55000458\/\">\n\n\t\t\n\t\t<fieldset class=\"rcp_login_data\">\n\t\t\t<p>\n\t\t\t\t<label for=\"rcp_user_login\">Username or Email<\/label>\n\t\t\t\t<input name=\"rcp_user_login\" id=\"rcp_user_login\" class=\"required\" type=\"text\"\/>\n\t\t\t<\/p>\n\t\t\t<p>\n\t\t\t\t<label for=\"rcp_user_pass\">Password<\/label>\n\t\t\t\t<input name=\"rcp_user_pass\" id=\"rcp_user_pass\" class=\"required\" type=\"password\"\/>\n\t\t\t<\/p>\n\t\t\t\t\t\t<p>\n\t\t\t\t<input type=\"checkbox\" name=\"rcp_user_remember\" id=\"rcp_user_remember\" value=\"1\"\/>\n\t\t\t\t<label for=\"rcp_user_remember\">Remember me<\/label>\n\t\t\t<\/p>\n\t\t\t<p class=\"rcp_lost_password\"><a href=\"\/index.php\/data\/wp\/v2\/posts\/55000458?rcp_action=lostpassword\"><\/a><\/p>\n\t\t\t<p>\n\t\t\t\t<input type=\"hidden\" name=\"rcp_action\" value=\"login\"\/>\n\t\t\t\t\t\t\t\t\t<input type=\"hidden\" name=\"rcp_redirect\" value=\"https:\/\/access-basics.de\/data\/wp\/v2\/posts\/55000458\/\"\/>\n\t\t\t\t\t\t\t\t<input type=\"hidden\" name=\"rcp_login_nonce\" value=\"8d63f6cbe9\"\/>\n\t\t\t\t<input id=\"rcp_login_submit\" class=\"rcp-button\" type=\"submit\" value=\"Login\"\/>\n\t\t\t<\/p>\n\t\t\t\t\t<\/fieldset>\n\n\t\t\n\t<\/form>\n<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Wenn Sie VBA-Funktionen entwickeln, sollen diese reproduzierbare und f&uuml;r alle &uuml;bergebenen Parameterwerte korrekte Ergebnisse liefern. Manch einer testet die Funktion dann f&uuml;r einen Wert, erh&auml;lt das gew&uuml;nschte Ergebnis, erh&auml;lt f&uuml;r einen anderen Wert ein falsches Ergebnis, &auml;ndert die Funktion &#8230; und: Irgendwann stellt sich heraus, dass diese nach den &auml;nderungen nicht mehr das korrekte Ergebnis f&uuml;r den eingangs verwenden Parameter liefert. Hier hilft es, wenn Sie das Entwickeln von VBA-Funktionen etwas systematischer angehen, n&auml;mlich mit organisierten Tests. Dabei testen Sie die Funktion mit allen Parameterwerten, die Ihnen einfallen und wiederholen diese Tests auch nach &auml;nderungen an der Funktion, um sicherzustellen, dass die &auml;nderung der Funktion die Ergebnisse nicht beeinflusst. Wie das gelingt, zeigen wir in diesem Artikel.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662019,66052019,44000011],"tags":[],"class_list":["post-55000458","post","type-post","status-publish","format-standard","hentry","category-662019","category-66052019","category-VBAGrundlagen"],"aioseo_notices":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v15.9.2 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>VBA-Funktionen testen - Access [basics]<\/title>\n<meta name=\"description\" content=\"Wenn Sie VBA-Funktionen entwickeln, sollen diese reproduzierbare und f\u00fcr alle \u00fcbergebenen Parameterwerte korrekte Ergebnisse liefern. Manch einer testet die Funktion dann f\u00fcr einen Wert, erh\u00e4lt das gew\u00fcnschte Ergebnis, erh\u00e4lt f\u00fcr einen anderen Wert ein falsches Ergebnis, \u00e4ndert die Funktion ... und: Irgendwann stellt sich heraus, dass diese nach den \u00c4nderungen nicht mehr das korrekte Ergebnis f\u00fcr den eingangs verwenden Parameter liefert. Hier hilft es, wenn Sie das Entwickeln von VBA-Funktionen etwas systematischer angehen, n\u00e4mlich mit organisierten Tests. Dabei testen Sie die Funktion mit allen Parameterwerten, die Ihnen einfallen und wiederholen diese Tests auch nach \u00c4nderungen an der Funktion, um sicherzustellen, dass die \u00c4nderung der Funktion die Ergebnisse nicht beeinflusst. Wie das gelingt, zeigen wir in diesem Artikel.\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"VBA-Funktionen testen - Access [basics]\" \/>\n<meta property=\"og:description\" content=\"Wenn Sie VBA-Funktionen entwickeln, sollen diese reproduzierbare und f\u00fcr alle \u00fcbergebenen Parameterwerte korrekte Ergebnisse liefern. Manch einer testet die Funktion dann f\u00fcr einen Wert, erh\u00e4lt das gew\u00fcnschte Ergebnis, erh\u00e4lt f\u00fcr einen anderen Wert ein falsches Ergebnis, \u00e4ndert die Funktion ... und: Irgendwann stellt sich heraus, dass diese nach den \u00c4nderungen nicht mehr das korrekte Ergebnis f\u00fcr den eingangs verwenden Parameter liefert. Hier hilft es, wenn Sie das Entwickeln von VBA-Funktionen etwas systematischer angehen, n\u00e4mlich mit organisierten Tests. Dabei testen Sie die Funktion mit allen Parameterwerten, die Ihnen einfallen und wiederholen diese Tests auch nach \u00c4nderungen an der Funktion, um sicherzustellen, dass die \u00c4nderung der Funktion die Ergebnisse nicht beeinflusst. Wie das gelingt, zeigen wir in diesem Artikel.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html\" \/>\n<meta property=\"og:site_name\" content=\"Access [basics]\" \/>\n<meta property=\"article:published_time\" content=\"2020-04-06T16:32:44+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"-0001-11-30T00:00:00+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Gesch\u00e4tzte Lesezeit\">\n\t<meta name=\"twitter:data1\" content=\"12\u00a0Minuten\">\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebSite\",\"@id\":\"https:\/\/access-basics.de\/#website\",\"url\":\"https:\/\/access-basics.de\/\",\"name\":\"Access [basics]\",\"description\":\"DAS ACCESS-MAGAZIN F\\u00dcR ALLE, DIE VON 0 AUF 100 WOLLEN\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":\"https:\/\/access-basics.de\/?s={search_term_string}\",\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"de\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html#webpage\",\"url\":\"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html\",\"name\":\"VBA-Funktionen testen - Access [basics]\",\"isPartOf\":{\"@id\":\"https:\/\/access-basics.de\/#website\"},\"datePublished\":\"2020-04-06T16:32:44+00:00\",\"dateModified\":\"-0001-11-30T00:00:00+00:00\",\"author\":{\"@id\":\"https:\/\/access-basics.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f\"},\"description\":\"Wenn Sie VBA-Funktionen entwickeln, sollen diese reproduzierbare und f\\u00fcr alle \\u00fcbergebenen Parameterwerte korrekte Ergebnisse liefern. Manch einer testet die Funktion dann f\\u00fcr einen Wert, erh\\u00e4lt das gew\\u00fcnschte Ergebnis, erh\\u00e4lt f\\u00fcr einen anderen Wert ein falsches Ergebnis, \\u00e4ndert die Funktion ... und: Irgendwann stellt sich heraus, dass diese nach den \\u00c4nderungen nicht mehr das korrekte Ergebnis f\\u00fcr den eingangs verwenden Parameter liefert. Hier hilft es, wenn Sie das Entwickeln von VBA-Funktionen etwas systematischer angehen, n\\u00e4mlich mit organisierten Tests. Dabei testen Sie die Funktion mit allen Parameterwerten, die Ihnen einfallen und wiederholen diese Tests auch nach \\u00c4nderungen an der Funktion, um sicherzustellen, dass die \\u00c4nderung der Funktion die Ergebnisse nicht beeinflusst. Wie das gelingt, zeigen wir in diesem Artikel.\",\"breadcrumb\":{\"@id\":\"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"item\":{\"@type\":\"WebPage\",\"@id\":\"https:\/\/access-basics.de\/\",\"url\":\"https:\/\/access-basics.de\/\",\"name\":\"Home\"}},{\"@type\":\"ListItem\",\"position\":2,\"item\":{\"@type\":\"WebPage\",\"@id\":\"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html\",\"url\":\"https:\/\/access-basics.de\/index.php\/VBAFunktionen_testen.html\",\"name\":\"VBA-Funktionen testen\"}}]},{\"@type\":\"Person\",\"@id\":\"https:\/\/access-basics.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"@id\":\"https:\/\/access-basics.de\/#personlogo\",\"inLanguage\":\"de\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","_links":{"self":[{"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/posts\/55000458","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/comments?post=55000458"}],"version-history":[{"count":0,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/posts\/55000458\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/media?parent=55000458"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/categories?post=55000458"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/tags?post=55000458"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}