Pattern Iterator

[bokel]

Hier ist mal ein einfaches, aber praktisches Beispiel für die
Vorzüge der OOP. Eine Iterator-Klasse, beispielhaft
für Arrays implementiert.

Theoretisch funktioniert das so, dass jede Klasse mit einer
Liste, die man irgendwie durchlaufen kann, eine Methode
createIterator zur Verfügung stellt. Diese Methode liefert
dann ein Iterator-Object mit der gleichen Schnittstelle wie
unten.
So kann man unabhängig davon, wie die Liste intern
aufgebaut ist, jede Klasse auf die gleiche Weise durchlaufen.

//---------------------------------------------------------
//**
// Ein normaler Vorwärts-Iterator für Arrays
//*
 
_global.IteratorArray = function(obj){
    this.obj = obj;
    this.actIdx = 0;
};
 
o = IteratorArray.prototype;
 
o.first = function(){
    this.actIdx = 0;
}
 
o.next = function(){
    ++this.actIdx;
}
 
o.isDone = function(){
    return this.actIdx >= this.obj.length;
}
 
o.hasNext = function(){
    return this.actIdx < this.obj.length;
}
 
o.current = function(){
    if(this.isDone()){
        trace("Iterator out of Bounds: " + this.actIdx + ":" + this.obj.length);    
    }
    return this.obj[this.actIdx];
}
 
 
//---------------------------------------------------------
//**
// Ein Rückwärts-Iterator für Arrays
//*
 
_global.IteratorReverseArray = function(obj){
    this.obj = obj;
    this.actIdx = obj.length-1;
};
 
o = IteratorReverseArray.prototype;
 
o.first = function(){
    this.actIdx = this.obj.length-1;
}
 
o.next = function(){
    --this.actIdx;
}
 
o.isDone = function(){
    return this.actIdx < 0;
}
 
o.hasNext = function(){
    return this.actIdx >= 0;
}
 
o.current = function(){
    if(this.isDone()){
        trace("Iterator out of Bounds: " + this.actIdx + ":" + this.obj.length);    
    }
    return this.obj[this.actIdx];
}
 
//---------------------------------------------------------
//Die Klasse Array bekommt ihre "createIterator"-Methoden zugewiesen
Array.prototype.createIterator = function(){
      return new IteratorArray(this);
}
 
Array.prototype.createIteratorReverse = function(){
      return new IteratorReverseArray(this);
}
//Das braucht ja keiner zu wissen :)
ASSetPropFlags(Array.prototype, null, 1);
 
 
 
 
//---------------------------------------------------------
//---------------------------------------------------------
// Ein Beispiel für normale Arrays: 
 
a = [1,2,3,4,5];
trace("----");
it = a.createIterator();
for(it.first(); it.hasNext(); it.next()){
    trace(it.current());
}
trace("----");
it = a.createIteratorReverse();
for(it.first(); it.hasNext(); it.next()){
    trace(it.current());
}
trace("----"); 

Der Vorteil ist, dass man alle Schleifen dieser Art auf die
gleiche Weise programmieren kann und sich keine Sorgen
darüber machen muss, dass man die Grenzen der Liste
überschreitet. Dafür sorgt ja jetzt der Iterator.

Nur für Arrays alleine bringt das auch noch nicht so viel,
aber wenn man sich jetzt vorstellt, dass eine verlinkte
Liste oder ein Baum oder eine Liste, die nur jedes
zweite ihrer Elemente liefert, auf die gleiche Weise
durchlaufen werden kann, weil sie schliesslich ihren
Iterator selbst zur Verfügung stellen, dann geht einem
plötzlich ein Licht auf.

Es kostet natürlich etwas Performance, also in hochoptimierten
inneren Schleifen ist das vielleicht nicht so angesagt. Aber
oft genug kommt es ja nicht aufs letzte Byte an und optimieren
soll man schliesslich erst zum Schluss.

mfg r.

[kelor]

gefällt mir außerordentlich gut, ralf...

gleich mal testen...*g*

greetz

kelor

[Madokan]

ralf auch wenn es performance frist - ist es eine schöne Umsetzung und ich bin sicher die Jungs und Mädels nehmen es dankbar an.

Ich bin sicher der Flash Player wird in zukünftigen version mehr und mehr OOP Kompatibel, ich denk da an C++ u. Java Klassen strukturen, private u. public, etc. mein wunschzettel ist gross - eine Flamme die in mir wohl auch nicht so schnell erlicht!

Wir sollten jedoch froh um jede Erweiterung sein - die fehlerfrei funtzt. War das jetzt eine Anspielung...*hust*

