[FMX] Ciclo for..in

[euripide]

E' possibile ciclare in modo inverso in un for..in??

grazie

--
F

[Chicco Flash]

Post by euripide
E' possibile ciclare in modo inverso in un for..in??

cioè?

vuoi fare un ciclo in-for?

se per inverso intendi partire dalla fine puoi sempre usare:

for (c=myarray.length;c=0;c--)

e cicla iniziando dalla fine
considera che puoi sempre mettere una condizione ed il "break" per uscire
dal ciclo

ciau

[stefano]

Post by Chicco Flash

Post by euripide
E' possibile ciclare in modo inverso in un for..in??

cioè?
vuoi fare un ciclo in-for?
for (c=myarray.length;c=0;c--)

Oppure può fare una copia dell'array e usare il metodo reverse.
Però senza conoscere il contesto e la natura dell'oggetto da ciclare
potrebbe non essere la soluzione adatta.



Stefano

[Christian Giordano]

In realta' il for-in restituisce gia' di per se con il metodo LIFO (Last In First Out) se non ricordo male.

[euripide]

Post by stefano

Post by Chicco Flash

Post by euripide
E' possibile ciclare in modo inverso in un for..in??

cioè?
vuoi fare un ciclo in-for?
for (c=myarray.length;c=0;c--)

Oppure può fare una copia dell'array e usare il metodo reverse.
Però senza conoscere il contesto e la natura dell'oggetto da ciclare
potrebbe non essere la soluzione adatta.
Stefano

In realtà dovrei ciclare su un array associativo quindi non posso usare la
proprietà length.
In pratica devo ciclare una struttura... il for..in parte sempre dall'ultima
proprietà della struttura, io invece vorrei partire dall'inizio.

Visto che si tratta di array associativo, potrei usare reverse() e poi fare
il for..in?

[Alessandro Crugnola]

Post by euripide
In realtà dovrei ciclare su un array associativo quindi non posso usare la
proprietà length.
In pratica devo ciclare una struttura... il for..in parte sempre dall'ultima
proprietà della struttura, io invece vorrei partire dall'inizio.
Visto che si tratta di array associativo, potrei usare reverse() e poi fare
il for..in?

il reverse nn funziona con un array associativo, anche perchè flash non
sa nemmeno cosa sia un array associativo ma lo tratta semplicemente come
object.
non puoi neanche usare la proprietà .length perchè nn ti darebbe il
valore corretto.

[Mauro Di Blasi]

Post by euripide
Visto che si tratta di array associativo, potrei usare reverse() e poi fare
il for..in?

un array associativo è di tipo Object



---

[Luca[M]]

prova a postare un esempio di codice
Luca[M]

[euripide]

il codice è molto semplice:

for( var collection:String in this.images)
{
trace(collection)
}

quando Flash genera l'output parte dall'ultimo elemento, io vorrei che
partisse dal primo...

Post by Luca[M]
prova a postare un esempio di codice
Luca[M]

[Luca[M]]

Post by euripide
for( var collection:String in this.images)
{
trace(collection)
}
quando Flash genera l'output parte dall'ultimo elemento, io vorrei che
partisse dal primo...

:) questo l'avevo capito, intendevo il tuo codice per capire come risolvere
la cosa.
Probabilmente si deve intervenire in altri punti piuttosto che inventare
nuovi cicli for
ciao
Luca[M]

[Kenny Rullo]

Post by euripide
for( var collection:String in this.images)
{
trace(collection)
}

La mia conoscenza di flash si ferma alla versione 6, quindi non so con
precisione come funzioni questo nuovo giocattolo ma la logica di
programmazione vuole che allo scorrere di una collection (esempio array)
si parta sempre dall'elemento zero. Dato che a quanto mi dicono flash
non fa uso di puntatori la cosa è alquanto strana.

Puoi fare un esempio + complesso del problema?

Ciao
Valerio

[Massimo Foti]

Post by Kenny Rullo
La mia conoscenza di flash si ferma alla versione 6, quindi non so con
precisione come funzioni questo nuovo giocattolo ma la logica di
programmazione vuole che allo scorrere di una collection (esempio array)
si parta sempre dall'elemento zero. Dato che a quanto mi dicono flash non
fa uso di puntatori la cosa è alquanto strana.

Non essendo un flasharo ero rimasto fuori dal thread, ma non posso lasciare
che Kenny spari minchiate senza porto d'armi :-))

In realtà la logica vuole che una collection, ovvero un insieme di coppie
nome/valore (le propietà di un oggetto, un array associativo o simili), non
garantiscano alcun ordine intrinseco.

Kenny, qui stiamo parlando di array associativi (aka map, hash, dictionary,
collection etc):
http://en.wikipedia.org/wiki/Associative_array

Non di array:
http://en.wikipedia.org/wiki/Array

Laddove si accede ad un elemento di una struttura dati tramite una chiave, e
non tramite la sua posizione (aka indice), l'ordine non esiste.
Il fatto che poi nella pratica Flash mantenga un certo ordine non è un
comportamento su cui si possa fare affidamento.

[Kenny Rullo]

Post by Massimo Foti

Post by Kenny Rullo
La mia conoscenza di flash si ferma alla versione 6, quindi non so con
precisione come funzioni questo nuovo giocattolo ma la logica di
programmazione vuole che allo scorrere di una collection (esempio array)
si parta sempre dall'elemento zero. Dato che a quanto mi dicono flash non
fa uso di puntatori la cosa è alquanto strana.

Non essendo un flasharo ero rimasto fuori dal thread, ma non posso lasciare
che Kenny spari minchiate senza porto d'armi :-))
In realtà la logica vuole che una collection, ovvero un insieme di coppie
nome/valore (le propietà di un oggetto, un array associativo o simili), non
garantiscano alcun ordine intrinseco.
Kenny, qui stiamo parlando di array associativi (aka map, hash, dictionary,
http://en.wikipedia.org/wiki/Associative_array
http://en.wikipedia.org/wiki/Array
Laddove si accede ad un elemento di una struttura dati tramite una chiave, e
non tramite la sua posizione (aka indice), l'ordine non esiste.
Il fatto che poi nella pratica Flash mantenga un certo ordine non è un
comportamento su cui si possa fare affidamento.

Beh allora aggiungiamo stronzate su stronzate :D Se io dichiaro un
collection:string l'ultima cosa che vado a pensare è una coppia nome valore.
Esistono strutture ben + complesse sotto il nome di collection (guarda
l'hash r5). Tutte queste hanno una logica ben precisa, tipo il buddy
system.
Il fatto che su flash parta sempre dall'ultimo valore, mi suona strano
tutto qui.
In una struttura dati ben formata non esiste mai la casualità di
accesso, altrimenti avremmo sempre il cosiddetto "caso peggiore", odiato
da tutti.

Per il resto, sei un pippettone.

Ciao
Valerio

[Massimo Foti]

Post by Kenny Rullo
Beh allora aggiungiamo stronzate su stronzate :D
La mia conoscenza di flash si ferma alla versione 6, quindi non so con
precisione come funzioni questo nuovo giocattolo ma la logica di
programmazione vuole che allo scorrere di una collection (esempio array)

Stavi mischiando array con collection!

Post by Kenny Rullo
Se io dichiaro un collection:string l'ultima cosa che vado a pensare è una
coppia nome valore.

Se la collection contiene stringhe la sintassi è assolutamente normale.
Se poi accedi con un "for in" cosa ti aspetti che sia?

Siccome, come hai giustamente fatto notare, la tua conoscenza di Flash si
ferma alla versione 6. E, aggiungo io, già allora era scarsa, ti sei fatto
ingannare dalla sintassi.
Ora, invece di esporti al pubblico ludibrio, dovresti semplicemente
ammettere di aver letto/visto male o di esser stato vittima delle sostanze
psicotrope di cui notoriamente abusi.

Post by Kenny Rullo
Esistono strutture ben + complesse sotto il nome di collection (guarda
l'hash r5). Tutte queste hanno una logica ben precisa, tipo il buddy
system.

I termini usati variano a secondo della piattaforma, ma qui stiamo parlando
di semplici coppie nome/valore, array associativi, map, hash, dictionary o
come minchia li vuoi chiamare.

Post by Kenny Rullo
Il fatto che su flash parta sempre dall'ultimo valore, mi suona strano
tutto qui.

Il concetto di "ultimo" non si applica ad una serie di coppie nome/valore
perché, per definizione, non sono ordinate. In base a che cosa definisci
"ultimo" un valore?

Post by Kenny Rullo
In una struttura dati ben formata non esiste mai la casualità di accesso,
altrimenti avremmo sempre il cosiddetto "caso peggiore", odiato da tutti.

Vogliamo fare degli esempi?

Java: map, hash e tutti i loro eredi
Python: dictionary
PHP: tutti gli array sono associativi, nessun ordine
CFML: collection

In tutti i casi di cui sopra non esiste alcun ordine intriseco all'interno
della struttura di dati.

Post by Kenny Rullo
Per il resto, sei un pippettone.

Meglio pippettone che ignorante :-)

Massimo

[Kenny Rullo]

Post by Massimo Foti
Stavi mischiando array con collection!

Vero, qui ho fatto un errore

Post by Massimo Foti
Se la collection contiene stringhe la sintassi è assolutamente normale.
Se poi accedi con un "for in" cosa ti aspetti che sia?

Può anche essere una collection di oggetti, che possono anche non essere
stringhe.

Post by Massimo Foti
Ora, invece di esporti al pubblico ludibrio, dovresti semplicemente
ammettere di aver letto/visto male o di esser stato vittima delle sostanze
psicotrope di cui notoriamente abusi.

A parte qualche psicofarmaco ogni tanto, il resto è stato abbandonato.

Post by Massimo Foti
I termini usati variano a secondo della piattaforma, ma qui stiamo parlando
di semplici coppie nome/valore, array associativi, map, hash, dictionary o
come minchia li vuoi chiamare.

Ci sono strutture dati che sotto il nome di collection, sono ben +
complesse. Il fatto che flash assuma "semplici" coppie nome/valore non è
colpa mia.

Post by Massimo Foti
Il concetto di "ultimo" non si applica ad una serie di coppie nome/valore
perché, per definizione, non sono ordinate. In base a che cosa definisci
"ultimo" un valore?

Lo dice l'autore del topic.

Post by Massimo Foti
Vogliamo fare degli esempi?
Java: map, hash e tutti i loro eredi
Python: dictionary
PHP: tutti gli array sono associativi, nessun ordine
CFML: collection

map in c++ ha un preciso ordine, basato su logica fifo o tramite liste
puntate con vettori. Anche java ce l'ha...

Python e cfml li ignoro, ma se php usa la stessa base di c, allora userà
lo stack list, quindi con ordine lifo.

Post by Massimo Foti
Meglio pippettone che ignorante :-)

Meglio ignorante che con la barba :-)

