{"id":55000006,"date":"2015-02-01T00:00:00","date_gmt":"2024-04-25T16:16:22","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=6"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Von_VBA_Zu_C_Arrays","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Von_VBA_Zu_C_Arrays\/","title":{"rendered":"Von VBA Zu C#: Arrays"},"content":{"rendered":"

\"\"<\/p>\n

Arrays gibt es wohl in jeder Programmiersprache, jeweils mit eigenen Besonderheiten. Wie füllt man ein Arrays? Wie greift man auf die Werte eines Arrays zu? Wie organisiert man mehrdimensionale Arrays? Wie durchläuft man die Werte eines Arrays oder ermittelt die Anzahl der enthaltenen Elemente? All diese Fragen beantwortet der vorliegende Artikel.<\/b><\/p>\n

Unter VBA konnten Arrays nur einfache Werttypen aufnehmen, also beispielsweise Zahlen oder Zeichenketten. Wenn Sie etwa Objekte in einer Liste speichern wollten, mussten Sie auf eine Alternative wie das Collection<\/b>– oder das Dictionary<\/b>-Objekt zugreifen.<\/p>\n

Unter C# können Sie dies gleichermaßen mit einem Array erledigen. Dies ist jedoch nicht der einzige Unterschied. In den folgenden Abschnitten erhalten Sie die Grundlagen für die Programmierung von Arrays mit C#.<\/p>\n

Deklaration von Arrays<\/h2>\n

Unter VBA haben Sie ein Array durch das Hinzufügen eines Klammernpaares bei der Deklaration kenntlich gemacht:<\/p>\n

Dim <\/span>Zahlwoerter() As String<\/span><\/pre>\n
Wenn Sie schon wussten, wie viele Elemente das Array enthalten sollte, haben Sie diese Anzahl in Klammern angegeben:<\/p>\n
Dim <\/span>Zahlwoerter(9) As String<\/span><\/pre>\n
Dies bedeutete ohne weitere Angaben, dass das Array zehn Elemente mit den Indizes 0 <\/b>bis 9 <\/b>aufnehmen konnte.<\/p>\n
Unter C# verwenden Sie keine runden, sondern eckige Klammern, und diese geben Sie auch nicht hinter dem Variablennamen, sondern hinter dem Datentyp an:<\/p>\n
string[] Zahlwoerter;<\/pre>\n
Nun ist natürlich noch nicht bekannt, wie viele Elemente das Array aufnehmen soll. Dies geben Sie auch nicht bekannt, indem Sie die Anzahl einfach in die eckigen Klammern schreiben. Vielmehr ist eine Initialisierung unter Angabe der Anzahl der Elemente nötig. Diese können Sie in einer neuen Zeile erledigen:<\/p>\n
Zahlwoerter = new string;<\/pre>\n
Oder Sie verwenden einfach einen Einzeiler zur gleichzeitigen Deklaration und Initialisierung:<\/p>\n
string[] Zahlwoerter = new string;<\/pre>\n
Die Verwendung des Schlüsselworts new <\/b>stellt hier im Gegensatz zum Vorgehen unter VBA heraus, dass es sich bei dem Array um ein Objekt handelt.<\/p>\n
Stellt sich gleich die erste Frage: Besitzt das Array nun zehn Elemente? Und die zweite gleich hinterher: Wie werden diese indiziert – beginnend mit 0 <\/b>oder 1<\/b>?<\/p>\n
Das Array enthält nun tatsächlich genau die angegebene Elementanzahl. Im Gegensatz zu der etwas unübersichtlichen Vorgehensweise von VBA, bei der die Anzahl von der Basis des Index abhängt, initialisiert C# genau mit der angegebenen Menge von Elementen.<\/p>\n
Der Index basiert unter C# auf dem Wert 0<\/b>. Auf ein Element greifen Sie über die Angabe des Indexwertes in eckigen Klammern zu, also etwa über Zahlwoerter[0] <\/b>– mehr dazu weiter unten.<\/p>\n
Array füllen<\/h2>\n
Schauen wir uns erstmal eine einfache Methode an, das Array zu füllen – und zwar direkt bei der Initialisierung. Ausgehend vom obigen Einzeiler gelingt dies so (in einer Zeile):<\/p>\n
string[] Zahlwoerter = new String { \"Eins\", \"Zwei\", \"Drei\", \"Vier\", \"Fünf\", \"Sechs\", \"Sieben\", \"Acht\", \"Neun\", \"Zehn\" };<\/pre>\n
Sie geben also einfach die gewünschten Werte in einer geschweiften Klammer und durch Kommata getrennt an.<\/p>\n
In diesem Fall soll das Array zehn Elemente aufnehmen und jedes der Elemente wird auch gleich gefüllt.<\/p>\n
Es gibt noch eine Alternative, bei der Sie die Anzahl der Elemente nicht angeben und diese direkt aus der Anzahl der übergebenen Elemente ermittelt wird. In diesem Fall lassen Sie einfach die Angabe der Anzahl innerhalb der eckigen Klammern weg (in einer Zeile):<\/p>\n
string[] Zahlwoerter = new String[] { \"Eins\", \"Zwei\", \"Drei\", \"Vier\", \"Fünf\", \"Sechs\", \"Sieben\", \"Acht\", \"Neun\", \"Zehn\" };<\/pre>\n
Anschließend geben wir die im Array gespeicherten Werte in der Konsole aus. Für den Zugriff auf den Inhalt eines der Elemente geben Sie den Variablennamen gefolgt vom gewünschten Index in eckigen Klammern an.<\/p>\n
Am einfachsten bekommen wir den Inhalt eines Elements so auf die Konsole:<\/p>\n
Console.WriteLine(Zahlen[0]);<\/pre>\n
Wir wollen aber gleich alle zehn, und dann auch noch mit einem kleinen Hinweistext:<\/p>\n
Console.WriteLine(\"Wert von Zahlwoerter[0]: {0}\", Zahlen[0]);\r\nConsole.WriteLine(\"Wert von Zahlwoerter: {0}\", Zahlen);\r\nConsole.WriteLine(\"Wert von Zahlwoerter: {0}\", Zahlen);\r\n...\r\nConsole.WriteLine(\"Wert von Zahlwoerter: {0}\", Zahlen);<\/pre>\n
Das Ergebnis sieht nun wie folgt aus:<\/p>\n
Wert von Zahlwoerter[0]: Eins\r\nWert von Zahlwoerter: Zwei\r\nWert von Zahlwoerter: Drei\r\n...\r\nWert von Zahlwoerter: Zehn<\/pre>\n
Wichtig: Wenn Sie die Anzahl der zu erstellenden Elemente angeben und gleich dahinter die Elemente hinzufügen, muss deren Anzahl übereinstimmen.<\/p>\n
Die schnellste Alternative, um ein Array direkt mit Werten zu füllen, lässt noch ein paar Schlüsselwörter weg und übergibt die Werte direkt als Array an die Variable:<\/p>\n
string[] Zahlwoerter = { \"Eins\", \"Zwei\", \"Drei\", \"Vier\", \"Fünf\", \"Sechs\", \"Sieben\", \"Acht\", \"Neun\", \"Zehn\" };<\/pre>\n
Elemente nach Initialisierung füllen<\/h2>\n
Wenn Sie das Array zunächst deklarieren und initialisieren, aber noch nicht füllen, holen Sie dies in späteren Anweisungen nach.<\/p>\n
Dazu weisen Sie einfach dem entsprechenden Element, das Sie über die Angabe des Indexwertes in eckigen Klammern referenzieren, den gewünschten Wert zu:<\/p>\n
string[] Zahlwoerter = new string;\r\nZahlwoerter[0] = \"Eins\";\r\nZahlwoerter = \"Zwei\";\r\nZahlwoerter = \"Drei\";<\/pre>\n
Wenn Sie nun alle Elemente ausgeben, bleiben die hinteren sieben leer. Die Elemente werden bei der Initialisierung gleich mit leeren Zeichenketten gefüllt.<\/p>\n
0 als initialer Wert von Zahlen-Arrays<\/h2>\n
Probieren wir dies gleich noch mit Zahlen aus, um zu prüfen, mit welchem Wert das Element eines Zahlen-Arrays initial gefüllt wird:<\/p>\n
int[] Zahlen = new int;\r\nZahlen[0] = 1;\r\nZahlen = 2;\r\nZahlen = 3;\r\nConsole.WriteLine(\"Wert von Zahlen[0]: {0}\", Zahlen[0]);\r\nConsole.WriteLine(\"Wert von Zahlen: {0}\", Zahlen);\r\nConsole.WriteLine(\"Wert von Zahlen: {0}\", Zahlen);\r\nConsole.WriteLine(\"Wert von Zahlen: {0}\", Zahlen);\r\nConsole.WriteLine(\"Wert von Zahlen: {0}\", Zahlen);<\/pre>\n
Wir definieren also ein Array mit fünf int<\/b>-Elementen und füllen dann nur drei davon. Das Ergebnis bei der Ausgabe aller Elemente inklusive der übrigen zwei sieht so aus:<\/p>\n
Wert von Zahlen[0]: 1\r\nWert von Zahlen: 2\r\nWert von Zahlen: 3\r\nWert von Zahlen: 0\r\nWert von Zahlen: 0<\/pre>\n
Leere Zahlenelemente werden also direkt mit dem Wert 0 <\/b>gefüllt.<\/p>\n
Größe einer Dimension eines Array ermitteln<\/h2>\n
Unter VBA ermitteln Sie die Größe eines Arrays über die Differenz der Funktionen UBound <\/b>und LBound <\/b>mit dem Array als Parameter:<\/p>\n
Debug.Print<\/span> UBound<\/span>(intZahlen()) - LBound<\/span>(intZahlen())<\/pre>\n
Für mehrdimensionale Arrays gibt es noch weitere Besonderheiten. Unter C# gibt es verschiedene Eigenschaften, mit denen Sie die Anzahl der Elemente einer Dimension sowie die Gesamtzahl der Elemente ermitteln können. Zunächst reicht uns die Anzahl der Elemente einer einzigen Dimension. Die erhalten Sie mit der Funktion GetLength<\/b>:<\/p>\n
Console.WriteLine(Zahlen.GetLength(0));<\/pre>\n
GetLength <\/b>erwartet als Parameter den Index der zu untersuchenden Dimension, in diesem Fall 0<\/b>.<\/p>\n
Im Falle eines eindimensionalen Arrays liefert die Funktion Length <\/b>den identischen Wert. Für mehrdimensionale Arrays liefert sie hingegen die Anzahl aller Elemente. Dementsprechend kommt sie ohne Parameter aus:<\/p>\n
Console.WriteLine(Zahlen.Length);<\/pre>\n
Größe des Arrays zur Laufzeit ändern <\/h2>\n
Weiter oben haben Sie bereits gesehen, dass Sie die Größe eines Arrays zur Laufzeit festlegen können. Dies ist gleichbedeutend mit der Initialisierung. Den dort angegebenen Zahlenwert, der die Anzahl der Elemente angibt, kann auch als Variable übergeben werden – nicht immer ist ja gleich beim Programmieren bekannt, wie groß ein Array gegebenenfalls werden soll.<\/p>\n
Im folgenden Beispiel legen wir die Anzahl der Elemente per Variable fest (die natürlich auch etwa über die Konsole abgefragt oder auf andere Weise ermittelt werden kann) und initialisieren das Array damit:<\/p>\n
string[] Zahlwoerter;\r\nint AnzahlZahlwoerter;\r\nAnzahlZahlwoerter = 10;\r\nZahlwoerter = new string[AnzahlZahlwoerter];<\/pre>\n
Aber was geschieht, wenn wir das Array bereits mit Werten füllen oder auslesen wollen, aber später die Größe des Arrays ändern müssen? Mit der Initialisierung per new<\/b>-Schlüsselwort ist uns nicht geholfen, da das Array dann ja wieder leer ist.<\/p>\n
Genau genommen gibt es bei den Arrays keine Möglichkeit, es ohne Umweg zu vergrößern oder zu verkleinern. Immerhin gibt es einen Workaround. Dabei verwenden wir neben dem eigentlichen Array Zahlen <\/b>ein Hilfsarray namens temp<\/b>. Zahlen <\/b>deklarieren wir als Array mit der Elementanzahl 0<\/b>, temp <\/b>zunächst ohne Initialisierung.<\/p>\n
Dann durchlaufen wir eine Schleife von 1 <\/b>bis 10<\/b>, da wir dem Array mit jedem Durchlauf ein weiteres Element hinzufügen und dieses mit dem Wert der Zählervariablen füllen wollen. Innerhalb der Schleife initialisieren wir das Hilfsarray temp <\/b>zunächst mit einer Größe, welche dem Wert der Zählervariablen entspricht.<\/p>\n
Dann verwenden wir die CopyTo<\/b>-Methode des Arrays Zahlen<\/b>, um dessen Inhalt in das Array temp <\/b>zu kopieren. Schließlich stellen wir den Zeiger der Variablen Zahlen auf das nun in temp <\/b>befindliche Array ein und weisen dem neu hinzugefügten Element den Wert der Zählervariablen hinzu:<\/p>\n
int[] Zahlen;\r\nZahlen = new int[0];\r\nint[] temp;\r\nfor (int i = 1; i <= 10; i++)\r\n{\r\n     temp = new int[i];\r\n     Zahlen.CopyTo(temp, 0);\r\n     Zahlen = temp;\r\n     Zahlen[i-1] = i;\r\n}<\/pre>\n
Anschließend verwenden wir, um ein wenig Dynamik in die Sache zu bringen, wiederum eine Schleife, um den Inhalt des Arrays auszulesen.<\/p>\n
Die Abbruchbedingung definieren wir diesmal allerdings mithilfe der Anzahl der im Array Zahlen <\/b>befindlichen Elemente (Zahlen.GetLength<\/b>):<\/p>\n
for (int i = 1; i <= Zahlen.GetLength(0); i++)\r\n{\r\n     Console.WriteLine(\"Wert von {0}: {1}\", i, Zahlen[i-1]);\r\n}<\/pre>\n
Arrays mit foreach durchlaufen<\/h2>\n
In den bisherigen Beispielen haben wir die for<\/b>-Schleife verwendet, um die Elemente eines Arrays zu durchlaufen. Unter VBA die einzige Möglichkeit die entsprechende For…Next<\/b>-Schleife.<\/p>\n
Unter C# gibt es hingegen noch eine weitere Methode, um die Elemente eines Arrays zu durchlaufen, nämlich mit der foreach<\/b>-Schleife. Auch unter VBA kennen Sie eine entsprechende Schleife, die mit den Schlüsselwörtern For Each <\/b>beginnt. Diese ist jedoch dem Zugriff auf die Elemente von Objektauflistungen vorbehalten.<\/p>\n
Das Array ist unter C# jedoch ein Objekt, daher können Sie seine Elemente auch mit der foreach<\/b>-Schleife durchlaufen.<\/p>\n
Im folgenden Beispiel füllen wir ein Array mit zehn Zahlwörtern und durchlaufen dann eine foreach<\/b>-Schleife. Diese deklariert mit string Element <\/b>die Laufvariable, welche die Inhalte des Arrays aufnehmen soll, als Element des Arrays (in Zahlwoerter<\/b>). Innerhalb der foreach<\/b>-Schleife gibt die WriteLine<\/b>-Anweisung direkt den Inhalt der string<\/b>-Variablen Element <\/b>in der Konsole aus:<\/p>\n
string[] Zahlwoerter = { \"Eins\", \"Zwei\", \"Drei\", \"Vier\", \"Fünf\", \"Sechs\", \"Sieben\", \"Acht\", \"Neun\", \"Zehn\" };\r\nforeach (string Element in Zahlwoerter)\r\n{\r\n     Console.WriteLine(Element);\r\n}<\/pre>\n
Der Nutzen der foreach<\/b>-Schleife ist in diesem Fall jedoch begrenzt. Wenn Sie beispielsweise den Indexwert benötigen, müssten Sie eine Laufvariable mitlaufen lassen, was Sie mit einer for<\/b>-Schleife direkt in der Schleife erledigen können.<\/p>\n
Außerdem können sie die mehrdimensionalen Arrays, die wir im Anschluss vorstellen, nur sequentiell durchlaufen, was einen gezielten Zugriff auf die Elemente erschwert.<\/p>\n
Mehrdimensionale Arrays<\/h2>\n
Mehrdimensionale Arrays kennen Sie auch schon von VBA. Unter C# ist die Vorgehensweise ähnlich. Das folgende Beispiel deklariert zunächst ein Array namens Schach<\/b>. Dass es zweidimensional sein soll, geben wir durch das Komma zwischen den eckigen Klammern an.<\/p>\n
Danach initialisieren wir das Array und stellen die Größe der einzelnen Dimensionen jeweils auf 2 <\/b>ein. Das Array soll also zweimal zwei Elemente aufnehmen. Die Indizes der beiden Dimensionen basieren wieder jeweils auf dem Wert 0<\/b>, sodass wir die Indexpaare 0, 0<\/b>, 0, 1<\/b>, 1, 0<\/b>, 1, 1<\/b> nutzen können, um die Werte zuzuweisen:<\/p>\n
string[,] Schach;\r\nSchach = new string[2,2];\r\nSchach[0, 0] = \"A1\";\r\nSchach[0, 1] = \"A2\";\r\nSchach[1, 0] = \"B1\";\r\nSchach[1, 1] = \"B2\";<\/pre>\n
Anschließend durchlaufen wir das frisch erstellte und gefüllte Array innerhalb von zwei verschachtelten for<\/b>-Schleifen.<\/p>\n
Deren Abbruchbedingung richten wir wieder an der Anzahl Elemente je Dimension des Arrays aus (Schach.GetLength(0) <\/b>für die erste Dimension, Schach.GetLength(1) <\/b>für die zweite Dimension):<\/p>\n
for(int i = 0; i <= Schach.GetLength(0)-1; i++) \r\n{\r\n     for (int j = 0; j <= Schach.GetLength(1)-1; j++)\r\n     {\r\n         Console.WriteLine(\"Feld ({0}|{1}): {2}\", i, j, \r\n                                             Schach[i, j]);\r\n     }\r\n}<\/pre>\n
Das Ergebnis sieht wie folgt aus:<\/p>\n
Feld (0|0): A1\r\nFeld (0|1): A2\r\nFeld (1|0): B1\r\nFeld (1|1): B2<\/pre>\n
Mehrdimensionale Arrays einfach füllen<\/h2>\n
Ein zweidimensionales Array können Sie auch wieder direkt beim Initialisieren mit Daten füllen. Dabei ist zu beachten, dass etwa beim zweidimensionalen Array jedes Wertpaar in ein eigenes Paar geschweifter Klammern eingefasst werden muss, also etwa {{“A1″,”A2”}, {“B1″,”B2”}}<\/b>.<\/p>\n
Die komplette Anweisung sieht so aus:<\/p>\n
string[,] Schach = \r\n          new string[,] { { \"A1\", \"A2\" }, { \"B1\", \"B2\" } };<\/pre>\n
Sie könnten die Dimensionen hier auch wieder explizit angeben:<\/p>\n
string[,] Schach = \r\n       new string[2, 2] { { \"A1\", \"A2\" }, { \"B1\", \"B2\" } };<\/pre>\n
Oder Sie verwenden gleich die einfachste Schreibweise mit der direkten Zuweisung der Werte:<\/p>\n
string[,] Schach = { { \"A1\", \"A2\" }, { \"B1\", \"B2\" } };<\/pre>\n
Zweidimensionales Array per Schleife füllen<\/h2>\n
Schauen wir uns noch ein Array mit den Koordinaten eines kompletten Schachbretts an. Hier wollen wir nicht mehr die einzelnen Koordinaten von Hand codieren, sondern zwei Schleifen füllen des Arrays mit acht mal acht Feldern nutzen.<\/p>\n
Dazu erzeugen wir zunächst die Variable Schach <\/b>mit acht mal acht Elementen und durchlaufen dann zwei verschachtelte for<\/b>-Schleifen von 0 <\/b>bis 7<\/b>. Innerhalb der Schleife fügen wir dem jeweils durch die Werte der Laufvariablen i <\/b>und j <\/b>charakterisierten Element einen Ausdruck hinzu, der aus zwei Teilen besteht:<\/p>\n
    \n
  • (char)(i + 65) <\/b>ermittelt wie die von VBA bekannte Chr<\/b>-Funktion das Zeichen zu einem ASCII-Code. Dabei konvertiert char <\/b>also quasi den dahinter angegebenen Zahlenwert in ein Zeichen. 65 <\/b>entspricht dem Buchstaben A<\/b>, daher liefert im ersten Durchgang mit i = 0 <\/b>genau diesen Buchstaben.<\/li>\n
  • Convert.ToString(j + 1) <\/b>hingegen berechnet den Zahlenwert von j + 1 <\/b>und konvertiert dies mit der ToString<\/b>-Methode der Convert<\/b>-Klasse in eine Zeichenkette, damit die so ermittelte Zahl problemlos mit dem zuvor ermittelten Buchstaben zusammengeführt werden kann.<\/li>\n<\/ul>\n
    string[,] Schach = new string [8,8];\r\nfor (int i = 0; i <= 7; i++)\r\n{\r\n   for (int j = 0; j <= 7; j++)\r\n   {\r\n     Schach[i, j] = (char)(i + 65) + Convert.ToString(j + 1);\r\n   }\r\n}<\/pre>\n
    Danach durchlaufen wir wiederum zwei verschachtelte Schleifen und geben die Inhalte des Arrays in der Konsole aus:<\/p>\n
    for (int i = 0; i <= Schach.GetLength(0) - 1; i++)\r\n{\r\n     for (int j = 0; j <= Schach.GetLength(1) - 1; j++)\r\n     {\r\n         Console.Write(\"{0,4}\", Schach[i, j]);\r\n     }\r\n     Console.WriteLine();\r\n}<\/pre>\n
    Das Ergebnis sieht schließlich wie folgt aus:<\/p>\n
       A1  A2  A3  A4  A5  A6  A7  A8\r\n   B1  B2  B3  B4  B5  B6  B7  B8\r\n   C1  C2  C3  C4  C5  C6  C7  C8\r\n   D1  D2  D3  D4  D5  D6  D7  D8\r\n   E1  E2  E3  E4  E5  E6  E7  E8\r\n   F1  F2  F3  F4  F5  F6  F7  F8\r\n   G1  G2  G3  G4  G5  G6  G7  G8\r\n   H1  H2  H3  H4  H5  H6  H7  H8<\/pre>\n
    Gesamtzahl der Elemente ermitteln<\/h2>\n
    Nachdem wir nun bereits ein zweidimensionales Array erstellt haben, können wir uns mit der folgenden Anweisung auch gleich die Anzahl der Elemente aller Dimensionen ausgeben lassen, die in diesem Beispiel bei 64 <\/b>liegt:<\/p>\n
    Console.WriteLine(\"Gesamtzahl: {0}\", Schach.Length);<\/pre>\n","protected":false},"excerpt":{"rendered":"
    Arrays gibt es wohl in jeder Programmiersprache, jeweils mit eigenen Besonderheiten. Wie füllt man ein Arrays? Wie greift man auf die Werte eines Arrays zu? Wie organisiert man mehrdimensionale Arrays? Wie durchläuft man die Werte eines Arrays oder ermittelt die Anzahl der enthaltenen Elemente? All diese Fragen beantwortet der vorliegende 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":[66012015,662015,44000001,44000035,44000013,44000022],"tags":[],"yst_prominent_words":[66062094,66062087,66062092,66062081,66062082,66062084,66062086,66062083,66062088,66062099,66062091,66062097,66062090,66062089,66062085,66062095,66062098,66062093,66062096,66062100],"class_list":["post-55000006","post","type-post","status-publish","format-standard","hentry","category-66012015","category-662015","category-CGrundlagen","category-COMDLLs_programmieren","category-Visual_Studio_nutzen","category-Von_Access_zu_NET"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000006","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000006"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000006\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000006"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000006"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000006"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000006"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}