PHP: Verschachtelte Strukturen bauen

[Marscel]

Ich sitze gerade an einem etwas intelligenterem HTML-Template-System. Geplant dafür war, dass es im Template Platzhalter gibt, die ruhig auch im n-ten verschachtelten Block sein können, aber alle in der selben Struktur zu finden sind.

So soll später:

<!-- START x -->
<b>{x.NAME}</b>
<!-- END x -->

durch so eine Struktur (sowas unter PHP als Array zu bezeichnen find ich doof):

x =>
0 =>
"NAME" => "Bla"
1 =>
"NAME" => "Blub"

dann so aussehen:

<b>Bla</b>
<b>Blub</b>

Das wäre ein simpler Fall, natürlich soll [x][0] bzw. [x][1] noch beliebig tiefer gehen können. Eine weitere Vorraussetzung ist, dass man wie es einem passt, neue Knoten und Werte hinzufügen kann. Dazu muss es irgendwas geben, wo man die Strukturen beliebig tief erweitern und verändern kann.

Die Frage ist für mich nun, was kann man da intelligent machen, dass das Skript nicht bei großen Seiten mehrere Sekunden braucht, aber praktisch wie ein Knoten-Dokument verwaltbar ist.

Ich hab den Nachmittag nun gegrübelt und etwas gebastelt, hier mal die Extrakte der Klasse:

function output_namespace_to_struct($namespaces, $attach_to_last)
{
if(!is_array($namespaces) || count($namespaces) < 1)
{
return false;
}

$count = count($namespaces)-1;

$new_struct[$namespaces[$count]][] = $attach_to_last;

unset($namespaces[$count]);

--$count;

if($count > -1)
{
return output_namespace_to_strcut($namespaces, $new_struct);
}
return $new_struct;
}

function output_struct_merge(&$original_struct, $array)
{
if(!is_array($original_struct) || !is_array($array))
{
return false;
}

foreach($array as $key => $val)
{
$isset = isset($original_struct[$key]);
$o_is_array = is_array($original_struct[$key]);
$v_is_array = is_array($val);

if($isset && !$o_is_array && !$v_is_array && ($original_struct[$key] != $val))
{
$original_struct[$key] = $val;
}
if($isset && $o_is_array && $v_is_array)
{
output_struct_merge($original_struct[$key], $val);
}
if($isset && !$o_is_array && $v_is_array)
{
$original_struct[] = $val;
}
if($isset && $o_is_array && !$v_is_array)
{
$original_struct[$key][] = $val;
}
if(!$isset)
{
$original_struct[$key] = $val;
}
}
return true;
}

Die erste Funktion soll aus einem Array von Namespace-Namen (sowas wie im Code 'x') eine verschachtelte Struktur bauen und die Daten einfügen, die zweite Funktion soll es erlauben, die "originale" Struktur soll nun mit einer zweiten Verglichen und Daten zu synchronisieren (array_merge() tuts nicht so wie ich will).

Es funktioniert alles, wie es soll, das Parsen später ist erstmal unwichtig, ich würde nur gerne von euch wissen, wie es mit dieser Idee aussieht.

Marscel

[MadMan2k]

schreibst du sonst C, oder warum ist dein Code so scheisse?
jedenfalls hat php schon ne funktion array_merge() eingebaut, die eigentl. für deine Zwecke reichen sollte.

Die Dinger unter PHP heissen übrigens assoziative Arrays. (man kann auch Dictionary sagen)

[Marscel]

MadMan2k[/POST]']schreibst du sonst C, oder warum ist dein Code so scheisse?

Wenn du 'scheisse' noch begründen würdest, nutzt mir das ein wenig mehr. ;)

jedenfalls hat php schon ne funktion array_merge() eingebaut, die eigentl. für deine Zwecke reichen sollte.

Wie beschrieben, das tut nicht das, was es soll.

Die Dinger unter PHP heissen übrigens assoziative Arrays. (man kann auch Dictionary sagen)

Ich meinte eher, dass ich dadrin alles mögliche an Datentypen speichern kann, sowie numerische und assoziative Schlüssel parallel verwendbar sind.

EDIT: Nun ists ein wenig modifiziert...

[Gast]

Marscel[/POST]']Wenn du 'scheisse' noch begründen würdest, nutzt mir das ein wenig mehr. ;)
entweder das war deine Änderung, oder ich hab beim Zweiten lesen besser hingeguckt - aber hab ich nix auszusetzen.... :(

[Marscel]

Keine Ursache. Ich bin für jedes Durchschauen dankbar. :)