Ciao
Valerio

[Massimo Foti]

Post by Kenny Rullo

Post by Massimo Foti
Stavi mischiando array con collection!

Vero, qui ho fatto un errore

Quoto, giusto per il piacere :-)

Post by Kenny Rullo

Post by Massimo Foti
Se la collection contiene stringhe la sintassi è assolutamente normale.
Se poi accedi con un "for in" cosa ti aspetti che sia?

Può anche essere una collection di oggetti, che possono anche non essere
stringhe.

Può anche essere una collection di qualunque cosa, ció non toglie che è
intrisecamente priva di ordine. Che ci siano stringhe al suo interno, o
qualcosa di piú complesso, la sostanza non cambia, non si puó far
affidamento su alcun ordine quanto si accede con un for in.

Post by Kenny Rullo

Post by Massimo Foti
Ora, invece di esporti al pubblico ludibrio, dovresti semplicemente
ammettere di aver letto/visto male o di esser stato vittima delle
sostanze psicotrope di cui notoriamente abusi.

A parte qualche psicofarmaco ogni tanto, il resto è stato abbandonato.

Hai smesso anche il Viagra?

Post by Kenny Rullo

Post by Massimo Foti
I termini usati variano a secondo della piattaforma, ma qui stiamo
parlando di semplici coppie nome/valore, array associativi, map, hash,
dictionary o come minchia li vuoi chiamare.

Ci sono strutture dati che sotto il nome di collection, sono ben +
complesse. Il fatto che flash assuma "semplici" coppie nome/valore non è
colpa mia.

Flash non assume nulla sul tipo contenuto negli elementi della collection,
potrebbero essere oggetti complessi, ma la sostanza non cambia, perché non
sarebbero comunque ordinati.

Post by Kenny Rullo

Post by Massimo Foti
Il concetto di "ultimo" non si applica ad una serie di coppie nome/valore
perché, per definizione, non sono ordinate. In base a che cosa definisci
"ultimo" un valore?

Lo dice l'autore del topic.

L'autore del topic è abbastanza confuso, se non lo fosse non starebbe a
chiedere aiuto ai pippettoni :-)
Parla chiaramente di "ciclare su un array associativo", ma non spiega cosa
intenda per "ultimo". Suppongo si aspetti fifo, ma in realtà non ha alcuna
garanzia che la logica fifo venga rispettata.

Post by Kenny Rullo

Post by Massimo Foti
Vogliamo fare degli esempi?
Java: map, hash e tutti i loro eredi
Python: dictionary
PHP: tutti gli array sono associativi, nessun ordine
CFML: collection

map in c++ ha un preciso ordine, basato su logica fifo o tramite liste
puntate con vettori. Anche java ce l'ha...

In Java, in effetti, dipende dal tipo di map:
http://java.sun.com/j2se/1.5.0/docs/api/java/util/Map.html
[...] Some map implementations, like the TreeMap class, make specific
guarantees as to their order; others, like the HashMap class, do not [...]

Post by Kenny Rullo
Python e cfml li ignoro, ma se php usa la stessa base di c, allora userà
lo stack list, quindi con ordine lifo.

L'ordine lifo non è garantito in nessuno dei tre. Di fatto viene spesso
rispettato, ma non è garantito.

Massimo

[Kenny Rullo]

Post by Massimo Foti
Quoto, giusto per il piacere :-)

Anche io :D

Post by Massimo Foti
Può anche essere una collection di qualunque cosa, ció non toglie che è
intrisecamente priva di ordine. Che ci siano stringhe al suo interno, o
qualcosa di piú complesso, la sostanza non cambia, non si puó far
affidamento su alcun ordine quanto si accede con un for in.

Mmmh, mi sa che stiamo facendo confusione su sort e ordering.

Post by Massimo Foti
Hai smesso anche il Viagra?

Per fortuna quello ha sempre funzionato anche senza bluepill. Quando
sarà l'ora ti chiamo, visto che hai fornitura vitalizia :D

Post by Massimo Foti
Flash non assume nulla sul tipo contenuto negli elementi della collection,
potrebbero essere oggetti complessi, ma la sostanza non cambia, perché non
sarebbero comunque ordinati.

Torno a quanto detto prima: non parlo di sort.

Per esempio usando un sistema grezzo io avrei con un inserimento di coppie:
Massimo 1
Valerio 2
Jay 3
Luca 4

Verranno inseriti nello stack nell'ordine di cui sopra. Esistono sempre
due puntatori alla memoria: alla base e alla cima dello stack.
(Ipotizziamo questo scenario semplice, senza contare i puntatori dei
processi e dei thread).
In qualsiasi sistema operativo se io richiedo l'accesso a quell'area di
memoria, lui mi ritorna i valore che punta alla base dello stack (che
punta in questo caso a Massimo) e non alla cima (Luca). Questa
convenzione esiste da sempre, quindi il valore nominalmente ultimo non
può essere letto per primo, se non dietro esplicita richiesta o bug
dell'applicazione.

Post by Massimo Foti
L'autore del topic è abbastanza confuso, se non lo fosse non starebbe a
chiedere aiuto ai pippettoni :-)
Parla chiaramente di "ciclare su un array associativo", ma non spiega cosa
intenda per "ultimo". Suppongo si aspetti fifo, ma in realtà non ha alcuna
garanzia che la logica fifo venga rispettata.

Ok chiaro fin qui. Vedi sopra.

Post by Massimo Foti
http://java.sun.com/j2se/1.5.0/docs/api/java/util/Map.html
[...] Some map implementations, like the TreeMap class, make specific
guarantees as to their order; others, like the HashMap class, do not [...]

Anche qui forse abbiamo fatto un po' di confusione. Un hash base, tipo
quello di trasformare le stringhe in numeri, non rispetta il sort, ma di
fatto rispetta quello di inserimento.

Post by Massimo Foti
L'ordine lifo non è garantito in nessuno dei tre. Di fatto viene spesso
rispettato, ma non è garantito.

In c l'ordine lifo è rispettato, negli altri proprio non lo so.

Ciao
Valerio

[Massimo Foti]

Post by Massimo Foti
Hai smesso anche il Viagra?

Per fortuna quello ha sempre funzionato anche senza bluepill. Quando sarà
l'ora ti chiamo, visto che hai fornitura vitalizia :D

Per me è diverso, rmai ho raggiuto la pace dei sensi, altrimenti non starei
qui a perdere tempo con i pippetoni :-)

Post by Massimo Foti
L'ordine lifo non è garantito in nessuno dei tre. Di fatto viene spesso
rispettato, ma non è garantito.

In c l'ordine lifo è rispettato, negli altri proprio non lo so.

Il punto è proprio questo, tu pensi a C, dove la gestione della memoria è
diretta. I linguaggi citati, ActionScript compreso, hanno invece tutti un
garbage collector, prima o poi il rischio che lifo no sia rispettato quando
accedi ad un hash è sempre presente.

Massimo

[Kenny Rullo]

Post by Massimo Foti
Per me è diverso, rmai ho raggiuto la pace dei sensi, altrimenti non starei
qui a perdere tempo con i pippetoni :-)

Sei giovane, per l'impotenza c'è tempo!

Post by Massimo Foti
Il punto è proprio questo, tu pensi a C, dove la gestione della memoria è
diretta. I linguaggi citati, ActionScript compreso, hanno invece tutti un
garbage collector, prima o poi il rischio che lifo no sia rispettato quando
accedi ad un hash è sempre presente.

Vedo le cose all'atto dell'applicazione pratica di una situazione del
genere. Il fatto di non assicurare in memoria un ordine preciso per un
hash o simili è un grande spreco di risorse. Pensa ad esempio ad una
funzione find() che non può garantire il miglior costo possibile. Non
sto parlando di algoritmi di sorting, banalmente di accesso ai dati
grezzi in memoria.

In GC ben rodati come java e in minor modo .net questo problema non
sussiste perchè l'ingegnerizzazione è perfetta. La questione "morale" su
come come utilizzare questi tool esce dal seminato.

Valerio

[Giuseppe Montemurro]

Post by Kenny Rullo
Vedo le cose all'atto dell'applicazione pratica di una situazione del
genere. Il fatto di non assicurare in memoria un ordine preciso per un
hash o simili è un grande spreco di risorse. Pensa ad esempio ad una
funzione find() che non può garantire il miglior costo possibile. Non sto
parlando di algoritmi di sorting, banalmente di accesso ai dati grezzi in
memoria.

E' vero come è vero il contrario.
Ad esempio Flex 2 ha incrementato di molto la velocità di esecuzione del
player proprio creando una superclasse Sprite, che altro non è che un
tradizionale MovieClip senza la timeline.

Il vantaggio è immediato in termini di esecuzione, creazione, distruzione,
rendering ed allocazione di memoria.
Visto che un component per Flex 2 in generale non necessita di un macigno
come la timeline (e tutto il suo insieme di methods e property), mi è
sembrata cosa buona e giusta la scelta da parte di macromedia (ops! adobe)
di astrarre un concetto come Sprite o genericamente una sottoclasse di
flash.display.*

