Hoe zet je dit in een for-loop

[Traxx]

var digital1:MovieClip = new MovieClip();
var digital2:MovieClip = new MovieClip();
var digital3:MovieClip = new MovieClip();
var digital4:MovieClip = new MovieClip();
var digital5:MovieClip = new MovieClip();
var digital6:MovieClip = new MovieClip();
var digital7:MovieClip = new MovieClip();
var digital8:MovieClip = new MovieClip();
var digital9:MovieClip = new MovieClip();
digital1.graphics.lineStyle(3, 0x00FFFF);
digital2.graphics.lineStyle(3, 0x00FFFF);
digital3.graphics.lineStyle(3, 0x00FFFF);
digital4.graphics.lineStyle(3, 0x00FFFF);
digital5.graphics.lineStyle(3, 0x00FFFF);
digital6.graphics.lineStyle(3, 0x00FFFF);
digital7.graphics.lineStyle(3, 0x00FFFF);
digital8.graphics.lineStyle(3, 0x00FFFF);
digital9.graphics.lineStyle(3, 0x00FFFF);

Alleen dan in een for-loop...?

[TheDutch]

Zoiets wanneer je de MovieClips buiten de functie wilt kunnen benaderen...:

var mc:MovieClip;

for(var i:int=1;i<=9;i++)
{
mc = this["digital"+i] = new MovieClip();
mc.graphics.lineStyle(3, 0x00FFFF);
}

Let erop dat je class op deze manier dynamic moet zijn of (afstammen van) MovieClip.


...of zoiets wanneer je de MovieClips niet buiten de functie hoeft te kunnen benaderen:

var mc:MovieClip;
var mcTemp:Object = new Object();

for(var i:int=1;i<=9;i++)
{
mc = mcTemp["digital"+i] = new MovieClip();
mc.graphics.lineStyle(3, 0x00FFFF);
}


// EDIT: Taalfout weggehaald.

[toadstool]

bedoel je het niet andersom? In het eerste geval is alleen de laatste movieclip nog te benaderen via mc, en in het tweede geval allemaal via het mcTemp object..?

[TheDutch]

In het eerste geval zijn alle MC's nog buiten de functie te benaderen via de "this" scope (dynamische class). In het tweede geval zijn ze dit niet meer. De variable "mcTemp" die binnen de functie staat is er alleen maar om ervoor te zorgen dat de MC's binnen(!) de functie nog te bereiken zijn maar buiten(!) de for loop :).

[theFlashWizard]

Ik prefereer eigenlijk altijd array's boven this["digital"+i], want dat lijkt me een stuk minder typfout gevoelig.
Wat nu ook erg makkelijk is is dat je een bepaalde groep in 1 container (Sprite/MovieClip) kan verzamelen en ze dan gewoon via getChildAt() kan bereiken.

[TheDutch]

Wellicht een idee om jouw voorkeur wat meer toelichting te geven? Op deze manier weten we jouw voorkeur maar niet waarom en hoe je dit zou doen dan :).

Voor hoe ik het nu van je lees koppel je depth en indices aan elkaar, wat mij zeer onverstandig lijkt. Vandaar graag meer uitleg, das ook meer zinvol dan alleen wat er nu staat ;).

[theFlashWizard]

Owke, kan ik proberen :)

Ik maak eerder een typfout met: items["item"+i] dan met items[i]. Ook krijg je meestal geen heldere foutmeldingen als je die "item" verkeerd spelt.
Daarnaast kun je bij een array makkelijker het aantal items opvragen.

Wat bedoel je met indices ? Id's? Nee zo gebruik ik ze niet. Ik gebruik het enkel om een groep displayobjecten in apart aan te kunnen spreken. Bijv. met een for loop met numChildren. Ook is het dan erg makkelijk om de hele groep te verwijderen:
while(itemsContainer.numChildren > 0){
itemsContainer.removeChildAt(0);
}

Nothing more to it eigenlijk.

[TheDutch]

Wanneer de AVM tijdens runtime object["item"+i] niet kan vinden krijg je keurig een duidelijke RTE dat hij "item5" niet kan vinden. Dat is in mijn ogen duidelijker dan dat de index out of bound is.

