[PHP] Arrays verplaatsen binnen een class tussen arrays

[killercow]

Ik heb een class:

In deze class bestaan 2 multi-dimensionale arrays;

PHP:

class parser{
 var $DOM;
 var $tmpDOM;
 function &getPointer($i){
  return $this->DOM[$i];
 }
 function &createObject($tag){
  $obj=&$this->tmpDOM[]=array('name'=>$tag,'children'=>null,'count'=>count($this->tmpDOM)-1 );
  return $obj;
 }
 function appendChild(&parent,&obj){
  $parent['children'][]=$obj;
  unset($this->tmpDOM[$obj['count']])
 }
}

Wat is nou de mooiste / gezondste manier om de child van $tmpDOM inclusief onderliggende arrays over te hevelen naar DOM, zonder dat er allerlei copien van de DOM ontstaan.

Tevens gaat dit maar een keer goed,

Ik trek een pointer naar een plekje in de DOM array naar buiten met een getElementByID functie.
Daarna voeg ik 2 tags toe met createElement welke ook netjes in de tmpDOM komen te staan.
De eeste kan ik daarna redelijk netjes van tmpDOM naar de DOM verplaatsen, en hij komt ook netjes onder de juiste plek in die array te hangen.

De tweede blijft echter gewoon in tmpDOM staan, en verplaatst niet, maar wordt ook niet verwijderd.

[SchizoDuckie]

De mooiste manier? Netjes PHP5 gebruiken. Dan ben je in 1x van dat nep OO af.

Waarom beginnen je functies trouwens met een &

[killercow]

SchizoDuckie schreef op vrijdag 09 maart 2007 @ 00:30:
De mooiste manier? Netjes PHP5 gebruiken. Dan ben je in 1x van dat nep OO af.

Waarom beginnen je functies trouwens met een &

Meh, das vervelend.

De functies beginnen met een & zodat ik zonder extra &'s voor de return altijd een reference terug krijg.

[evolnick]

offtopic:

die & voor een functie heeft alleen zin, als je bij het aanroepen van die functie ook een & gebruikt:

PHP:

<?php

class a {
    var $ok;
    function a() { $this->ok = 'jaja'; }
    function change() { $this->ok = 'oke dan'; }    
    function return_no_ref() { return $this->ok; }
    function &return_with_ref() { return $this->ok; }
}

$a = new a();

$test1 = $a->return_no_ref();
$test2 = &$a->return_no_ref();
$test3 = $a->return_with_ref();
$test4 = &$a->return_with_ref();

print '
Voor Change
Test 1: '.$test1.'<br>
Test 2: '.$test2.'<br>
Test 3: '.$test3.'<br>
Test 4: '.$test4.'<p>
';

$a->change();

print '
Na Change
Test 1: '.$test1.'<br>
Test 2: '.$test2.'<br>
Test 3: '.$test3.'<br>
Test 4: '.$test4.'<p>
';

?>

Output:
Voor Change
Test 1: jaja
Test 2: jaja
Test 3: jaja
Test 4: jaja

Na Change
Test 1: jaja
Test 2: jaja
Test 3: jaja
Test 4: oke dan

Bij PHP versie 5.2.0-8 in ieder geval

[evolnick]

Sorry dat ik het zeg, maar vind het nogal een vaag scriptje

Hopelijk begrijp ik het goed, maar je zou het volgende kunnen doen:
- bij createObject geen reference terug geven, maar de echte array.
- wanneer je klaar bent met het vullen van het bovenstaande, zet hem dan in je DOM array, bij de goede parent dan.
- een check bij getPointer, of $i wel bestaat

of een andere manier:
- eerst de parent object reference uit de dom halen
- en direct daarin een child maken.

[killercow]

evolnick schreef op vrijdag 09 maart 2007 @ 09:32:
Sorry dat ik het zeg, maar vind het nogal een vaag scriptje

Hopelijk begrijp ik het goed, maar je zou het volgende kunnen doen:
- bij createObject geen reference terug geven, maar de echte array.
- wanneer je klaar bent met het vullen van het bovenstaande, zet hem dan in je DOM array, bij de goede parent dan.
- een check bij getPointer, of $i wel bestaat

of een andere manier:
- eerst de parent object reference uit de dom halen
- en direct daarin een child maken.

UIteraard check of i bestaat.
Ik juist (net als de normale javascript implementatie van DOM) de nieuwe elementen eerst in een soort temp container zetten, en ze beschikbaar houden dmv een pointer,
Deze pointer gebruik ik daarna om ze uit de temp te vissen en ze binnen de echte DOM onder de juiste parent te gooien.

Ik ben dus bezig met een DOM implementatie in php, paden en argumenten werkt allemaal, maar DOM manipulaties lopen dus in de soep vanwege de references naar copyen van de DOM ipv de echte DOM.

Een van de problemen waar ik tegen aan loop is het volgende, ik gebruik gewoon een grote multi-dimensionale array met alle tags en hun argumenten/children. Waar een mooie implementatie waarschijnlijk per tag een eigen instance van een "object" class zou gebruiken, zodat de verschillende functies methods van de objects zelf zijn ipv methods van de DOM.
Maar een array bouwen en doorzoeken is ZO veel sneller als honderden nested objects.