JSON: Ein kompaktes, strukturiertes Datenformat

Das JSON-Format ist ein kompaktes Datenformat für einfach strukturierte Daten. Die Syntax beschränkt sich dabei auf einige wichtige Zeichen zum Einleiten von Objekten, Arrays und Strings, wodurch sich der Overhead in Grenzen hält. JSON-Strings lassen sich in vielen Programmiersprachen auf einfache Weise parsen. So kann man zum Beispiel einen AJAX-Request entgegen nehmen und den JSON-String dann in ein ganz normales PHP-Objekt verwandeln.

Und falls man eine Antwort auf die Anfrage schicken will, kann man ein ganz normales PHP-Array auch in einen JSON-String konvertieren. Um ein PHP-Array in einen JSON-String zu konvertieren übergibt man das Array einfach an die PHP-Funktion json_encode, die einen gültigen JSON-String zurück liefert. Will man einen JSON-String in ein PHP-Objekt konvertieren, dann nimmt man dafür json_decode, oder folgendes, um in ein PHP-Array zu konvertieren:

json_decode($json_data, true)

Unterstützte Datenformate- und Strukturen

Ein JSON-Objekt kann wiederum mehrere Objekte oder Arrays beinhalten. Boolesche Werte werden komplett klein geschrieben, ebenso wie der NULL-Wert. Zeichenketten kommen zwischen zwei doppelte Anführungszeichen (einfache Anführungszeichen sind nicht erlaubt) und Zahlen können sowohl negativ (ein Minus als Vorzeichen) als auch positiv sein und dürfen auch Punkte für die Darstellung von Float-Zahlen enthalten.

Objekte beginnen mit { und enden mit }; Arrays beginnen mit [ und enden mit ]. Der Schlüssel und der zugehörige Wert werden durch einen doppelpunkt (:) voneinander getrennt. Innerhalb von Objekten und Arrays werden die einzelnen Zuweisungen durch ein Kommata (,) voneinander getrennt.

{
	"nullwert": null,
	"boolean": true,
	"number": 1048,
	"object": {
		"key1": "Foo",
		"key2": "Bar",
		"key3": false},
	"array": ["One", "Two", "Three"]
}

AJAX: Asynchroner Datenaustausch mit JSON

Im Webbereich kann man JSON am besten beim asynchronen Datenaustausch mit AJAX zwischen Server und Client einsetzen. Der Einsatz innerhalb von PHP, also dort, wo nichts vom Client kommt oder an den Client gesendet werden muss, lohnt es sich meiner Meinung nach nicht, ein bestehendes PHP-Array in einen JSON-String zu konvertieren um ihn dann bei nächster Verwendung wieder in ein PHP-Objekt zurück zu konvertieren. Sinnlos.

Der Vorteil beim Datenaustausch mit JSON ist, dass die Daten typisiert sind und man sie am Client schon strukturiert entgegennehmen kann, um sie dann weiter zu verarbeiten. Selbiges geht auch mit XML, allerdings hat XML bei einfach strukturierten Daten einen großen Markup-Overhead, der sich durch die Verwendung von JSON stark reduzieren lässt.

PHP: Ein Array in einen JSON-String konvertieren

Hier ein Beispiel wie man ein PHP-Array mit der Funktion json_encode in ein JSON-Objekt konvertieren kann:

$php_array = [
	'parameter1' => true,
	'parameter2' => 1234,
	'parameter3' => ['abc']
];

echo json_encode($php_array);

{"parameter1":true,"parameter2":1234,"parameter3":"abc"}

Um aus dem JSON-Objekt wieder ein PHP-Objekt zu erzeugen, übergibt man den String, der das JSON-Objekt repräsentiert, einfach an die Funktion json_decode, die ein PHP-Objekt mit den Daten aus dem JSON-Objekt zurückgibt:

$json_data='{"parameter1":true,"parameter2":1234,"parameter3":"abc"}';

var_dump(json_decode($json_data));

object(stdClass)#1 (3) {
  ["parameter1"]=>
  bool(true)
  ["parameter2"]=>
  int(1234)
  ["parameter3"]=>
  string(3) "abc"
}

Der zweite Parameter von json_decode

Gerade wurde das JSON-Objekt in ein PHP-Objekt umgewandelt. Man kann das JSON-Objekt aber auch explizit in ein assoziatives PHP-Array umwandeln lassen, indem man der Funktion den zweiten Parameter TRUE übergibt:

$json_data = '{
	"nullwert": null,
	"boolean": true,
	"number": 1048,
	"object": {
		"key1": "Foo",
		"key2": "Bar",
		"key3": false},
	"array": ["One", "Two", "Three"]
}';

var_dump(json_decode($json_data));

echo "Und hier mit TRUE als zweiten Parameter:\n";
var_dump(json_decode($json_data, TRUE));

object(stdClass)#1 (5) {
  ["nullwert"]=>
  NULL
  ["boolean"]=>
  bool(true)
  ["number"]=>
  int(1048)
  ["object"]=>
  object(stdClass)#2 (3) {
    ["key1"]=>
    string(3) "Foo"
    ["key2"]=>
    string(3) "Bar"
    ["key3"]=>
    bool(false)
  }
  ["array"]=>
  array(3) {
    [0]=>
    string(3) "One"
    [1]=>
    string(3) "Two"
    [2]=>
    string(5) "Three"
  }
}
Und hier mit TRUE als zweiten Parameter:
array(5) {
  ["nullwert"]=>
  NULL
  ["boolean"]=>
  bool(true)
  ["number"]=>
  int(1048)
  ["object"]=>
  array(3) {
    ["key1"]=>
    string(3) "Foo"
    ["key2"]=>
    string(3) "Bar"
    ["key3"]=>
    bool(false)
  }
  ["array"]=>
  array(3) {
    [0]=>
    string(3) "One"
    [1]=>
    string(3) "Two"
    [2]=>
    string(5) "Three"
  }
}

Fazit

Das JSON-Format für einfach strukturierte Daten einzusetzen bedeutet minimalen Overhead bei geringerem Ressourcenverbrauch (siehe XML) und bessere Übersichtlichkeit. Am besten lässt sich das JSON-Format in Kombination mit Javascript einsetzen, wo Informationen asynchron zwischen Server und Client ausgetauscht werden.

Bei einer typischen AJAX-Anwendung könnte das zum Beispiel beim Nachladen von Einträgen aus der Datenbank sein. Dort enthält das vom Server zurückgelieferte JSON-Objekt dann die Daten, die in's HTML eingefügt werden sollen, sowie weitere Informationen wie z.B. die Information darüber, ob das nun alle Einträge waren und an welcher ID man sich gerade befindet. Die Möglichkeiten sind natürlich unbegrenzt.