Indices is het meervoud van index. Zoals ik je begrijp zijn op jouw manier de indices van de array gelijk aan de depth positie van het element in het display object. Zou je deze vraag kunnen beantwoorden en toe kunnen lichten?

Wanneer je referenties van UI elementen in een array of object (mijn voorkeur in dat geval) zet, dan kan je ze inderdaad eenvoudiger beheren wanneer ze als groep ook verwijderd of verplaatst moeten worden. In grote lijnen dat is dat wat jij denk ik bedoeld. Echter zal dit niet overal nodig zijn, wellicht zelfs in de meeste gevallen niet. In games is het een handige toevoeging maar in applicaties waar UI elementen staan en niet meer zelfstandig weggehaald / verplaatst hoeven te worden geldt dat niet.

Zoals wel vaker in onze discussies komt het er voor mij veelal op neer dat je de tools moet gebruiken die je nodig hebt en niet meer. Bedenk goed van te voren wat de doelen zijn en zoek daar de juist benadering voor. Dat is één van de belangrijkste aspecten van het programmeren :).

[theFlashWizard]

Indices is het meervoud van index. Zoals ik je begrijp zijn op jouw manier de indices van de array gelijk aan de depth positie van het element in het display object. Zou je deze vraag kunnen beantwoorden en toe kunnen lichten?
Dit klopt, kan ik weinig over uitleggen. Maar deze index zou ik dan btw niet gebruiken als id's. Id's zet ik altijd als id properties in de objecten zelf.

Owke, maar ik kan het ook omdraaien. Waarom zou je items["item"+i] gebruiken als je ook items[i] kan gebruiken. Het lijkt me voor degene die het naleest een stuk eenvoudiger te interpreteren dat een array 1 groep met objecten van (bijna) hetzelfde type. Wat, volgens mij, meestal zo is.
De items["item"+i] syntax moet je ook nog eens onthouden bij het schrijven en het uitlezen, waardoor je altijd terug moet kijken in je code. Bij array's kan deze verwarring nooit ontstaan.

In games is het een handige toevoeging maar in applicaties waar UI elementen staan en niet meer zelfstandig weggehaald / verplaatst hoeven te worden geldt dat niet.
Kun jij deze dan toelichten want deze snap ik niet. In dit geval sla je deze onderdelen bijna altijd toch gewoon op in een instance variabele?

Probeer ook zeker altijd de goede manier te vinden, kom het alleen bijna nooit meer tegen dat een native object handiger is dan een array.
Het properties object voor TweenLite / Tweener zijn hier een uitzondering op.

[TheDutch]

Mijn veronderstelling was dat jij de index van een item binnen een array wilde gebruiken om het bijvoorbeeld van het DisplayObjectContainer te verwijderen. Op die manier koppel je de array indices direct aan de depths binnen de DisplayObjectContainer, wat zeer foutgevoelig kan zijn. Echter kan ik dat niet geloven - ook al erken je het hierboven met "dit klopt" - omdat ik je tot meer in staat stel dan dat ;).

Een array is prima wanneer je de items maar weer verwijderd met removeChild(array[5]) en niet removeChildAt(arrayIndex). Datzelfde geldt natuurlijk ook voor het swappen van children.

Eigenlijk is er voor zowel array als object wat te zeggen:
==========================================
Een array is inderdaad minder tikfout gevoelig omdat je niet met namen werkt - al zal je dat probleem dan ook hebben bij reguliere variables - en het kan in een specifieke volgorde loopen. Echter is het bij een array lastiger te bepalen naar welk element een index verwijst en geeft een array bij het niet vinden van een index een minder duidelijke RTE.

Een object is handig omdat je daarmee duidelijker een verwijzing kunt leggen naar een bepaald element binnen het object, wanneer je bijvoorbeeld een event listener wilt hangen aan een element. Dan is array[5].addEventListener() een stuk onduidelijker dan object.naam5.addEventListener(). Daarnaast is het bij een object altijd te bepalen naar welk element je verwijst en geeft een object bij het niet vinden van een element een duidelijke RTE.


Kun jij deze dan toelichten want deze snap ik niet. In dit geval sla je deze onderdelen bijna altijd toch gewoon op in een instance variabele?

