Rekursionen beim Parsen vermeiden ?

[frankiee]

Hallo!

Ich habe vor ,aus einem XML Object ein Flash Objekt zu generieren. Im Gegensatz zu den mir bekannten Lösungen möchte ich aber zusätzlich die Verknüpfungen zwischen den Knoten, also firstChild, nextSibling usw beibehalten.

Mein Lösungsansatz war nun, statt der üblichen for..in Schleife das XML mit nextSibling zu durchlaufen:

PHP-Code:


public function parse($node:XMLNode, $callObj:Object):Object {
        
    var object = new Object();
    
    var firstNode = $node.firstChild;        
    if (firstNode != null) {
        object[firstNode.nodeName] = parse(firstNode, object);
    }

    var nextNode = $node.nextSibling;        
    if (nextNode != null) {
        $callObj[nextNode.nodeName] = parse(nextNode, $callObj);
    }
        
    return object;
} 


Eigentlich ganz nett, es funktioniert und die Mitführung des aufrufenden Objekts erlaubt es mir (in der erweiterten Codeversion) unter anderem tatsächlich die gewünschten Verknüpfungen zu erzeugen, nur ...

... dadurch dass ich das XML auch quasi in der Breite rekursiv durchlaufe komme ich im Gegensatz zur Schachtelungstiefe sehr leicht über die erlaubten 256 Stufen - eine etwas längere Liste mit Knoten reicht da schon.

Wie vermeide ich das am besten, und laufe trotzdem in etwa wie gezeigt durch das Objekt, bzw gibt es einen anderen Weg, diese Verknüpfungen beim Parsen mit im resultierenden Flashobjekt abzubilden?


Frank Kudermann
--------------------------------------------------
http://www.alphanull.de

[atothek]

schau dir mal meine XML Iteratoren an

XML Iterator

der durchlooft nen XML tree linear mit einer while schleife, und das ganze ohne rekursion, ich bin leider immer noch nicht zu einem kompletten beispiel gekommen

mfg
alex

[hgseib]

"..sehr leicht über die erlaubten 256 Stufen.."
kein wunder, du verschachtelst ja jedesmal.
ein rekursiver aufruf hat nur dann zu erfolgen, wenn es eine stufe (einen ordner) tiefer geht.
da musst du schon einen bär von einem xml haben, um die 256 zu knacken.

function fXMLParsen(_xml, _tiefe) {
	do {
		if (_xml.hasChildNodes()) {
			fXMLParsen(_xml.firstChild, _tiefe+1);
		} else {
			trace(_tiefe+":"+_xml);
		}
	} while (_xml=_xml.nextSibling);
}
_xml = new XML("<a>aaa</a><a>aaa<b>bbb</b><b>bbb<c>ccc</c></b></a><a>aaa</a>");
fXMLParsen(_xml.firstChild, 0);

[subHero]

Zitat von frankiee

Mein Lösungsansatz war nun, statt der üblichen for..in Schleife das XML mit nextSibling zu durchlaufen:

nimm doch statt "statt" beides minus "in" und du hast die mutter aller xml-rekursiv-schleifen

for (var sibNode:XMLNode=node; sibNode != null; sibNode=sibNode.nextSibling)
{
	// ...
}

clownesque grüße
-sh

[frankiee]

wow, danke, das waren ja gleich mal drei brauchbare Ansätze! Hab mich für die do...while Schleife entschieden, da sie meiner Denke doch am nächsten kam und sich auch die Verkettungsgeschichten recht einfach lösen liessen.

Hat wer Interesse am finalen Code? Dann poste ich es gerne hier!

Überlege auch gerade, ob ich nicht doch eine Unterklasse der "Object" Klasse definieren soll, da es ja auch darum gehen soll nicht nur zu iterieren, sondern auch neue Knoten einzufügen, etc. wo dann doch etwas mehr "Arbeit" geleistet werden muss. Mach mir auch Sorgen um die Speicherverwaltung, da es ja jetzt auch nicht mehr genügt, Objekte zu löschen, weil die Referenzen in anderen Objekten ja immer noch vorhanden wären. Hat wer Erfahrung mit sowas?

[Janoscharlipp]

klaro sind wir am Ergebnis interessiert!