Alla stessa maniera, se usiamo delle strutture dati che non richiedono un
metodo find() è cosa ottima non scomodare costrutti spreconi di risorse.
Parliamo di array associativi? ... non abbiamo un ordine preciso, ma questo
come ogni cosa al mondo ha i suoi pro ed i suoi contro.

Ci sarà pure un perchè la VM di flash fino all'altro giorno era costituita
da un megabyte scarso di codice C++.

Oggi la VM del player 9 è circa 2Mb e contiene anche la precedente, gli
arraycollection, gli errori di runtime, la specifica E4X, dei parser XML
deliziosi, una vera sintassi strongly typed, le regular expression.

Niente male dai :)

ciao
[ jay ]

[Alessandro Crugnola]

Post by Giuseppe Montemurro
Oggi la VM del player 9 è circa 2Mb e contiene anche la precedente, gli
arraycollection, gli errori di runtime, la specifica E4X, dei parser XML
deliziosi, una vera sintassi strongly typed, le regular expression.
Niente male dai :)

io ci metterei nei primi posti il reparent ;)

[Giuseppe Montemurro]

Post by Alessandro Crugnola
io ci metterei nei primi posti il reparent ;)

Infatti, ma anche la gestione automatica dei depth, la preassegnazione dei
parametri, strutture dati come ByteArray.

*La scomparsa di attachMovie* e similari !!!!

Una nota dolente riguarda proprio il garbage collector. Ci sono dei posts
interessanti su gskinner.com a riguardo.

Ma credo (spero) si tratti di tutta roba risolvibile.

ciao
[ jay ]

[Alessandro Crugnola]

Post by Giuseppe Montemurro

Post by Alessandro Crugnola
io ci metterei nei primi posti il reparent ;)

Infatti, ma anche la gestione automatica dei depth, la preassegnazione dei
parametri, strutture dati come ByteArray.
*La scomparsa di attachMovie* e similari !!!!
Una nota dolente riguarda proprio il garbage collector. Ci sono dei posts
interessanti su gskinner.com a riguardo.
Ma credo (spero) si tratti di tutta roba risolvibile.
ciao
[ jay ]

beh, i software perfetti non esistono dopo tutto..

[Giuseppe Montemurro]

"Alessandro Crugnola"

Post by Alessandro Crugnola
beh, i software perfetti non esistono dopo tutto..

<jokeMode>
come no? ... non sono per caso quelli che finiscono per .NET? :D

(eg. WC.NET funziona egregiamente) :P
</jokeMode>

ciao
[ jay ]

[Massimo Foti]

Post by Kenny Rullo

Post by Massimo Foti
Il punto è proprio questo, tu pensi a C, dove la gestione della memoria è
diretta. I linguaggi citati, ActionScript compreso, hanno invece tutti un
garbage collector, prima o poi il rischio che lifo no sia rispettato
quando accedi ad un hash è sempre presente.

Vedo le cose all'atto dell'applicazione pratica di una situazione del
genere. Il fatto di non assicurare in memoria un ordine preciso per un
hash o simili è un grande spreco di risorse. Pensa ad esempio ad una
funzione find() che non può garantire il miglior costo possibile. Non sto
parlando di algoritmi di sorting, banalmente di accesso ai dati grezzi in
memoria.

Continui a gingillarti con la teoria ed i linguaggi di basso livello.

Nei linguaggi citati il lifo non viene garantito, punto.
Suppongo, come dice Giuseppe, che dipenda dall'allocazione di memoria, che
varia continuamente a run-time.

E poi, che cosa vuoi ottimizzare il find() in un hash se tanto accedi agli
elementi sempre in base alle loro chiavi? Infatti nelle API Java di hash e
map non hai alcun find(), perché non avrebbe senso.

Massimo

[Kenny Rullo]

Post by Massimo Foti
Continui a gingillarti con la teoria ed i linguaggi di basso livello.

Si :)

Post by Massimo Foti
Nei linguaggi citati il lifo non viene garantito, punto.
Suppongo, come dice Giuseppe, che dipenda dall'allocazione di memoria, che
varia continuamente a run-time.

Nei linguaggi citati come Java e .net il lifo viene garantito eccome.
Non so su quali basi tu dica il contrario. Hai ben chiaro come
funzionino le allocazioni di memoria? Garbage collector o meno.

Post by Massimo Foti
E poi, che cosa vuoi ottimizzare il find() in un hash se tanto accedi agli
elementi sempre in base alle loro chiavi? Infatti nelle API Java di hash e
map non hai alcun find(), perché non avrebbe senso.

http://www.oracle.com/technology/pub/articles/maps1.html
C'è get() che di fatto è la primitiva per un find(). Il senso ce l'ha
eccome, altrimenti dovresti ogni volta che ricerchi un valore scrivere
il codice per scorrere la lista.

Ciao
Valerio

[Massimo Foti]

Post by Kenny Rullo

Post by Massimo Foti
Nei linguaggi citati il lifo non viene garantito, punto.
Suppongo, come dice Giuseppe, che dipenda dall'allocazione di memoria,
che varia continuamente a run-time.

Nei linguaggi citati come Java e .net il lifo viene garantito eccome.

NET non l'ho mai citato, perché non lo conosco. Ho citato Java ed ho postato
pure il link alle API:
http://java.sun.com/j2se/1.5.0/docs/api/java/util/Map.html
[...] Some map implementations, like the TreeMap class, make specific
guarantees as to their order; others, like the HashMap class, do not. [...]

Altro esempio:
http://java.sun.com/j2se/1.5.0/docs/api/java/util/HashSet.html
[...] It makes no guarantees as to the iteration order of the set; in
particular, it does not guarantee that the order will remain constant over
time [...]

Post by Kenny Rullo
Non so su quali basi tu dica il contrario.

Documentazione ufficiale della Sun.

Post by Kenny Rullo
Hai ben chiaro come funzionino le allocazioni di memoria? Garbage
collector o meno.

Il fatto che non perda il mio tempo facendomi le seghe con linguaggi di
basso livello non significa che non sia a conoscenza di certi concetti
basilari.

Post by Kenny Rullo

Post by Massimo Foti
E poi, che cosa vuoi ottimizzare il find() in un hash se tanto accedi
agli elementi sempre in base alle loro chiavi? Infatti nelle API Java di
hash e map non hai alcun find(), perché non avrebbe senso.

http://www.oracle.com/technology/pub/articles/maps1.html
C'è get() che di fatto è la primitiva per un find(). Il senso ce l'ha
eccome, altrimenti dovresti ogni volta che ricerchi un valore scrivere il
codice per scorrere la lista.

E perché lo chiamano get() e non find() secondo te? E' solo una sintassi
equivalente all'uso di parentesi quadre in altri linguaggi, come ActioScript
1, JavaScript, CFML, PHP o Python. Ovvero:

collection.get(key)

Al posto di:

collection[key]

Non scorri nessuna lista, vai dritto all'elemento che cerchi.

Massimo

[Kenny Rullo]

Post by Massimo Foti
http://java.sun.com/j2se/1.5.0/docs/api/java/util/Map.html
[...] Some map implementations, like the TreeMap class, make specific
guarantees as to their order; others, like the HashMap class, do not. [...]

Letto con estrema velocità, ma domani ci do un occhio + approfondito.
Secondo quanto ho capito però qui siamo sempre nel sort, infatti treemap
(una mappa basata su alberi) intende il sorting, non l'ordine in memoria.

Post by Massimo Foti
http://java.sun.com/j2se/1.5.0/docs/api/java/util/HashSet.html
[...] It makes no guarantees as to the iteration order of the set; in
particular, it does not guarantee that the order will remain constant over
time [...]

Qui credo intenda un hash basato sui SET, che hanno dei controlli sui
duplicati.

Post by Massimo Foti
E perché lo chiamano get() e non find() secondo te? E' solo una sintassi
equivalente all'uso di parentesi quadre in altri linguaggi, come ActioScript
collection.get(key)
collection[key]
Non scorri nessuna lista, vai dritto all'elemento che cerchi.

Si ma secondo te come get() trova in memoria l'elemento? Accede a cazzo
a tutta l'area o scorre i valori fino a quando non trova un riscontro?

Buona serata :D

Ciao
Valerio

[Massimo Foti]

Post by Kenny Rullo

Post by Massimo Foti
http://java.sun.com/j2se/1.5.0/docs/api/java/util/Map.html
[...] Some map implementations, like the TreeMap class, make specific
guarantees as to their order; others, like the HashMap class, do not. [...]

Letto con estrema velocità, ma domani ci do un occhio + approfondito.

Fatti una cultura, leggi questo, l'autore ha disegnato le API "collection"
di Java 1.2:
http://www.amazon.com/gp/explorer/0201310058

Post by Kenny Rullo
Secondo quanto ho capito però qui siamo sempre nel sort, infatti treemap
(una mappa basata su alberi) intende il sorting, non l'ordine in memoria.

Come ordine intende l'ordine in cui vengono ritornati in un iterator (e
siamo sostanzialmente al for in/ for each).
Dove stiano in memoria non ha importanza, quel che ci interessa sapere è in
che ordine vengono ritornati gli elementi, ovvero nessun ordine, il lifo non
è affatto garantito. Come non lo è in ActionScript, JavaScript, Python, PHP
e CFML.

Post by Kenny Rullo

Post by Massimo Foti
http://java.sun.com/j2se/1.5.0/docs/api/java/util/HashSet.html
[...] It makes no guarantees as to the iteration order of the set; in
particular, it does not guarantee that the order will remain constant
over time [...]

Qui credo intenda un hash basato sui SET, che hanno dei controlli sui
duplicati.

Il controllo sui duplicati è assolutamente irrilevante. Smettila di fare il
pippettone ed attieniti all'argomento.

Post by Kenny Rullo
Si ma secondo te come get() trova in memoria l'elemento? Accede a cazzo a
tutta l'area o scorre i valori fino a quando non trova un riscontro?

