Mit folgenden Code-Schnipseln kann man einen JSON-String in ein Array umwandeln:

1
2
3
4
5
6
7
8

try
{ 
var prod = YAHOO.lang.JSON.parse(jsonString); 
}
catch (e)
{
alert("Invalid product data"); 
}

Ebenfalls ist es möglich aus einem Array einen JSON String umzuwandeln. Das Beispiel findet sich im JSON Manual der YUI Seite. Wer YUI und JSON gemeinsam verwendet, kann sich nun getrost zurücklehnen und alles aus einem Guß verwenden .

Als Beispiel nehmen wir ein Formular, welches eine Anfrage via AJAX an den Server schickt und die Antwort des Servers wieder in das Script zurückholt. Hierzu verwenden wir die eingebettete JSON-Funktionalität. Hierbei sei zu beachten, dass Prototype auf einem JSON-Objekt auch nur mit eval() operiert. Hier besteht also bei Produktivanwendungen noch Prüfungsbedarf. Mit Prototype kann man auf jeden Fall vor der Ausgabe Script-, HTML-Tags etc. entfernen lassen, wenn man das möchte. Das schützt allerdings nicht vor dem Angriff durch JavaScript, welches sich in der Response des Servers befindet und direkt ausgeführt werden könnte.
JSON kann bei Prototype via Header und “normaler” Übergabe übertragen werden. Bei der Übergabe per Header muss der X-JSON-Header gesendet werden. Bei größeren Datenmengen empfielt sich jedoch wieder das echo. Dies wird von Prototype erkannt, wenn der Content-Type text/javascript ist. Ich stelle hier die Lösung mit X-JSON-Header vor. Wichtig ist hier wieder, dass die JSON-Extention[3] für PHP installiert ist, bzw. eincompiliert[2] ist.

Beginnen wir also mit dem AJAX-Beispiel. Vorrausgesetzt ist hier, dass die Datei prototype.js korrekt im Header der HTML-Seite eingebunden ist, ich denke das muss ich nicht erklären . Für die eigenen Funktion verwende ich eine weitere JavaScript-Datei article-prototype.js. Falls das doch jemandem nicht ganz klar sein sollte, verweise ich jetzt mal frech auf selfhtml[4]. Ich verwende hier auch Inline-JavaScript, was ich eigentlich mittels Behaviours verstecken würde, aber das wird evtl. Thema eines neuen Artikels sein .

Zunächst basteln wir uns eine HTML-Seite, die eine FORM enthält, in der man mittels einer Selectbox einen oder alle Datensätze wählen kann:

<h2>Daten wählen</h2>
 
<form action="#" method="post">
	<label for="datensatz">Datensätze ausgeben</label>
<select id="datensatz" name="datensatz">
		<option value="0">Alle Datensätze</option>
		<option value="1">Datensatz 1</option>
		<option value="2">Datensatz 2</option>
		<option value="3">Datensatz 3</option>
		<option value="4">Datensatz 4</option>
		<option value="5">Datensatz 5</option>
	</select>
<input onclick="RequestData();" type="button" value="Daten abholen" />
</form>
 
<h2>Ausgabe</h2>
 
 
<div id="output">Keine Daten ausgewählt</div>

Jetzt legen wir eine Funktion an, die unseren AJAX-Aufruf beherbergt:

var RequestData = function ()
{
   new Ajax.Request
   (
      '/test/prototype-server.php',
	{
	   method:'post',
	   parameters: { datensatz: parseInt($('datensatz').value) },
	   onSuccess: function(transport, json)
	   {
		handleSuccess(json);
	   },
		onFailure: function()
		{
			handleFailure();
		}
	}
   );
}

Wir haben jetzt eine Funktion, die ein AJAX-Objekt angelegt und die Methode POST verwendet, implementiert. Über parameters: kann man die einzelnen Parameter angeben, die man an den Request übergeben will. Hier verwende ich die von Prototype implementierte Kuzform für document.getElementById(‘datensatz’) ($(‘id-name’)). Möchte man eine komplette Form übergeben, bietet Prototype eine Serialisierung der Daten:

$('id_of_form_element').serialize(true)

Als nächstes definieren wir die vorgegebenen Funktionen onSuccess und onFailure. Verwendet man JSON, werden zwei Variablen an onSuccess übergeben, die zweite enthält dann die Response-Daten als JSON-Objekt. Die Bedeutung der Funktionen sollte selbsterklärend sein. Der Übersicht halber machen diese Funktionen nichts anderes, als eine andere Funktion aufzurufen. Die Fehler-Funktion ist hier recht unspektakulär und wird nur aufgerufen, wenn ein Timeout beim Request eintritt:

var handleFailure = function()
{
   alert('Ein Problem ist aufgetreten, die Daten konnten nicht abgeholt werden');
}

Jetzt geben wir einfach die abgeholten Daten aus. Hierzu leeren wir zunächst den Content-Container. Danach laufen wir mit einer Schleife durch das Result:

var handleSuccess = function(response)
{
	$('output').innerHTML = '';
 
	for(i = 0; i < response.length; i++)
	{
		$('output').innerHTML += i+1;
		$('output').innerHTML += ' => '
		$('output').innerHTML += response[i];
		$('output').innerHTML += '';
	}
}