Liebe Grüsse
Matze

[hOk]

Hi,
ich würde den Iterator noch um zwei Methoden
erweitern:

o.getNextItem = function () {
    var r = this.obj[++this.actIdx];
    if (r == undefined) this.actIdx = 0;
    return r;
}
 
o.getPreviewItem = function () {
    var r = this.obj[--this.actIdx];
    if (r == undefined) this.actIdx = 0; // <-- should maybe this.obj.length - 1 ?
    return r;
} 

...dann kann man mit folgender while
Schleife arbeiten:

var e;
while (e = it.getNextItem()) {
    // do something with e
} 

...so kann man sich dann die Reverse-Variante
sparen. Fragwürdig finde ich noch die Reaktion
bei Überschreiten der Grenze, was denkt ihr,
sollte man in beiden Fällen den Pointer auf null
zurücksetzen?

nette Grüße, Holger

[bokel]

Ja,
das ist möglich.
Aber was passiert, wenn deine Liste
Stellen enthält, die undefined sind ?

Und das mit dem Rückwärtsdurchlaufen ist auch ein
Beispiel dafür, dass das Durchlaufen selbst genau
gleich aussieht und nur durch den Iterator bestimmt
wird.

Das ist ja das eigentlich Ziel der ganzen Anstrengung.
Sozusagen Iterieren ohne Rücksicht auf Verluste.

Genaugenommen ist das zweite Beispiel falsch,
ich ändere das mal. (nee, doch nicht ) Es kann ja
durchaus sein, dass man auch mal rückwärts
iterieren will.
Man könnte sich aber auch eine Klasse vorstellen,
die vom Array abstammt und deren normaler Iterator
eben der Rückwärtsiterator ist. Dann würde man es
von aussen gar nicht mitkriegen, dass es ein Rückwärts-
iterator ist.

mfg r.

[hOk]

Geschrieben von bokel
Ja,
das ist möglich.
Aber was passiert, wenn deine Liste
Stellen enthält, die undefined sind ?

Huch, stimmt hast natürlich recht, bokel,
das wäre dann nicht so schön...;-)

grüße, Holger

[secp]

lol

Sozusagen Iterieren ohne Rücksicht auf Verluste.

Schaut aber gut aus, Auf den ersten blick ein bischen "high-tech" aber doch recht brauchbar. Ich glaube aber das ich mir sowas gar nicht mehr angewöhnen kann. Wenn mal was richtig komplexes kommt kann ich das ja vielleicht brauchen

[rOb]

flash goes java!





*froi*

[achimbode]

warum hat das Iterator-Interface eigentlich keine current()-Methode?
hasNext() und next() sind ja schön und gut - aber wenn ich das aktuelle Element nicht abfragen kann, brauche ich die auch nicht.

Gibt es vielleicht ein View-Interface, das current() enthält und das ich zusätzlich implementieren kann, um sicher zu stellen, dass ich eine current()-Methode - oder einige von den anderen Iterator-Methoden von oben - bekomme?

[bokel]

Interfaces sollen immer möglichst klein sein, und für einen Iterator reichen next und hasNext eigentlich.

//Ausgabe A,B,C,...,Z
var it:Iterator = new ABCIterator("A", "Z");
while( it.hasNext()){
       trace(it.next());
} 

next übernimmt dabei eine Doppelfunktion, es liefert das aktuelle Element und stellt den internen Zeiger eins vor.

mfg. r

[achimbode]

hi bokel,

das dachte ich auch immer, aber Macromedia verwendet das anders:

DataSet.next()

...

Rückgaben
Keine.

[bokel]

Huh,
und wie kommen die dann an die Werte?
Achso, das ist kein richtiger Iterator, sondern was eingebautes, oder?
mfg r.

[achimbode]

oh, tschuldigung.
habe gerade festgestellt, dass es in der Definition von mx.utils.Iterator so drinsteht, wie du es beschrieben hast...

besten dank!

[achimbode]

Hi Folks,

vielleicht braucht jemand einen Iterator für XML.
Da ich hier schon soviele gute Sachen gefunden habe, hier meine Version.
Bin natürlich für Verbesserungsvorschläge immer offen...

PHP-Code:

import de.achimbo.xml.iterators.*;

class de.achimbo.xml.iterators.DeepIterator implements mx.utils.Iterator{
    