Non scorre tutta l'area, non ne ha bisogno, ha già il riferimento
all'elemento. Cosí come non scorre quando su un array (vettoriale) uso
array[i]. Scorre su un array vettoriale quando cerchi un elemento senza
conoscenerne la posizione (ovvero find()).

Massimo

[Mauro Di Blasi]

Post by Massimo Foti
Come ordine intende l'ordine in cui vengono ritornati in un iterator (e
siamo sostanzialmente al for in/ for each).

segnalo anche questo link:
http://www.darronschall.com/weblog/archives/000207.cfm



---

[asleo]

Massimo Foti ha scritto:

Premetto che stavo per perdermi questa perla di thread e non me lo sarei
mai perdonato!
Anzi, brutti bastardi vecchi bavosi, perche' nessuno di voi mi ha
mandato una mail personale avvisandomi dell'avvenimento?
:)))

btw, passo anch'io a gettare un po' di benzina sul fuoco. Come sanno
anche i sassi di flash non me ne frega niente e quindi non entro nel
merito dei suoi metodi/oggetti/cazzetti vari. Coma qualcuno sa, invece,
sto scrivendo in php da un annetto. Vengo, dunque, con questa mia

Post by Massimo Foti
PHP: tutti gli array sono associativi, nessun ordine

in PHP tutti gli array sono associativi (e fin qui concordo col vecchio
barbone simil-elvetico) e mantengono l'ordine di inserimento (azz! qui
sono col rullante!)
Le varie funzioni di sorting ne modificano l'indicizzaione, ovviamente.
Ma non ho letto da nessuna parte che in assenza di sorting un non meglio
precisato "garbage collaps" possa introdurre una ventata di anarchia
nell'indicizzazione originaria (e tutti voi sapete bene quanto tali
ventate, pur essendo auspicabili nei piu' disparati campi del sociale e
del personale, sono vere e proprie iatture nel delicato mondo
dell'artificiosita' informatica...)

asleo

[Massimo Foti]

Post by asleo

Post by Massimo Foti
PHP: tutti gli array sono associativi, nessun ordine

in PHP tutti gli array sono associativi (e fin qui concordo col vecchio
barbone simil-elvetico) e mantengono l'ordine di inserimento (azz! qui
sono col rullante!)
Le varie funzioni di sorting ne modificano l'indicizzaione, ovviamente. Ma
non ho letto da nessuna parte che in assenza di sorting un non meglio
precisato "garbage collaps" possa introdurre una ventata di anarchia
nell'indicizzazione originaria (e tutti voi sapete bene quanto tali
ventate, pur essendo auspicabili nei piu' disparati campi del sociale e
del personale, sono vere e proprie iatture nel delicato mondo
dell'artificiosita' informatica...)

Probabilmente non ti è mai capitato di vedere questo fenomeno in azione, per
farlo, in PHP, devi avere script abbastanza complessi, con diverse classi,
oggetti di qua e di là, e dati rimossi/aggiunti durante l'eseguzione dello
script (magari con un pó di session, tanto per gradire).

Il "garbage collaps", lo sai solo tu cosa vuol dire, il "garbage collector"
invece è un concetto che dovrebbe esser chiaro a tutti:
http://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29

Ci vediamo a FATW, ti aspetto al buffet :-))

Massimo

[asleo]

Post by Massimo Foti

Post by asleo
Le varie funzioni di sorting ne modificano l'indicizzaione,

ovviamente. Ma

Post by Massimo Foti

Post by asleo
non ho letto da nessuna parte che in assenza di sorting un non meglio
precisato "garbage collaps" possa introdurre una ventata di anarchia

Probabilmente non ti è mai capitato di vedere questo fenomeno in azione, per
farlo, in PHP, devi avere script abbastanza complessi, con diverse classi,
oggetti di qua e di là, e dati rimossi/aggiunti durante l'eseguzione dello
script (magari con un pó di session, tanto per gradire).

beh, ma io sono stato chiaro: "in assenza di sorting"...

Post by Massimo Foti
Il "garbage collaps", lo sai solo tu cosa vuol dire, il "garbage collector"

uhauhauhauaa l'ho appunto definito "un non meglio presisato" concetto.
In ogni caso intendevo richiamare una situazione di "perdita della
memoria legata all'oggetto", come appunto avviene quando un "contenitore
dimemoria" collassa.
Insomma: vogliamo dare lo spazio che merita ad un po' di poesia e di
fantasia in questo mondo freddo e sterile dell'informatica?
:-PpPp

Post by Massimo Foti
Ci vediamo a FATW, ti aspetto al buffet :-))

Non ci sperare: saro' IO ad aspettare TE :)))

asleo

[Massimo Foti]

Post by asleo

Post by Massimo Foti
Ci vediamo a FATW, ti aspetto al buffet :-))

Non ci sperare: saro' IO ad aspettare TE :)))

Stavolta mi hanno fregato, ho la sessione prima di pranzo :-(

Massimo

[asleo]

Post by Massimo Foti

Post by asleo

Post by Massimo Foti
Ci vediamo a FATW, ti aspetto al buffet :-))

Non ci sperare: saro' IO ad aspettare TE :)))

Stavolta mi hanno fregato, ho la sessione prima di pranzo :-(

sono i primi concreti segnali del post-acquisizione :)

asleo

[Alessandro Crugnola]

Post by Massimo Foti

Post by Kenny Rullo
La mia conoscenza di flash si ferma alla versione 6, quindi non so con
precisione come funzioni questo nuovo giocattolo ma la logica di
programmazione vuole che allo scorrere di una collection (esempio array)
si parta sempre dall'elemento zero. Dato che a quanto mi dicono flash non
fa uso di puntatori la cosa è alquanto strana.

Non essendo un flasharo ero rimasto fuori dal thread, ma non posso lasciare
che Kenny spari minchiate senza porto d'armi :-))
In realtà la logica vuole che una collection, ovvero un insieme di coppie
nome/valore (le propietà di un oggetto, un array associativo o simili), non
garantiscano alcun ordine intrinseco.
Kenny, qui stiamo parlando di array associativi (aka map, hash, dictionary,
http://en.wikipedia.org/wiki/Associative_array
http://en.wikipedia.org/wiki/Array
Laddove si accede ad un elemento di una struttura dati tramite una chiave, e
non tramite la sua posizione (aka indice), l'ordine non esiste.
Il fatto che poi nella pratica Flash mantenga un certo ordine non è un
comportamento su cui si possa fare affidamento.

flash non sa cosa sia un array associativo
for..in parte dall'ultimo elemento inserito nell'oggetto/array esso sia

in ogni caso:

var ar:Array = new Array();

ar[0] = "ciao"
ar[1] = "ciao2";
ar[100] = "ciao100";
ar[9] = "ciao9";
ar['associativo'] = "ciao associativo"

trace("lunghezza array: " + ar.length);
for(var a in ar) trace([a, ar[a]])

genera:
lunghezza array: 101 --> vedi che non da la lunghezza giusta...
associativo,ciao associativo
9,ciao9
100,ciao100
1,ciao2
0,ciao

[Giuseppe Montemurro]

Post by Massimo Foti
Non essendo un flasharo ero rimasto fuori dal thread, ma non posso
lasciare che Kenny spari minchiate senza porto d'armi :-))

[Parentesi di Colore]
Mi sono cappottato sulla sedia dalle risate... oh mamma !!! :D
Mi sembra di essere tornato indietro nel tempo di 5 anni !!! :D

Back to the future !!! Ed ho la De Lorean DMC-12 in doppia fila :)

[/Parentesi di Colore]

La questione è alquanto semplice, il tipo di accesso di cui mi sembra parli
il nostro amico è quello realtivo agli array associativi riguardo i generici
oggetti in flash.

var oo: Object = {a : 5, b : "ciao mamma", c : false, d : null};

di conseguenza l'istruzione

for (var i : String in oo) trace(i);

mi traccia il seguente risultato :

a
b
c
d


così come : for (var i : String in oo) trace(oo[i]);

mi traccia
3
ciao mamma
true
null

ora se per qualche strano motivo (diciamo un prurito) vogliamo che l'ordine
del for in sia inverso possiamo usare una semplice sporca spaghettata di
codice :)


var idx : Array = new Array();
for (var i : String in oo) idx.push (i);
idx.reverse(); // e qui che facciamo la nostra cagata !!
for (var j : Number = 0 ; j < idx.length; j++) trace(idx[j]+ " --> "+
oo[idx[j]]);

otteniamo quindi:

d --> null
c --> true
b --> ciao mamma
a --> 3

ovvero accumuliamo gli indice in una sorte di stack e poi usiamo il method
Array.reverse() per ottenerne l'indice inverso.

Per pruriti più grossi potrebbe costruire una ArrayCollection per usare il
method sortOn(arg:String) per ottenerne un ordine insensato.

Personalmente non gradisco l'ineleganza di ciclare due volte.
Ma rimane una (s)porca soluzione :)

ciao
[ jay ]

P.S. Massimo hai ricevuto la mia mail?

[Alessandro Crugnola]

Post by Giuseppe Montemurro
Per pruriti più grossi potrebbe costruire una ArrayCollection per usare il
method sortOn(arg:String) per ottenerne un ordine insensato.
Personalmente non gradisco l'ineleganza di ciclare due volte.
Ma rimane una (s)porca soluzione :)
ciao
[ jay ]
P.S. Massimo hai ricevuto la mia mail?

se solo flash avesse i metodi python per i dizionari... ma qui o ecma o
niente, peggio dei talebani..

[Massimo Foti]

Post by Giuseppe Montemurro

Post by Massimo Foti
Non essendo un flasharo ero rimasto fuori dal thread, ma non posso
lasciare che Kenny spari minchiate senza porto d'armi :-))

[Parentesi di Colore]
Mi sono cappottato sulla sedia dalle risate... oh mamma !!! :D
Mi sembra di essere tornato indietro nel tempo di 5 anni !!! :D