Een array of object is alleen handig wanneer je op een later moment nog toegang wilt hebben tot een specifieke groep elementen. Wanneer dit niet zo is kan je ze net zo goed direct op this[] zetten wanneer het een dynamic class betreft (zoals ik in mijn eerste post ook aagaf). Echter werk ik alleen wanneer nodig met dynamic classes en zou ik normaal dus een object gebruiken. Ik gaf de topic starter enkel twee opties hoe het op te lossen valt, met een dynamic class en this[] of met een object :).

[theFlashWizard]

Ow oeps, nee dat bedoel ik niet. Het zou erg lastig zijn dat bijde gelijk te laten lopen.
Ik zou of een array vullen met referenties naar displayObjecten of ik zou geen array gebruiken en direct op index in een displayObjectContainer verwijderen.

al zal je dat probleem dan ook hebben bij reguliere variablen
Ben ik het niet helemaal mee eens, bij editors als flex builder en fdt krijg je tijdens het ontwikkelen al meteen meldingen van dit soort typfouten.

Maar vaak is het niet van belang welk item je uit een groep (uit array/object) aanspreek omdat je vaak (in een for loop bijv.) hetzelfde met elk item doet toch?
Want als je per item in een object iets anders doet vind ik al snel dat je "gevaarlijk" bezig bent.
Script wordt daar al snel onduidelijk en onvoorspelbaar van volgens mij.
Kort gezegt, ik zie iets in een array/object als een groep, waarbij je ze hetzelfde behandelt. Ik kan me dan eigenlijk niet zo snel situaties voorstellen waarbij het van belang is om welk item het specifiek gaat. Daarom mijn voorkeur voor array's.

[TheDutch]

Wanneer jij zo snel tikfouten maakt, dan moet je toch eens wat gaan doen aan die dikke vingers van je ;).

Het zal misschien voor jou veelal niet van belang zijn welk element je aanspreekt omdat jij dat vaak in een loop doet waar ze allemaal hetzelfde behandeld moeten worden. Echter wil dit niet direct zeggen dat dit voor iedereen altijd ook zo is. De vraag is eigenlijk wat de reden is voor het gebruik van een array of object met dynamische elementen.

Ik kan me heel goed situaties voorstellen waarbij je niet met dynamic classes wilt werken maar toch dynamische elementen op de stage wilt zetten en ze benaderbaar wilt houden. Dan is het gebruik van een array erg onduidelijk gezien je niet met namen werkt maar met indices (zie mijn vorige reactie). Een object zou dan ideaal zijn om daar referenties in op te slaan onder een bepaalde naam. Zo zullen er vast nog meer situaties zijn waarbij een object of array gebruikt wordt voor een heel ander doeleinde dan waar jij dit tot nu toe voor gebruikt hebt. Sluit dus niet te snel dingen uit hè. Er zijn namelijk enorm veel situaties waar wij beiden helemaal geen ervaring mee hebben gehad, die zullen altijd blijven bestaan :).

Misschien kan je als afsluiter nog even een voorbeeld neerzetten van hoe jij zijn probleem zou oplossen met een array. Dan kan hij zelf uit de drie methoden kiezen en bepalen welke voor hem het meest geschikt is.

[theFlashWizard]

Haha of misschien een typcursus ;)

Dat is zo, zou ook niet durfen te beweren dat ik aan alle situaties denk.

Bedacht me net wel nog een goede toepassing van een object. Als je objecten een id (Number/String) hebben die los staat van bijv. de volgorde waarin ze neergezet worden, omdat het bijv. uit xml komt, dan kan een object erg handig zijn.
Dan kun je ze namelijk uit het object halen met hun id.
Zoiets vind je bijv terug in PureMVC waarbij een notification naam als id werkt.
Deze naam sla je dan alleen op als static constant in een Notifications class om typfouten te voorkomen.

Ik zou het ongeveer zo doen:
var mc:MovieClip;
var digitals:Array = new Array;

for(var i:int=1;i<=9;i++)
{
mc = new MovieClip();
mc.graphics.lineStyle(3, 0x00FFFF);
digitals.push(mc);
}