Newsgroup: it.comp.lang.javascript
Titolo: Variabile di variabile

In PHP esistono le variabili di variabili (tipo: $$a ).
Esiste qualcosa di simile in JavaScript?
Nel concreto, in una funzione che può venir richiamata più volte, mi
serve inizializzare una variabile con un nome che sia sempre diverso.
Quindi pensavo di settare una variabile globale tipo 
var a = 1;
e di incrementarla ad ogni richiamo della mia funzione, in modo da
poter utilizzare il valore della variabile a come nome di variabile.
Saluti
Matteo

 serve inizializzare una variabile con un nome che sia sempre diverso.
Sei sicuro che la tua unica opzione per sviluppare quel che ti serve, sia
istanziare ogni volta una variabile diversa?
Di quante variabili hai bisogno?
Inoltre, alla peggio, se proprio non ci sono alternative, non puoi
utilizzare gli array?
--------------------------------
Inviato via 
http://usenet.libero.it

utilizzare gli array?
Sě, in effetti sto cercando di sviluppare questa alternativa.
Grazie
Matteo

 Sě, in effetti sto cercando di sviluppare questa alternativa.
Se magari ci esponi il problema di fondo, sapremo darti maggiormente aiuto.


Se magari ci esponi il problema di fondo, sapremo darti maggiormente aiuto.
A questo punto è più una questione didattica che di necessità (nel
senso che alla fin dei conti penso non mi serva).
Una funzione, richiamata da un evento OnMouseOver, cambia il colore di
fondo della cella. All'interno di questa funzione c'è un Timeout che,
dopo n secondi, ripristina il colore originario della cella. 
La funzione ridotta all'osso è:
function inverti(obj) {
        cella = obj;
        statusquo=obj.style.backgroundColor;
        obj.style.backgroundColor = '#FFFFFF';
        // obj1=obj;
        setTimeout("cella.style.backgroundColor=statusquo",1000); 
}
Il fatto è che se l'utente, prima che sia trascorso il timeout, passa
sopra un'altra cella che richiama la stessa funzione, la funzione
viene interrotta (o meglio, viene eseguita, ma con le nuove variabili
passate dalla nuova chiamata alla funzione).
Tra l'altro non mi è molto chiaro (per mia ignoranza) perché
l'istruzione richiamata dal Timeout non veda la variabile obj passata
alla funzione (per questo creo la nuova variabile cella). 
Un saluto
Matteo

 alla funzione (per questo creo la nuova variabile cella).
Perche' devi ricordarti che setTimeout esegue la stringa che gli passi dopo
tot millisecondi, al di fuori del contesto. Ergo, obj e' dichiarata SOLO nel
contesto della tua funzione.. quindi il codice che hai scritto nel
setTimeout non la trova.
Trova invece cell e statusquo perche' sono globali, cosi' come le hai
dichiarate.. Ma, essendo globali, quando passi sopra un altra cella, i
valori vengono cambiati.
Devi cambiare completamente approccio logico.
Come mai hai optato per una soluzione come questa, invece di un
mouseover/mouseout? Se mi illumini su questo punto, vediamo assieme come
fare.


 passate dalla nuova chiamata alla funzione).
Forse ti intertessava qualcosa del genere:
    <script language="JavaScript">
    function restore() {
       this.el.style.backgroundColor = this.bgcolor;
       this.el.onmouseover = this.onmouseover;
    }
    function change(obj, color){
       this.el=obj;
       this.restore = restore;
       this.onmouseover=obj.onmouseover;
       this.bgcolor = obj.style.backgroundColor;
       this.obj = 
obj.id
 + "Object"
       eval(this.obj + "=this");
       obj.style.backgroundColor = color;
       obj.onmouseover = null;
       timerId = setTimeout(this.obj + ".restore()", 1000);
    }
    </script>
    <table width="200" border="1" cellspacing="0" cellpadding="0">
      <tr>
        <td id="uno" bgcolor="red" onmouseover="new change(this,
'#aabbcc')">&nbsp;</td>
      </tr>
      <tr>
        <td id="due" bgcolor="blue" onmouseover="new change(this,
'lightgray')">&nbsp;</td>
      </tr>
      <tr>
        <td id="tre" bgcolor="brown" onmouseover="new change(this,