    private var structure:XMLNode;    // XML-Struktur, die übergeben wurde
    private var curnode:XMLNode;    // die Node selbst oder das jeweils aktuelle Child (-> getChild())
    private var iterator:DeepIterator = null; // iterator des aktuellen Child
    private var internDepth:Number;        // Tiefe in der XML-Struktur (0 = dem ersten Konstruktor übergebenes Level)
    private var selfdone:Boolean = false; // ist die Node selbst schon zurückgegeben worden (wenn ja, Children zurückgeben!)
    
    private static var selfNext:Number = 0;        // Konstanten für die
    private static var iteratorNext:Number = 1;    // Ansage der "Strategie"
    private static var childNext:Number = 2;    // von hasNext() an next()
    
    function DeepIterator(structure:XMLNode, depth:Number) {
        if(structure == null || structure == undefined) throw new de.achimbo.error.AboError(("Parameter structure = " + structure), this, "Constructor");
        if(depth == null || depth == undefined) {
            this.internDepth = 0;
        } else {
            this.internDepth = depth;
        }
        this.structure = structure;
        this.curnode = structure;
    }
    
    public function next():Object {
        var tmp = getNext();
        return tmp;
    }
    
    public function hasNext():Boolean {
        return (findNext(false)!= null);
    }
    
    private function getNext():XMLNode {
        switch(findNext()){
            case 0: // die (Haupt-)Node wurde noch nicht bearbeitet
                     // die (Haupt-)Node auf bearbeitet setzen
                selfdone = true;
                // HauptNode zurückgeben
                return structure;
            case 1: // der Iterator der aktuellen Node (bzw. *dessen* Iterator) hat noch mehr Nodes
                // nächste Iterator-Node zurückgeben
                return XMLNode(iterator.next());
            case 2: // ein Iterator existiert entweder nicht 
                // oder der Iterator der aktuellen Node hat keine weiteren Nodes,
                // aber es existieren (weitere) Children der Structure-Node
                // nächste ChildNode zur aktuellen machen, ...
                curnode = getChild();
                // ... von dieser einen Iterator erstellen
                iterator = new DeepIterator(curnode, depth+1);
                // wenn dieser Iterator weitere Nodes hat...
                if(iterator.hasNext()) {
                    // ... die nächste ( = erste) Node von diesem Iterator ( = die ChildNode selbst) zurückgeben
                    return XMLNode(iterator.next());
                } else {
                    // sonst: weiter.
                    return getNext();
                }
            default: // ein Iterator existiert nicht und eine weitere ChildNode auch nicht mehr
                return null;
        }
    }

    private function findNext():Number {
        // wenn die Haupt-(Structure-)Node noch nicht zurückgegeben ...
        if(!selfdone) {
            //Haupt-(Structure-)Node zurückgeben
            return DeepIterator.selfNext;
        } // sonst:
        // wenn ein bestehender Iterator weitere Nodes hat ...
        if(iterator.hasNext()) { // wenn kein Iterator besteht, ist iterator.hasNext()=undefined -> false
            // ... mit Nodes von bestehendem Iterator fortfahren
            return DeepIterator.iteratorNext;
        } else { // sonst:
            // hat der bestehende Iterator KEINE weitere Nodes:
            delete iterator; // Iterator löschen (Speicher freigeben)...     
            //(wenn kein Iterator vorhanden, wird eben undefined gelöscht...)
            iterator = null; // ... und auf Null setzen 
        }
        // die Haupt-(Structure-)Node ist bearbeitet und es besteht kein Iterator:
        // wenn weiteres Child vorhanden ...
        if(getChild() != null) {
            // ... mit nächstem Child weitermachen
            return DeepIterator.childNext;
        }
        return null;
    }
    
    private function getChild():XMLNode {
        // wenn oberste Node keine Children hat, NULL zurück (-> hasNext = false)
        if(!structure.hasChildNodes()) return null;
        if(curnode === structure) {
            return curnode.firstChild;
        }
        return curnode.nextSibling; // nextSibling gibt NULL zurück, falls kein weiterer Sibling existiert
    }

//////////////////// DEBUG-Area (kann weggelassen werden) ///////////////////////
    
    public function get depth():Number {
        /* DEBUG + toString() only ........................ */
        if(iterator != null) return iterator.depth;
        return internDepth;
    }
    
    private function traceNode(node:XMLNode):String {
        /* DEBUG + toString() only ........................ */
        return "<" + node.nodeName + ">" + node.nodeValue + "</" + node.nodeName + ">"; 
    }
    
    public function toString():String {
        var einzug:String = "";
        for(var i=0; i<depth; i++) {
            einzug += "   ";
        }
        return einzug + "DeepIterator" + traceNode(structure);
    }
}