Ho risposto appunto per questo motivo. Adesso che 'enorme massa di niubbi ha
lasciato deserto MGI, godiamocela per un pó, non tarderanno poi tanto a
tornare e noi torneremo a farci da parte.

Post by Giuseppe Montemurro
var oo: Object = {a : 5, b : "ciao mamma", c : false, d : null};
di conseguenza l'istruzione
for (var i : String in oo) trace(i);
a
b
c
d

Sei *assolutamente* sicuro che ti traccerà sempre e comunque lo stesso
risultato? Qualcosa nella documentazione ActionScript ti garantisce che
l'ordine che vedi al momento (lifo, ovvero last in first out) verrà
mantenuto per tutta la durata di una applicazione, con reimpasti di memoria,
passate di garbage collector e tutto quanto?

Post by Giuseppe Montemurro
P.S. Massimo hai ricevuto la mia mail?

Si, mi ero dimenticato di ripondere :-(

Massimo

[Giuseppe Montemurro]

Post by Massimo Foti
Sei *assolutamente* sicuro che ti traccerà sempre e comunque lo stesso
risultato? Qualcosa nella documentazione ActionScript ti garantisce che
l'ordine che vedi al momento (lifo, ovvero last in first out) verrà
mantenuto per tutta la durata di una applicazione, con reimpasti di
memoria, passate di garbage collector e tutto quanto?

No, nella maniera più assoluta, mi ero dimenticato di precisare questo in
effetti.
Gli array associativi non seguono in alcuna maniera un ordine preciso.

La mia sporca soluzione non fa altro che invertire l'ordine dato in quel
momento. Ma non posso garantire che questo sia numerico, alfabetico,
ascendente o discendente.

Credo, a dire il vero, sia tutto relativo alla allocazione di memoria
durante in run-time. Ma nessuno può garantire un ordine preciso in alcuna
maniera.

ciao
[ jay ]

[Alessandro Crugnola]

Post by Giuseppe Montemurro

Post by Massimo Foti
Sei *assolutamente* sicuro che ti traccerà sempre e comunque lo stesso
risultato? Qualcosa nella documentazione ActionScript ti garantisce che
l'ordine che vedi al momento (lifo, ovvero last in first out) verrà
mantenuto per tutta la durata di una applicazione, con reimpasti di
memoria, passate di garbage collector e tutto quanto?

No, nella maniera più assoluta, mi ero dimenticato di precisare questo in
effetti.
Gli array associativi non seguono in alcuna maniera un ordine preciso.
La mia sporca soluzione non fa altro che invertire l'ordine dato in quel
momento. Ma non posso garantire che questo sia numerico, alfabetico,
ascendente o discendente.
Credo, a dire il vero, sia tutto relativo alla allocazione di memoria
durante in run-time. Ma nessuno può garantire un ordine preciso in alcuna
maniera.
ciao
[ jay ]

se solo flash avesse i metodi python per i dizionari... ma qui o ecma o
niente, peggio dei talebani..

[Alessandro Crugnola]

Post by Massimo Foti
Kenny, qui stiamo parlando di array associativi (aka map, hash, dictionary,
http://en.wikipedia.org/wiki/Associative_array
http://en.wikipedia.org/wiki/Array
Laddove si accede ad un elemento di una struttura dati tramite una chiave, e
non tramite la sua posizione (aka indice), l'ordine non esiste.
Il fatto che poi nella pratica Flash mantenga un certo ordine non è un
comportamento su cui si possa fare affidamento.

flash non sa cosa sia un array associativo
for..in parte dall'ultimo elemento inserito nell'oggetto/array esso sia

in ogni caso:

var ar:Array = new Array();

ar[0] = "ciao"
ar[1] = "ciao2";
ar[100] = "ciao100";
ar[9] = "ciao9";
ar['associativo'] = "ciao associativo"

trace("lunghezza array: " + ar.length);
for(var a in ar) trace([a, ar[a]])

genera:
lunghezza array: 101 --> vedi che non da la lunghezza giusta...
associativo,ciao associativo
9,ciao9
100,ciao100
1,ciao2
0,ciao

[Massimo Foti]

Post by Alessandro Crugnola
flash non sa cosa sia un array associativo

Cosí come in JavaScript, un "object" in ActionScript è, sostanzialmente, un
array associativo, ovvero una serie di coppie di nome/valore

Post by Alessandro Crugnola
for..in parte dall'ultimo elemento inserito nell'oggetto/array esso sia
var ar:Array = new Array();
ar[0] = "ciao"
ar[1] = "ciao2";
ar[100] = "ciao100";
ar[9] = "ciao9";
ar['associativo'] = "ciao associativo"

Questo esempio usa un array (chiamalo array vettoriale se vuoi), non un
object
L'esempio da fare è quelo postato da Giuseppe:

var oo: Object = {a : 5, b : "ciao mamma", c : false, d : null};

Puoi chiamarlo object, aray assocativo, hash, dictionary, collection o come
cavolo vuoi. La sostanza è la stessa, una serie di coppie di nome/valore.

A scanso di equivoci consiglio di rileggere tutto il thread, non solo gli
ultimi post

Massimo

[Alessandro Crugnola]

Post by Massimo Foti
Questo esempio usa un array (chiamalo array vettoriale se vuoi), non un
object
var oo: Object = {a : 5, b : "ciao mamma", c : false, d : null};

sì, ma che si tratti di array, classe, object o altro, il for..in non fa
distinzione.
e cmq un array associativo non esiste in flash (torna ad essere un
object con i metodi -inutilizzabili- degli array), visto che un array
associativo fallisce miseramente quando utilizza le proprietà/metodi
propri degli array

[Massimo Foti]

Post by Alessandro Crugnola

Post by Massimo Foti
Questo esempio usa un array (chiamalo array vettoriale se vuoi), non un
object
var oo: Object = {a : 5, b : "ciao mamma", c : false, d : null};

sì, ma che si tratti di array, classe, object o altro, il for..in non fa
distinzione.

Sono tornato all'object perché il tuo esempio con la lunghezza dell'array
non aveva a che fare con il topic (vedi post iniziali di Euclide).

Il for..in non fa distinzione perché tutto è un object, array compresi
(esattamente come in JavaScript). Ed ogni object è, essenzialmente, una
serie di coppie nome/valore.

Post by Alessandro Crugnola
e cmq un array associativo non esiste in flash (torna ad essere un object
con i metodi -inutilizzabili- degli array), visto che un array associativo
fallisce miseramente quando utilizza le proprietà/metodi propri degli
array

Il "concetto" di array associativo in ActionScript, cosí come in JavaScript
prima di lui, è supportato dagli object. Stiamo usando il termine array
associativo per capirci meglio. Se preferisci usare il termine "object", che
in ActionScript e JavaScript è piú appropiato, per me va benissimo.

http://en.wikipedia.org/wiki/Associative_array
http://en.wikipedia.org/wiki/Array

Il fatto che i metodi degli array non siano vadano è assolutamente normale,
ci mancherebbe altro.

Massimo

[Alessandro Crugnola]

Post by Massimo Foti

Post by Alessandro Crugnola

Post by Massimo Foti
Questo esempio usa un array (chiamalo array vettoriale se vuoi), non un
object
var oo: Object = {a : 5, b : "ciao mamma", c : false, d : null};

sì, ma che si tratti di array, classe, object o altro, il for..in non fa
distinzione.

Sono tornato all'object perché il tuo esempio con la lunghezza dell'array
non aveva a che fare con il topic (vedi post iniziali di Euclide).

sì hai ragione, ho usato la proprietà sbagliata.. ma visto che
"Euripide" accennava al fatto di poter usare "reverse" volevo
evidenziare come nn si potessero usare i metodi/proprietà degli array

Post by Massimo Foti
Il "concetto" di array associativo in ActionScript, cosí come in JavaScript
prima di lui, è supportato dagli object. Stiamo usando il termine array
associativo per capirci meglio. Se preferisci usare il termine "object", che
in ActionScript e JavaScript è piú appropiato, per me va benissimo.

ecco, perchè magari poi la gente si confonde ;)

---
Alessandro Crugnola [aka sephiroth]
http://www.sephiroth.it

mobile: [phone]
---

[Massimo Foti]

Post by Massimo Foti
Sono tornato all'object perché il tuo esempio con la lunghezza dell'array
non aveva a che fare con il topic (vedi post iniziali di Euclide).

sì hai ragione, ho usato la proprietà sbagliata.. ma visto che "Euripide"
accennava al fatto di poter usare "reverse" volevo evidenziare come nn si
potessero usare i metodi/proprietà degli array

Giusto anche questo. A scanso di equivoci ricordiamo ad Euripide che
reverse() non lo puó usare.

Post by Massimo Foti
Il "concetto" di array associativo in ActionScript, cosí come in
JavaScript prima di lui, è supportato dagli object. Stiamo usando il
termine array associativo per capirci meglio. Se preferisci usare il
termine "object", che in ActionScript e JavaScript è piú appropiato, per
me va benissimo.

ecco, perchè magari poi la gente si confonde ;)

Per adesso lo scopo del thread è insultare Kenny, il resto è secondario :-)

Massimo

[Giuseppe Montemurro]

"Alessandro Crugnola"

Post by Alessandro Crugnola
sì, ma che si tratti di array, classe, object o altro, il for..in non fa
distinzione.
e cmq un array associativo non esiste in flash (torna ad essere un object
con i metodi -inutilizzabili- degli array), visto che un array associativo
fallisce miseramente quando utilizza le proprietà/metodi propri degli
array

Mi sbaglierò, ma per la mia mente un array è un vettore di elementi
(possibilmente congrui ma non necessariamente) con indice numerico.

Un Array associativo è (detto brutalmente) un qualcosa di analogo ma con
indici di tipo stringa (o al limite puntatori).

I methods che tu dici riguardo gli Array classici per istanze (object) di
classi, oggetti, o altri costrutti sono strettamente legati alla
visibilità/enumerabilità delle properties (che divengono identificatori
stringa usando le parentesi quadre).