Danach können wir unsere Ausgabe bestaunen . Der Server dazu sieht übrigens so aus:

$AryData = new ArrayObject ( array( 'PHP','Perl', 'Python', 'C++' , 'C#') );
 
if((int)$_POST['datensatz'] == 0)
{
	$Output = $AryData;
}
else
{
	$Output = $AryData [ (int)$_POST['datensatz'] – 1];
}
 
header('X-JSON: '.json_encode((array) $Output));

Das Ganze ist beliebig erweiterbar und auf jeden Fall recht mächtig. Prototype nimmt einem an vielen Stellen eine Menge Arbeit ab und es läuft großteils auch alles in fast allen gängigen Browsern . Das war natürlich nur ein Feature von vielen, die Prototype bietet, mehr findet man auch auf der Webseite[1].

Bei Fragen, Problemen etc. einfach einen Kommentar hinterlassen . Die Sourcen versende ich auf Anfrage. Interessenten können auch gerne einen Kommentar hinterlassen; ist vielleicht weniger Arbeit, als alles hier rauszukopieren.

Links
[1] http://www.prototypejs.org
[2] http://de.php.net/json
[3] http://pecl.php.net/package/json
[4] http://de.selfhtml.org

Zur Übertragung der Daten gibt es einige Formate, die sich in der Praxis bewiesen haben. Hierzu gehören u.a. XML, reST, JSON und SOAP.

Was ist JSON?
JSON steht für JavaScript Object Notation. Hierbei wird auf Anforderung mit einem Algorithmus serverseitig aus einem Objekt (z.B. einem PHP-Array) ein JSON-Objekt serialisiert. JSON-Objekte haben den Vorteil gegenüber XML, dass sie wenige Bytes für die eigenen Strukturinformationen verwenden und somit wenig Overhead beim Übertragen von Daten erzeugt wird. Will man natürlich komplexe Datenstrukturen übertragen, sollte man sich überlegen XML zu verwenden, denn hier sind die Methoden zum Zugriff auf die Baumstruktur der Daten ausgereift und verschwenden weniger Rechenleistung des Clients. Zum Übertragen von Arrays mit überschaubarer Verschachtelung ist JSON aber die richtige Wahl.

Bei der Wahl des Datenformats sollte man bedenken, dass auf Seiten des Clients zusätzlich Rechenleistung von Nöten ist, um die Daten zur Ausgabe aus dem Format zu extrahieren.

Verarbeitung
Erhält man nun von Serverseite ein JSON-Objekt, hat man zwei Methoden zur Auswahl um aus diesem Objekt ein verwendbares Javascript-Objekt zu erzeugen:

1. eval()
Mittels eval() kann man ein JSON-Objekt direkt ausführen und so zu einem benutzbaren Javascript-Objekt machen. Das hat den gewaltigen Nachteil, dass nicht vertrauenswürdige Daten ausgeführt würden könnten und somit auch schadhafter Code ausgeführt werden kann. Daher sollte man darauf verzichten.

2. JSON-Parser
Ein JSON-Parser[1] bietet ebenso die Möglichkeit aus einem JSON-Objekt ein brauchbares Javascript-Objekt zu erzeugen. Hierbei kann man entscheiden, was man mit im JSON-Objekt vorhandenen Methoden vorgeht. Man kann sie umwandeln oder auch nicht. Der hier verwendete JSON-Parser überläd bei Einbindung alle Strings, Arrays etc. und ergänzt nötige Methoden für das umwandeln in ein Javascript-Objekt. Bei Bedarf können diese dann aufgerufen werden.

Ein Beispiel:
Wir haben ein PHP-Array. Dieses wird dann mittels der in PHP 5.2 enthaltenen JSON-Bibliothek[2] codiert. Für Versionen < PHP 5.2 ist eine Extention in PECL vorhanden [3].

$Data = array
(
	array
	(
		'name' => 'Stephan',
		'ort' => 'Bonn'
	),
	array
	(
		'name' => 'Thomas',
		'ort' => 'Köln'
	)
);
echo json_encode($Data);

Diese Daten werden nun via AJAX übertragen. In der Callback-Funktion des AJAX-Objekts haben wir dann folgende Code-Stelle:

var Data = response.responseText.parseJSON();

Der Funktion parseJSON können auch noch zusätzliche Filter übergeben werden, mit denen man entscheiden kann, wie mit Methoden etc. umgegangen werden soll. Dies lassen wir hier mal außen vor. Jetzt können wir einzelne Daten hiervon ausgeben:

alert(Data[0]['name']);

Der JSON-Parser erkennt, dass es sich hierbei um ein Array handelt und wandelt es um. Es ist also recht einfach die Daten zurückzuwandeln.

So kann man einfach und schnell Daten von PHP nach Javascript übertragen und diese dort weiterverarbeiten ohne ein externes Framework einzubinden (welche natürlich auch ihre Vorteile haben).

Demnächst werde ich in einem eigenen Artikel auf AJAX mit Prototype eingehen, lasst Euch überraschen .

Links
[1] http://www.json.org/
[2] http://de.php.net/json
[3] http://pecl.php.net/package/json