'cyan')">&nbsp;</td>
      </tr>
    </table>
Maurizio.

Il 30 Set 2002, 21:51, "Maurizio." <mau...@libero.itA> ha scritto:
[STRA-CUT: Ripristinare il colore delle celle dopo "tot" secondi]
.. Io prima di usare uno script del genere, mi riguarderei ben benino
l'analisi che ci sta a monte.. a me pare un "ciuccia-risorse" incredibile
(tant'e' che allochi ad ogni mouseover).
Non "critico" (parolona) tanto lo script in se', anzi, quanto la logica di
base.. Mettere setTimeout come se piovesse, non e' esattamente il mio
concetto di "buona programmazione", non in JS almeno.
Bisognerebbe capire esattamente se quel che vuole e' *unicamente* un effetto
del genere, oppure no. Se cosi' fosse, bisognerebbe cmq rivedere la logica
che ci sta dietro ottimizzare a palla, anche se dal punto di vista del
codice forse ce lo complichiamo un poco (ad esempio, riducendo i timeout ad
uno solamente).


mouseover/mouseout? 
Sì, ho già fatto uno script utilizzando onmouseout per ripristinare il
colore della cella.
Poi, per pura speculazione, come avevo scritto nel post precedente, mi
sono chiesto se era possibile collegare il ripristino del colore
originale dopo un intervallo di tempo invece che al movimento del
mouse. È più che altro per curiosità (e in effetti nel mio caso credo
che l'effetto alla fine potrebbe creare confusione all'utente).
Saluti
Matteo

 Matteo


[snip]
Mhhh, a quanto pare funziona: ora me la studio!
Per inciso, ho notato che su Ie 'lightgray' non è accettato come
proprietà (su Opera sì), e così probabilmente altri colori CSS.
Grazie
Matteo

 concetto di "buona programmazione", non in JS almeno.
Idem, come sopra.
Maurizio.

 Idem, come sopra.
Si, ma il punto rimane: Conoscendoti, nello stesso tempo in cui l'hai
scritto (tra l'altro, Brattli rulez again :) )potevi optare per una
soluzione un po' meno "devastante".


di base alla fine e' lo stesso.
Condivido.
Il fatto è che mentre si trovano valanghe di tutorial, esempi e script
belli pronti, sono molto rari i tutorial che ti insegnio a programmare
"bene". Io me ne ricordo ad esempio uno per PHP, sul sito di Zend. 
Se ne conoscete uno per JavaScript, fatemelo sapere!
Saluti
Matteo

 memoria e hertz in abbondanza
Addirittura? L'ho fatta tanto grossa?
Nel C++ per ottimizzare le risorse vi è la funzione release che serve a
liberare la memoria utilizzata da un oggetto creato con l'operatore new. Nei
moderni linguaggi ad oggetti questa funzione manca del tutto (e secondo me
la scelta è sbagliata) perché la memoria allocata da oggetti non più
utilizzati viene liberata automaticamente nelle periodiche operazioni di
pulizia (garbage).
È vero che l'istruzione "new setup(this)" ciuccia nuove risorse perché viene
allocato un nuovo oggetto; ma al termine dell'esecuzione, non rimanendo
riferimento all'oggetto stesso, la memoria allocata viene posta
automaticamente nella lista delle risorse che devono essere liberate. Forse
non vengono liberate immediatamente; ma quando serviranno sicuramente verrà
fatto.
Se mi dici che è un cattivo modo di programmare allocare nuove risorse,
affidandosi al garbage, quando questo si può evitare, sono completamente
d'accordo. Però ti ho già detto che da questo punto di vista lo script era
solo un primo abbozzo.
Insomma non vedo tutte queste tons di memoria. Per quanto riguarda gli herz
forse ti riferisci al setTimeout; ma gli herz disponibili a tale scopo erano
disponibili anche allo Z80 o al 6502.
Mi aiuti a capire cosa c'è di tanto grave?
Maurizio.

 Mi aiuti a capire cosa c'è di tanto grave?
Riassumendo:
- JS non e' multithread.
- il setTimeout quindi lavora "nello stesso thread".
- Piu' setTimeout assegni, meno "risorse" ha ognuno, ergo piu' setTimeout
metti piu' "scattano" e sono meno "attinenti" allo scostamento che gli hai
dato.
- In una buona programmazione, il setTimeout va usato solo lo stretto
necessario.
- In uno script del genere, su una tabella abbastanza grande, se uno avesse
passato con il mouse sopra la tabella velocemente per - chesso' - andare da
altre parti, avrebbe allocato "n" setTimeout e "n" oggetti tutti in un
botto.. e non mi pare carino.
Spero di averti dato qualche spunto (dubito che sia riuscito a fartelo
capire, non tanto perche' non "credo" nelle tue capacita', anzi tutt'altro..
quanto - come un sacco di altre cose, e Riccardo puo' confermare - finche'
uno non ci arriva da solo, o non ci sbatte il capo, non le comprende
appieno).


 sono ricreduto, e al volo anche :)