Es. la distinsione tra private / public di un method per una istanza di
classe MiaClasse, oppure il flag che setti con ASSetPropFlag con la roba
prototype based. Ma il concetto non cambia molto.

In Flex 2 hai altri methods aggiuntivi a riguardo, qualcosa tipo
propertyIsEnumerable() o setPropertyEnumerable().

Ma che mi risulti l'oggetto (istanza) generico Object ha un array
associativo per accedere alle sue proprietà enumerabili, ma questi non ha i
methods tipici di un Array (ad indice numerico) ovvero split(), join(),
push(), length, etc.

Tanto è vero che un generico oo : Object = new Object(); in AS2 presenta
immediatamente un method addProperty(prop, getFunc, setFunc) e *non* un push
al suo array associativo.

però magari mi sbaglio :)

ciao
[ jay ]

[Alessandro Crugnola]

Post by Giuseppe Montemurro
"Alessandro Crugnola"

Post by Alessandro Crugnola
sì, ma che si tratti di array, classe, object o altro, il for..in non fa
distinzione.
e cmq un array associativo non esiste in flash (torna ad essere un object
con i metodi -inutilizzabili- degli array), visto che un array associativo
fallisce miseramente quando utilizza le proprietà/metodi propri degli
array

Mi sbaglierò, ma per la mia mente un array è un vettore di elementi
(possibilmente congrui ma non necessariamente) con indice numerico.
Un Array associativo è (detto brutalmente) un qualcosa di analogo ma con
indici di tipo stringa (o al limite puntatori).
I methods che tu dici riguardo gli Array classici per istanze (object) di
classi, oggetti, o altri costrutti sono strettamente legati alla
visibilità/enumerabilità delle properties (che divengono identificatori
stringa usando le parentesi quadre).

i metodi rimarranno anche, ma se .length nn considera gli indici
alfabetici allora a che mi serve a fare l'uso di array?
cmq nn riesco a capire dove sta andando la discussione :)

[Giuseppe Montemurro]

Post by Alessandro Crugnola
i metodi rimarranno anche, ma se .length nn considera gli indici
alfabetici allora a che mi serve a fare l'uso di array?
cmq nn riesco a capire dove sta andando la discussione :)

semplicemente nel dire che un Array associativo ha dell'Array una parentela
soltanto nel nome :)
O brutalmente, un array associativo *non è* un Array :)
E' un array associativo.

Per me sono solo un astrazione per semplificarci la vita. Ma in questo
momento specifico, la cosa non riesce bene :)

ciao
[ jay ]

[Giuseppe Montemurro]

Errata Corrige:
ovviamente con split() volevo dire splice() :)

split() è un method della Classe String :)

ciao
[ jay ]

[Massimo Foti]

Post by euripide
for( var collection:String in this.images)
{
trace(collection)
}
quando Flash genera l'output parte dall'ultimo elemento, io vorrei che
partisse dal primo...

Vedi risposta al pippettone (aka Kenny), se, come hai detto in precedenza,
si tratta di array associativo, in base a quali criteri definisci "primo" e
"ultimo"? L'ordine alfabetico delle chiavi? L'ordine crnologico in cui i
valori sono stati assegnati?

Massimo

[euripide]

Salve ragazzi,

ho letto tutti gli interventi (mi fanno male gli occhi)... ;)

Innanzitutto non volevo provocare un incidente diplomatico tra Alessandro
Foti e Kenny... :)


for( var i:Number=0; i < xmlObjects.length; i++)
{
var XmlCollection:XML = xmlObjects[i];
var rootNode:XMLNode = XmlCollection.firstChild;
var collectionName:String = rootNode.attributes.name;
var images:Array = rootNode.childNodes.slice(0);

// Contenitore per la nuova collezione di immagini.
this.images[collectionName] = new Array();

for(var j:Number=0; j<images.length; j++)
{
var image:XMLNode = images[j];
// Memorizza nell'array l'istanza di ogni immagine
this.images[collectionName].push( new Image(image.attributes.name,
image.attributes.extension) );
}
}


In definitiva il mio Object (aka array associativo) diventa questo:

this.images["augusta_2001"] = Istanza della classe Image
this.images["augusta_2002"] = Istanza della classe Image
this.images["augusta_2003"] = Istanza della classe Image

Quando vado ad utilizzare il for..in

for(var collection in this.images)
{
trace(collection)
}

genera:

augusta_2003
augusta_2002
augusta_2001

La cosa che vorrei (ma credo che non si possa fare è far comparire come
prima voce augusta_2001) e quindi First In First Out e quindi

augusta_2001
augusta_2002
augusta_2003

P.S.: Utilizzo AS 2.0 ;)

Grazie a tutti

[Alessandro Crugnola]

e perchè invece di inserire il nome nell'array:
this.images[collectionName] = new Array();

non fai un semplice push?
this.images.push(...)

Post by euripide
Salve ragazzi,
ho letto tutti gli interventi (mi fanno male gli occhi)... ;)
Innanzitutto non volevo provocare un incidente diplomatico tra Alessandro
Foti e Kenny... :)
for( var i:Number=0; i < xmlObjects.length; i++)
{
var XmlCollection:XML = xmlObjects[i];
var rootNode:XMLNode = XmlCollection.firstChild;
var collectionName:String = rootNode.attributes.name;
var images:Array = rootNode.childNodes.slice(0);
// Contenitore per la nuova collezione di immagini.
this.images[collectionName] = new Array();
for(var j:Number=0; j<images.length; j++)
{
var image:XMLNode = images[j];
// Memorizza nell'array l'istanza di ogni immagine
this.images[collectionName].push( new Image(image.attributes.name,
image.attributes.extension) );
}
}
this.images["augusta_2001"] = Istanza della classe Image
this.images["augusta_2002"] = Istanza della classe Image
this.images["augusta_2003"] = Istanza della classe Image
Quando vado ad utilizzare il for..in
for(var collection in this.images)
{
trace(collection)
}
augusta_2003
augusta_2002
augusta_2001
La cosa che vorrei (ma credo che non si possa fare è far comparire come
prima voce augusta_2001) e quindi First In First Out e quindi
augusta_2001
augusta_2002
augusta_2003
P.S.: Utilizzo AS 2.0 ;)
Grazie a tutti

[euripide]

perchè ogni indice di this.images (che a sua volta è un array) deve
contenere un array cioè:

this.image[0] = new Array();
this.image[n] = new Array();

Però anzichè riferirmi numericamente agli indici devo "associarli" ad una
stringa.

Se facessi this.images.push(...) non avrei una suddivisione tra collezioni
("augusta_2001, augusta_2002 e augusta 2003").

Praticamente la struttura che ho ricreato è questa:

images ["augusta_2001"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image

images ["augusta_2002"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image


images ["augusta_2003"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image


Le etichette (augusta ) mi servono per riferirmi ad una determinata
collezione

Post by euripide
this.images[collectionName] = new Array();
non fai un semplice push?
this.images.push(...)

Post by euripide
Salve ragazzi,
ho letto tutti gli interventi (mi fanno male gli occhi)... ;)
Innanzitutto non volevo provocare un incidente diplomatico tra Alessandro
Foti e Kenny... :)
for( var i:Number=0; i < xmlObjects.length; i++)
{
var XmlCollection:XML = xmlObjects[i];
var rootNode:XMLNode = XmlCollection.firstChild;
var collectionName:String = rootNode.attributes.name;
var images:Array = rootNode.childNodes.slice(0);
// Contenitore per la nuova collezione di immagini.
this.images[collectionName] = new Array();
for(var j:Number=0; j<images.length; j++)
{
var image:XMLNode = images[j];
// Memorizza nell'array l'istanza di ogni immagine
this.images[collectionName].push( new Image(image.attributes.name,
image.attributes.extension) );
}
}
this.images["augusta_2001"] = Istanza della classe Image
this.images["augusta_2002"] = Istanza della classe Image
this.images["augusta_2003"] = Istanza della classe Image
Quando vado ad utilizzare il for..in
for(var collection in this.images)
{
trace(collection)
}
augusta_2003
augusta_2002
augusta_2001
La cosa che vorrei (ma credo che non si possa fare è far comparire come
prima voce augusta_2001) e quindi First In First Out e quindi
augusta_2001
augusta_2002
augusta_2003
P.S.: Utilizzo AS 2.0 ;)
Grazie a tutti

[Luca[M]]

Puoi utilizzare reverse() su childNodes oppure scorrerlo al contrario invece
di ++ usa --
un esempio di reverse:
var _xml:XML=new XML("<root><item name=\"augusta_2001\" ><image name=\"1_1\"
extensions=\".jpg\"/><image name=\"1_2\" extensions=\".jpg\"/></item><item
name=\"augusta_2002\"><image name=\"2_1\" extensions=\".jpg\"/><image
name=\"2_2\" extensions=\".jpg\"/></item><item name=\"augusta_2003\"><image
name=\"3_1\" extensions=\".jpg\"/><image name=\"3_2\"
extensions=\".jpg\"/></item></root>");
var xmlObjects:Array=_xml.firstChild.childNodes;
xmlObjects.reverse()
var images:Array=[]
for (var i:Number = 0; i<xmlObjects.length; i++) {
var XmlCollection:XML = xmlObjects[i];
var collectionName:String = XmlCollection.attributes.name;
images[collectionName] = new Array();
///....il tuo codice
}
for (var a in images){
trace(a)
}

ciao
Luca[M]

[euripide]

Questo problema si solleva nella funzione per il dumping.
Al termine del caricamento dei file XML e conseguente sistemazione negli
array la struttura segue l'ordine del file XML e cioé:

