Loops in Templates

[rythms]

da es sich um arrays handelt, lässt sich das wohl auch gar nicht anders lösen.

bei mir sieht das template im moment so aus:

{foreach from="arrayname" as="foobar"}
    {$foobar.field1} <br> 
    {$foobar.field2} <br>
{/foreach}

<?php
// der array dazu:
$arr1 = Array('field1' => 'feld1 aus array1', 'field2' => 'feld2 aus array1');
$arr2 = Array('field1' => 'feld1 aus array2', 'field2' => 'feld2 aus array2');

$tpl->assign('arrayname', Array(&$arr2, &$arr1));


// in der parse funktion:
        $pattern = '%'.$tag_start.'foreach from\="(\w+)" as\="(\w+)"'.$tag_end.'(.*)'.$tag_start.'/foreach'.$tag_end.'%s';
        // replace {foreach} 's
        $string = preg_replace_callback($pattern, array(&$this, '_replace_foreach'), $string);


// in der _replace_foreach funktion:
    function _replace_foreach($a)
    {
        // start returned string.
        $string = "";
        
        $from  = $a[1];
        $as    = "__" . $a[2];
        $parse = $a[3];
        
        // replace the varnames in the foreach loop in the string to parse (avoid collision with assigned vars)
        $parse = str_replace('{$', '{$__', $parse);
        
        foreach($this->_vars[$from] AS $key => $val)
        {
            $this->assign($as, $this->_vars[$from][$key]);
            $string .= $this->_parse($parse);
        }
        return $string;
    }

?>

Das erlaubt leider noch keine Schachtelung.
Da muss ich bei dem preg_replace_callback pattern noch ein bisschen mit asserts rumspielen
Bisher habe ich allerdings auch nur eine Ebene.

[Tartax]

Original geschrieben von rythms
da es sich um arrays handelt, lässt sich das wohl auch gar nicht anders lösen.

Verstehe nicht was das mit Arrays zu tun hat?

[rythms]

Original geschrieben von Tartax
Verstehe nicht was das mit Arrays zu tun hat?

Na was hat eine foreach-Schleife wohl mit arrays zu tun .. ?

Wenn du in einem geschachtelten foreach Arrays in Arrays schachtelst, (dich also auf vorherige Ergebnisse von foreach beziehst) musst du die Schleifen wohl oder übel schachteln.

[Tartax]

Dass foreach unweigerlich mit Arrays zu tun hat weiß ich schon...

Hab nurnet gesehen warum es sich ausgerehchnet deshalb net anders lösen ließe....

Theoretisch wäre es so ganz schön... aber nur theoretisch:

TEMPLATE:
...
{foreach a as b}
__{foreach b as c}
____{foreach c as d}
______...
____{end c as d}
__{end b as c}
{end a as b}


Nun wird zuerst die innerste schleife geparsed un ausgeschreieben, dann die Mittlere, und dann die Äußere, hab aber noch keine möglichkeit gefunden das sinnvoll zu lösen

[TBT]

beliebig tief verschachtelt ist mit einem regulären Ausdruck doch auch verdammt schnell.
Ich arbeite selber oft 4-5 Stufen tief im Template.
Bei mir entscheidet aber nicht das Template was angezeigt wird,
sondern jeder loop wird nur expandiert, wenn auch Daten für den loop vorhanden
sind. Sind keine Daten da, entfällt auch das parsen der Unterloops.

zum Thema schnell:

http://tbt.dyndns.org/tpl_benchmark/

[TBT]

@tartax: der von dir gewünschte Templateaufbau und parsen von außen nach innen
ist ohne große Anstrengungen möglich.
Schau doch einfach mal nach regulären Ausdrücken, und rekursiven Aufrufen.

[Tartax]

OffTopic:

---

Mhh, rekursieve aufrufe waren nur in den eregs möglich, nicht in den PCRE, oder?

---

Wierum gehst du es denn an? bzw. was ist in deinen augen sinniger?

[rythms]

so was ähnliches suche ich hier eigentlich auch.

Aber da die inneren foreach schleifen einen array, der erst aus einer der sie umgebenden foreach schleifen herauskommt, benutzen könnten muss es von aussen nach innen geschehen.

beispiel:

foreach a as b
-- foreach b as f
-- /foreach
/foreach

wie ihr seht benutzen wir im inneren das ergebniss des äusseren foreachs.

[TBT]

innerhalb des regulären Ausdruckes einen rekursiven Aufruf der Funktion starten mit Schalter "#.....#/e" im preg_replace()

[Tartax]

Original geschrieben von rythms
Aber da die inneren foreach schleifen einen array, der erst aus einer der sie umgebenden foreach schleifen herauskommt, benutzen könnten muss es von aussen nach innen geschehen.

Das stimmt nicht... bsp:

foreach $a as $b
-- foreach $b as $f
---- ich bin ein $f
-- /foreach $b as $f
/foreach $a as $b


dann wird zuerst die innere schleife ausgeschrieben.. also jedes $f durch ein $b[...] ersetzt:


foreach $a as $b
---- ich bin ein $b[0]
---- ich bin ein $b[1]
...
/foreach $a as $b

dann wird die äußre schleife geparsed, also jedes $b durch $a[...] ersetzt also:

---- ich bin ein $a[0][0]
---- ich bin ein $a[0][1]
...
---- ich bin ein $a[1][0]
---- ich bin ein $a[1][1]
...
---- ich bin ein $a[2][0]
---- ich bin ein $a[2][1]
...
...
____________________________________________



Wenn ihr in dieser ausfühung massive probleme seht, laß ich mich gerne eines besseren belehren...

[Tartax]

@TBT

Mhh, /e- führt doch das Ergebnis als PH code aus, wie eval... oder hab ich das missverstanden??

Hab grade nachgedacht...ist es nicht am sinnigesten das ganz mir preg_replace_callback zu machen, und als Callbackfunktion die loopparsefkt selber anzugeben?

[rythms]

Original geschrieben von Tartax

Hab grade nachgedacht...ist es nicht am sinnigesten das ganz mir preg_replace_callback zu machen, und als Callbackfunktion die loopparsefkt selber anzugeben?

so ist es.

Dein ansatz die Loops zu parsen ist ganz interessant, allerdings bei mir so nicht möglich (es können z.b. auch methodenaufrufe im code stehen).
Das ganze dann nochmal mit einer regexp umzuändern wird mir zu aufwendig, da es eigentlich unnötig ist.

[Tartax]

Wenn der modifier das ganze das ganze so behandelt als würde man

eval(preg_replace(....));
schreiben... vestehe ich nicht was das dabei hilft verschachtelte schleifen zu parsen

[TBT]

der Modifier /e ruft nicht das Suchergebnis per eval auf,
sondern eine Funktion, und übergibt das Suchergebniss als Parameter

[Tartax]

Ähhh. ich bin verwirrt, kannst du mal nen beispiel machen?

Vielleicht auch eines zu der sache mit den rekursiven pattern alias (?R) hab ich auch noch net verstanden...