Idem, e solo al terzo giorno di smanettamenti piaccapippari :-))
-- 
Ciao, Riccardo
------------------------------------------------------------------------
http://www.jsdir.com
 ---- Bring Your Site To Life!!!!
------------------------------------------------------------------------
http://www.dev2dev.it
 - La rete ha connesso nuove particelle - D2D006
------------------------------------------------------------------------
 ----> itALY = it <----

 - il setTimeout quindi lavora "nello stesso thread".
Non confondiamo. Il fatto che il js non sia multithread non vuol dire che il
browser o l'interprete js non usi piů thread.
In ogni caso il js puň lavorare tramite interrupt. Un sistema operativo come
il dos, che non č multithread fa ampio uso degli interrupt: per leggere la
tastiera, il mouse, i caratteri in arrivo dal modem o addirittura per
aggiornare l'ora nelle macchine piů vecchie prive di orologio. Ogni x
millisecondi veniva interrotto il normale lavoro per richiamare altre
funzioni che svolgevano compiti importanti per il funzionamento della
macchina.
Qualche volta funzioni erano costituite da un semplice "return" perché
quella funzione non era attiva. Perň venivano richiamate in ogni caso. In
altre parole, secondo me anche il timeout del js viene eseguito ogni tot
millisecondi anche se non vi č stato alcun setTimeout; in questo caso la
funzione torna al chiamante senza effettuare niente.
Anche con il vecchio basic che girava su macchine a 8 bit aveva a
disposizione istruzioni simili al setTimeout che permettevano di fare
qualcosa che aveva una certa parvenza di multitasking.
Una vecchia "ciavatta" chiamata TI99 della Texas Instruments aveva gli
sprite (una specie di layer) il cui movimento veniva comandato da semplici
istruzioni basic. Ad ogni interrupt l'interprete basic provvedeva a
modificare la loro posizione. Sullo schermo si vedevano i 16 (o 32, non
ricordo) sprite che si muovevano, l'uno indipendentemente dall'altro, in
maniera assolutamente fluida. Altrimenti come si spiegherebbero certi
videogiochi di tanti anni fa?
E se ci riuscivano quelle vecchie macchine che avevano un clock di pochi
MHerz, perché non ci deve riuscire il js sui nostri computer superpotenti?
L'importante č che la funzione eseguita al timeout non impegni il
microprocessore per troppo tempo e non che vi siano poche interruzioni.
In conclusione il mio script alloca sě n (3) timeout tutti insieme.
L'interprete js ne prende atto e segna questi timeout in un suo array
continuando a svolgere tutte le normali funzioni. Al termine del timeout
viene richiamata una funzione che ha l'unico compito di cambiare colore alla
cella. E se questo sembra un grande impegno ditemelo che torno al TI99.
Maurizio.

 E se questo sembra un grande impegno ditemelo che torno al TI99.
Beh, torna al TI99 se vuoi.
I timeout in Javascript sono *pesanti*, soprattutto quando se ne usa 
piu' di uno in modo "parallelo" cosi' che si "accavallino".
Io non sto dicendo di non farne uso, ma solo di non farne ABUSO.
-- 
C'ya,
ZER0
  :. job profile - coder.gfxer.webDesigner
"When you have eliminated the impossible, whatever remains,
however improbable, must be the truth." (S.H.)