images ["augusta_2001"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image

images ["augusta_2002"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image


images ["augusta_2003"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image


Il problema vien fuori quando devo fare un dump dell'array images.

function dump(Void):Void
{
for( var collection in images)
{
trace("> Collection " + collection);
trace("-------------------------");
var coll_images:Array = images[collection];
// Per ogni immagine nella collezione corrente
for( var i:Number=0; i < coll_images.length; i++)
{
trace( " > Immagine "coll_images[i].getName()" );
}
}
}

Questo genera

Collection augusta_2003
Immagine 1
Immagine 2

Collection augusta_2002
Immagine 1
Immagine 2

Collection augusta_2001
Immagine 1
Immagine 2


Come è normale che sia il for..in parte dall'ultimo elemento inserito
(augusta_2003), io cercavo un modo per farlo partire dal primo elemento
inserito.
Come già detto ***non*** posso usare images.reverse()....

Post by Luca[M]
Puoi utilizzare reverse() su childNodes oppure scorrerlo al contrario
invece di ++ usa --
var _xml:XML=new XML("<root><item name=\"augusta_2001\" ><image
name=\"1_1\" extensions=\".jpg\"/><image name=\"1_2\"
extensions=\".jpg\"/></item><item name=\"augusta_2002\"><image
name=\"2_1\" extensions=\".jpg\"/><image name=\"2_2\"
extensions=\".jpg\"/></item><item name=\"augusta_2003\"><image
name=\"3_1\" extensions=\".jpg\"/><image name=\"3_2\"
extensions=\".jpg\"/></item></root>");
var xmlObjects:Array=_xml.firstChild.childNodes;
xmlObjects.reverse()
var images:Array=[]
for (var i:Number = 0; i<xmlObjects.length; i++) {
var XmlCollection:XML = xmlObjects[i];
var collectionName:String = XmlCollection.attributes.name;
images[collectionName] = new Array();
///....il tuo codice
}
for (var a in images){
trace(a)
}
-
ciao
Luca[M]

[Luca[M]]

Ma hai provato il codice che ti ho mandato???
con il for in ti ritorna l'array ordinato come vuoi tu, devi usare reverse
su CHILDNODES, non sull'array associativo images!!!
secondo me non hai neanche provato il codice :)

ciao
Luca[M]

Post by euripide
Questo problema si solleva nella funzione per il dumping.
Al termine del caricamento dei file XML e conseguente sistemazione negli
images ["augusta_2001"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image
images ["augusta_2002"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image
images ["augusta_2003"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image
Il problema vien fuori quando devo fare un dump dell'array images.
function dump(Void):Void
{
for( var collection in images)
{
trace("> Collection " + collection);
trace("-------------------------");
var coll_images:Array = images[collection];
// Per ogni immagine nella collezione corrente
for( var i:Number=0; i < coll_images.length; i++)
{
trace( " > Immagine "coll_images[i].getName()" );
}
}
}
Questo genera
Collection augusta_2003
Immagine 1
Immagine 2
Collection augusta_2002
Immagine 1
Immagine 2
Collection augusta_2001
Immagine 1
Immagine 2
Come è normale che sia il for..in parte dall'ultimo elemento inserito
(augusta_2003), io cercavo un modo per farlo partire dal primo elemento
inserito.
Come già detto ***non*** posso usare images.reverse()....

Post by Luca[M]
Puoi utilizzare reverse() su childNodes oppure scorrerlo al contrario
invece di ++ usa --
var _xml:XML=new XML("<root><item name=\"augusta_2001\" ><image
name=\"1_1\" extensions=\".jpg\"/><image name=\"1_2\"
extensions=\".jpg\"/></item><item name=\"augusta_2002\"><image
name=\"2_1\" extensions=\".jpg\"/><image name=\"2_2\"
extensions=\".jpg\"/></item><item name=\"augusta_2003\"><image
name=\"3_1\" extensions=\".jpg\"/><image name=\"3_2\"
extensions=\".jpg\"/></item></root>");
var xmlObjects:Array=_xml.firstChild.childNodes;
xmlObjects.reverse()
var images:Array=[]
for (var i:Number = 0; i<xmlObjects.length; i++) {
var XmlCollection:XML = xmlObjects[i];
var collectionName:String = XmlCollection.attributes.name;
images[collectionName] = new Array();
///....il tuo codice
}
for (var a in images){
trace(a)
}
-
ciao
Luca[M]

[euripide]

certo che l'ho provato ma non si adattava alla mia esigenza.. cmq ti
ringrazio.

Mi sono rotto co sti array associativi perciò ho creato un'altra classe
Collection e sta volta ho definito un ***vero*** array.

Non più images ma collections in cui in ogni ***indice*** viene memorizzata
un'istanza della classe Collection...

Post by Luca[M]
Ma hai provato il codice che ti ho mandato???
con il for in ti ritorna l'array ordinato come vuoi tu, devi usare reverse
su CHILDNODES, non sull'array associativo images!!!
secondo me non hai neanche provato il codice :)
ciao
Luca[M]

Post by euripide
Questo problema si solleva nella funzione per il dumping.
Al termine del caricamento dei file XML e conseguente sistemazione negli
images ["augusta_2001"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image
images ["augusta_2002"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image
images ["augusta_2003"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image
Il problema vien fuori quando devo fare un dump dell'array images.
function dump(Void):Void
{
for( var collection in images)
{
trace("> Collection " + collection);
trace("-------------------------");
var coll_images:Array = images[collection];
// Per ogni immagine nella collezione corrente
for( var i:Number=0; i < coll_images.length; i++)
{
trace( " > Immagine "coll_images[i].getName()" );
}
}
}
Questo genera
Collection augusta_2003
Immagine 1
Immagine 2
Collection augusta_2002
Immagine 1
Immagine 2
Collection augusta_2001
Immagine 1
Immagine 2
Come è normale che sia il for..in parte dall'ultimo elemento inserito
(augusta_2003), io cercavo un modo per farlo partire dal primo elemento
inserito.
Come già detto ***non*** posso usare images.reverse()....

Post by Luca[M]
Puoi utilizzare reverse() su childNodes oppure scorrerlo al contrario
invece di ++ usa --
var _xml:XML=new XML("<root><item name=\"augusta_2001\" ><image
name=\"1_1\" extensions=\".jpg\"/><image name=\"1_2\"
extensions=\".jpg\"/></item><item name=\"augusta_2002\"><image
name=\"2_1\" extensions=\".jpg\"/><image name=\"2_2\"
extensions=\".jpg\"/></item><item name=\"augusta_2003\"><image
name=\"3_1\" extensions=\".jpg\"/><image name=\"3_2\"
extensions=\".jpg\"/></item></root>");
var xmlObjects:Array=_xml.firstChild.childNodes;
xmlObjects.reverse()
var images:Array=[]
for (var i:Number = 0; i<xmlObjects.length; i++) {
var XmlCollection:XML = xmlObjects[i];
var collectionName:String = XmlCollection.attributes.name;
images[collectionName] = new Array();
///....il tuo codice
}
for (var a in images){
trace(a)
}
-
ciao
Luca[M]

[euripide]

Risolto con una piccola aggiunta di codice che potrebbe sembrare poco
ortodossa ma per ora raggiungo il mio obiettivo.

Nella mia classe ho il metodo getCollectionsName() che ritorna nella forma
di array i nomi delle proprietà della struttura this.images nell'ordine
esatto cioè:

*** [1]***
collectionsName[0] = "Augusta_2001"
collectionsName[0] = "Augusta_2002"
collectionsName[0] = "Augusta_2003"

Integrando una logica di confronto tra ogni nome dell'array collectionsName
con ogni proprietà dell'Object this.images ***[2]*** riesco ad ottenere un
dump nell'ordine desiderato cioè:

function dump(Void):Void
{

var collectionsName:Array = this.getCollectionsName(); ***[1]***

for( var j:Number=0; j<collectionsName.length; j++ )
{

// Nome della collezione corrente.
var collectionName:String = collectionsName[j];

// Per ogni collezione ( per ogni proprietà dell'Object
this.images )
for( var collection in images)
{

*** [2] ***
if( collectionName == collection )
{

trace("> Collection " + collection);
trace("-------------------------");
var coll_images:Array =
images[collection];
// Per ogni immagine nella collezione
corrente
for( var i:Number=0; i <
coll_images.length; i++)
{
trace( " > Immagine
"coll_images[i].getName()" );
}
}

}

}

} // fine funzione Dump()


Tutto questo genera

Collection augusta_2001
Immagine 1
Immagine 2

Collection augusta_2002
Immagine 1
Immagine 2

Collection augusta_2003
Immagine 1
Immagine 2


anzichè di

Collection augusta_2003
Immagine 1
Immagine 2

Collection augusta_2002
Immagine 1
Immagine 2

Collection augusta_2001
Immagine 1
Immagine 2

Post by euripide
Questo problema si solleva nella funzione per il dumping.
Al termine del caricamento dei file XML e conseguente sistemazione negli
images ["augusta_2001"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image
images ["augusta_2002"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image
images ["augusta_2003"] = [0] = istanza di Image
[1] = istanza di Image
[n] = istanza di Image
Il problema vien fuori quando devo fare un dump dell'array images.
function dump(Void):Void
{
for( var collection in images)
{
trace("> Collection " + collection);
trace("-------------------------");
var coll_images:Array = images[collection];
// Per ogni immagine nella collezione corrente
for( var i:Number=0; i < coll_images.length; i++)
{
trace( " > Immagine "coll_images[i].getName()" );
}
}
}
Questo genera
Collection augusta_2003
Immagine 1
Immagine 2
Collection augusta_2002
Immagine 1
Immagine 2
Collection augusta_2001
Immagine 1
Immagine 2
Come è normale che sia il for..in parte dall'ultimo elemento inserito
(augusta_2003), io cercavo un modo per farlo partire dal primo elemento
inserito.
Come già detto ***non*** posso usare images.reverse()....

Post by Luca[M]
Puoi utilizzare reverse() su childNodes oppure scorrerlo al contrario
invece di ++ usa --
var _xml:XML=new XML("<root><item name=\"augusta_2001\" ><image
name=\"1_1\" extensions=\".jpg\"/><image name=\"1_2\"
extensions=\".jpg\"/></item><item name=\"augusta_2002\"><image
name=\"2_1\" extensions=\".jpg\"/><image name=\"2_2\"
extensions=\".jpg\"/></item><item name=\"augusta_2003\"><image
name=\"3_1\" extensions=\".jpg\"/><image name=\"3_2\"
extensions=\".jpg\"/></item></root>");
var xmlObjects:Array=_xml.firstChild.childNodes;
xmlObjects.reverse()
var images:Array=[]
for (var i:Number = 0; i<xmlObjects.length; i++) {
var XmlCollection:XML = xmlObjects[i];
var collectionName:String = XmlCollection.attributes.name;
images[collectionName] = new Array();
///....il tuo codice
}
for (var a in images){
trace(a)
}
-
ciao
Luca[M]

[Giuseppe Montemurro]

"Luca[M]" Scrisse
[cut]

Post by Luca[M]
var images:Array=[]
for (var i:Number = 0; i<xmlObjects.length; i++) {
var XmlCollection:XML = xmlObjects[i];
var collectionName:String = XmlCollection.attributes.name;
images[collectionName] = new Array();
///....il tuo codice
}
for (var a in images){
trace(a)
}

La tecnica funziona certo, ma volevo far notare che un successivo trace
della proprietà length del (presunto Array) images ritorna 0, nonostante
questo sia stato dichiarato come Array e contenga come noto bene 3 elementi.

Questo avvalora il concetto che in realtà l'istanza images *non è* un array
ma un generico Object ( di cui Array è una sottoclasse). E quindi, come
noiosamente sto ripetendo da giorni. *ATTENZIONE* un array associativo *non
è* un array.

Infatti se sostituiamo la linea --> var images : Array = []; con var images
: Object = {}; il piccolo snippet funziona egragiamente, con l'aggiunta che
mentalmente avremo meno confusione sull'entità degli oggetti.

dichiarando images come Array, qualsiasi ide crederà possibile utilizzare le
proprietà .length, splice etc come splice

nello specifico se proviamo ad ottenere un duplicato di images (instanziato
come Array) nella variabile b con

var b : Array = images.slice(); // questo dovrebbe duplicare l'array images
senza alterarlo ed assegnarlo alla variabile b.

b sarà un Array come dichiarato, ma non conterrà il duplicato di images
(come invece avrebbe dovuto essere).

proviamo a vedere se la cosa è vera:

instanziamo un *vero* array:

var c : Array = [1,2,3,4,5,6,7,8,9,10];

var b : Array = c.slice(); // stesso method di prima , otteniamo una copia
esatta di un Array, a patto che questi sia un Array.
for (var a in b){
trace(a+"--->"+b[a]);
}

il trace ci rivela che abbiamo avuto a che fare con degli array :)

ciao
[ jay ]

[Alessandro Crugnola]

Post by Giuseppe Montemurro
La tecnica funziona certo, ma volevo far notare che un successivo trace
della proprietà length del (presunto Array) images ritorna 0, nonostante
questo sia stato dichiarato come Array e contenga come noto bene 3 elementi.
Questo avvalora il concetto che in realtà l'istanza images *non è* un array
ma un generico Object ( di cui Array è una sottoclasse). E quindi, come
noiosamente sto ripetendo da giorni. *ATTENZIONE* un array associativo *non
è* un array.
Infatti se sostituiamo la linea --> var images : Array = []; con var images
: Object = {}; il piccolo snippet funziona egragiamente, con l'aggiunta che
mentalmente avremo meno confusione sull'entità degli oggetti.
dichiarando images come Array, qualsiasi ide crederà possibile utilizzare le
proprietà .length, splice etc come splice
nello specifico se proviamo ad ottenere un duplicato di images (instanziato
come Array) nella variabile b con
var b : Array = images.slice(); // questo dovrebbe duplicare l'array images
senza alterarlo ed assegnarlo alla variabile b.
b sarà un Array come dichiarato, ma non conterrà il duplicato di images
(come invece avrebbe dovuto essere).
var c : Array = [1,2,3,4,5,6,7,8,9,10];
var b : Array = c.slice(); // stesso method di prima , otteniamo una copia
esatta di un Array, a patto che questi sia un Array.
for (var a in b){
trace(a+"--->"+b[a]);
}
il trace ci rivela che abbiamo avuto a che fare con degli array :)

è quello che ripeto dall'inizio di questo insulso thread

[Giuseppe Montemurro]

Luca[M]

mi sembra veramente che è stata montata su una discussione per un caz*o su
una stupidata
Luca[M]

come vuoi, sono punti di vista.
Non sono daccordo con te, ma farei qualsiasi cosa perchè tu possa essere
libero di avere una tua opinione:)

buona giornata
[ jay ]

[stefano]

Hai ragione, ad esempio io non sono d'accordo su come hai scritto d'accordo,
e probabilmente tu non sei d'accordo su come ho quotato il tuo post, sono
entrambe cazzate ma una risposta al pechè dell'esistenza umana (senso della
vita più in generale) non è riuscito a darla nemmeno Einstein! :o)
--
Ciao
Stefano

Post by Luca[M]
Luca[M]

mi sembra veramente che è stata montata su una discussione per un caz*o
su una stupidata
Luca[M]

come vuoi, sono punti di vista.
Non sono daccordo con te, ma farei qualsiasi cosa perchè tu possa essere
libero di avere una tua opinione:)
buona giornata
[ jay ]

[Giuseppe Montemurro]

"stefano"

Post by stefano
Hai ragione, ad esempio io non sono d'accordo su come hai scritto
d'accordo, e probabilmente tu non sei d'accordo su come ho quotato il tuo
post, sono entrambe cazzate ma una risposta al pechè dell'esistenza umana
(senso della vita più in generale) non è riuscito a darla nemmeno
Einstein! :o)

"concordo" con te :)

il fatto che io sia affetto tra le altre cose da dislessia acuta è un dato
di fatto ;)
non posso che concordare :)

ciao
[ jay ]

[stefano]

Ecco hai visto, io ho scritto "pechè" prima al posto di "perchè", forse
perchè la dislessia è contagiosa? O forse perchè essendo sintomo di
genialità ed avendo citato Einstein ho dovuto farne uso? O forse faccio
semplicemente uso di stupefacenti di seconda raffineria? :o)

La cosa che mi affascina di Einestein è che da piccino i suoi professori
lo consideravano un demente.
Rifletto molto su questo concetto, sapendo che personalmente mi considero
un demente adulto :)

E' vero mi sembra che una volta addirittura lo bocciarono, ma forse era
tutta invidia :o)

Anch'io mi considero un demente (ovviamente non di natura einsteniana) ma
nonostante il trenta esca dagli enti ed entri negli enta posso escludere di
essere un adulto! Ecco diciamo che sono giovane dentro ;o)

Vabbè adesso devo andare a fingermi adulto per un pò, anche se giovane
dentro mamma e papà da un pò di tempo non mi danno più la paghetta
settimanale.


Ciao raga!
Stefano

[stefano]

Post by Giuseppe Montemurro

Post by stefano
post, sono entrambe cazzate ma una risposta al pechè dell'esistenza umana

"concordo" con te :)
il fatto che io sia affetto tra le altre cose da dislessia acuta è un dato
di fatto ;)
non posso che concordare :)

Ecco hai visto, io ho scritto "pechè" prima al posto di "perchè", forse
perchè la dislessia è contagiosa? O forse perchè essendo sintomo di
genialità ed avendo citato Einstein ho dovuto farne uso? O forse faccio
semplicemente uso di stupefacenti di seconda raffineria? :o)

E poi perchè adesso ho quotato bene? Vabbè quella si chiama pigrizia non ci
sono tanti misteri. ;o)


Stefano

[Giuseppe Montemurro]

Ecco hai visto, io ho scritto "pechè" prima al posto di "perchè", forse
perchè la dislessia è contagiosa? O forse perchè essendo sintomo di
genialità ed avendo citato Einstein ho dovuto farne uso? O forse faccio
semplicemente uso di stupefacenti di seconda raffineria? :o)

La cosa che mi affascina di Einestein è che da piccino i suoi professori lo
consideravano un demente.
Rifletto molto su questo concetto, sapendo che personalmente mi considero un
demente adulto :)

:D

ciao
[ jay ]

[asleo]

Post by Giuseppe Montemurro
Non sono daccordo con te, ma farei qualsiasi cosa perchè tu possa essere
libero di avere una tua opinione:)

'o cunusc pure tu, a Lello? (cit.)

ehehehhehehee
asleo

[Luca[M]]

Post by Giuseppe Montemurro
La tecnica funziona certo, ma volevo far notare che un successivo trace

lo scopo del thread è quello di far funzionare il SUO codice

Post by Giuseppe Montemurro
Questo avvalora il concetto che in realtà l'istanza images *non è* un array

e chi lo ha messo in dubbio?

Post by Giuseppe Montemurro
ma un generico Object ( di cui Array è una sottoclasse). E quindi, come
noiosamente sto ripetendo da giorni. *ATTENZIONE* un array associativo
*non è* un array.

mi sembra veramente che è stata montata su una discussione per un caz*o su
una stupidata
Luca[M]

[Massimo Foti]

Post by euripide
Innanzitutto non volevo provocare un incidente diplomatico tra Alessandro
Foti e Kenny... :)

Tranquillo, noi ci siamo divertiti un mondo, erano anni che non ci
insultavamo cosí :-)

Massimo

[Alessandro Crugnola]

Post by Massimo Foti
Tranquillo, noi ci siamo divertiti un mondo, erano anni che non ci
insultavamo cosí :-)
Massimo

Già, ma si sente che ne sono passati di anni.. non sono più gli insulti
di una volta :)

[Giuseppe Montemurro]

Già, ma si sente che ne sono passati di anni.. non sono più gli insulti di
una volta :)

Ca##o dici, pirla? ;P

ahahah :D