Newsgroup: it.comp.lang.javascript
Titolo: Pausa in attesa di un evento

Ciao a tutti,
ho googlato in lungo e in largo ma non sono riuscito a trovare un metodo
per far si che in javascript resti in attesa per un tot di tempo, fino a
che una variabile non cambia il suo status da true a false
Con un while con in mezzo un setTimeout la pausa si fa, ma il processore
va al 100% e FF segnala pure che c'è uno script che blocca tutto... : /
C'è qualche metodo meno invasivo o proprio non c'è verso?
-- 
Mr. Fix @ work

 che una variabile non cambia il suo status da true a false
javascript non è multithread, quindi dentro un while (non ho capito cosa
vuol dire un while con un setTimeout...) l'altra variabile temo non
cambierà mai valore ...
Dovrebbe funzionare un qualcosa del tipo
function test() {
 if(tuavariabile)
  setTimeout("test()",100);
 else
  alert("mò è false!");
}
-- 
"e mai che mi sia venuto in mente
 di essere più ubriaco di voi
 di essere molto più ubriaco di voi"
									  F.D.A.

 C'è qualche metodo meno invasivo o proprio non c'è verso?
Come ti è stato detto, JS non è multi-thread. Inoltre, la sua natura è
quella di essere "event-driven". Puoi semplificare in questo modo:
BROWSER -> (evento) -> SCRIPT ENGINE -> BROWSER (repaint)
Fintanto che siamo nella fase "SCRIPT ENGINE" il browser non fa nulla,
neppure il repaint della finestra. Se metti un while() in quella fase,
blocchi di conseguenza il "flusso".
-- 
~ Non esistono donne brutte. Dipende solo da quanta vodka bevi.
(proverbio russo)

 }
Uhm, ricorsivo, giusto...
temo comunque che, rigirando su se stesso, impalli il processore...  : /


 BROWSER -> (evento) -> SCRIPT ENGINE -> BROWSER (repaint)
Non ho ancora avuto tempo di provare, esiste un "onchange" legato
all'aggiornamento dell'innerHTML di un div?
Però, mi viene in mente solo ora, potrei mettere un campo hidden nel
form e modificare quello al termine dell'aggiornamento, legandogli un
onchange che... uhm...  : )


 temo comunque che, rigirando su se stesso, impalli il processore...  : /
così come ti ho scritto no di certo: non "gira su sè stesso", esegue la
stessa function ogni tot millisecondi finché la var non cambia stato (e in
quei x millisecondi ci sarà un qualcosa che non hai detto che farà cambiare
stato alla var)
-- 
"That until there is no longer first class
And second class citizens of any nation
Until the colour of a man's skin
Is of no more significance than the colour of his eyes
Me say war"
B.M.

 onchange che... uhm...  : )
Povero illuso :) Tali eventi agiscono in base all'interazione utente,
se modifichi da codice l'evento non viene generato. :)
Inoltre, sarebbe stata ugualmente una complicazione inutile.
-- 
~ Religions change, but beer and wine remain. (Harvey Allen)

 temo comunque che, rigirando su se stesso, impalli il processore...  : /
Se fosse ricorsiva, si. Ma non lo è. Il problema è che non fa quello
che ti serve, ovvero non "mette in pausa". Fa solo un check ogni 100
millisecondi dello stato della variabile, ma il browser (e l'utente)
sono liberissimi di fare pastrocchi.
-- 
~ "Quando ti rifiuti di imparare una lezione in un modo,
ti verrà ripresentata sotto un altro aspetto." (E.Caddy)

 non è ricorsivo ma comunque ok
Ah, pensavo che una funzione che richiama se stessa fosse ricorsiva...
?: )


 Inoltre, sarebbe stata ugualmente una complicazione inutile.
Ho capito, ho capito, cedo alla violenza... : )
Stasera ripiglierò il codice e vedrò di mettere in coda il submit
all'aggiornamento del div... 


 sono liberissimi di fare pastrocchi.
Uhm... però potrebbe essere proprio quello che mi serve...
Probabilmente mi sono spiegato male, non volevo bloccare tutto ma
semplicemente attendere che una variabile passasse di stato prima di
eseguire una funzione


 all'aggiornamento del div...
Beh, ma non dovrebbe essere una cosa così ostica da fare.. Ma ripeto,
non mi è ben chiaro tutto l'ambaradan.
-- 
~ "La storia sarà buona con me perché sarò io a scriverla."
(Winston Churchill)

 ?: )
pensavi male ... una function ricorsiva è una function che AL SUO INTERNO
richiama sè stessa e attende un risultato (da sè stessa) per proseguire ...
invece qua, semplicemente, se la var è true TERMINA LA FUNCTION e la
riesegue dopo n millisecondi ...
-- 
"Voi abili a tenere sempre un piede qua e uno là
 avrete un avvenire certo in questo mondo qua
 però la dignità
 dove l'avete persa?"
									    V.R.

 eseguire una funzione
Ma non capisco come mai non puoi farlo senza questa variabile di
mezzo, dato che JS normalmente si comporta cosě. :) 
-- 
~ Il futuro č nelle nostre mani. Purtroppo.

> Ah, pensavo che una funzione che richiama se stessa fosse ricorsiva...
esempio semplice di funzione ricorsiva:
 
http://www.criosoftware.it/default10.aspx
-- 
"La realtà è un'illusione causata dall'assenza di alcool."
									      A.

 riesegue dopo n millisecondi ...
Quindi, se non ho capito male, una funzione che richiama se stessa x
volte e genera un risultato senza "interventi esterni" si definisce
ricorsiva, mentre una funzione che richiama se stessa ma dipende da un
evento esterno, non si può definire ricorsiva.
(sono zuccone, mi ci vuole un attimo... : )


 mezzo, dato che JS normalmente si comporta cosě. :) 
temo di aver mal progettato lo script nella sua fase iniziale e di
essermi trascinato dietro il problema... : /


 il discorso; secondo me ti stai complicando qualcosa di semplice.
Probabilmente si, ma non volevo tediarvi con una paginata di codice e
spiegazioni.
Stasera imporrò le mani e vedrò cosa succederà. Se l'esito sarà negativo
tornerò a scassarvi gli zebedei... : )


 evento esterno, non si può definire ricorsiva.
uhm ... no. direi che il fulcro è che una function richiama sè stessa e SI
FERMA attendendo il risultato (di sè stessa) per poter andare avanti.
Quello che ti ho proposto invece non è altro che l'esecuzione di una
function ogni tot millisecondi, è completamente un'altra cosa ...
Vedi l'esempio che ti ho postato.
-- 
"E' l' ignoranza che crea l'intolleranza
 di gente cieca e senza coscienza"
									  S.S.S.

 ha scritto:

No, aspetta: il punto è che nel codice che ha scritto Cristiano la funzione
test() NON RICHIAMA SE STESSA, bensì invoca la funzione setTimeout(); è
quest'ultima che si occuperà di invocare nuovamente test().
-- 
Nando [?]
Apostolo della Prova

 evento esterno, non si può definire ricorsiva.
No. Mini spiegazione sperando sia comprensibile:
Questa e' una funzione ricorsiva:
function fact(n){
if(n<=1){
	return 1;
} else
	return n*fact(n-1);
}
}
esecuzione di fact(3):
in fact(3)
	n>1 chiama fact(2)
		in fact(2)
			n>1 chiama fact(1)
				in fact(1)
					n==1 ritorna 1 non richiama fact(0)
				fine fact(1)
		fine fact(2)
fine fact(3)
La funzione prima di terminare, per certe condizioni, richiama se stessa.
Questa non lo e':
function test() {
 if(tuavariabile)
  setTimeout("test()",100);
 else
  alert("mò è false!");
}
esecuzione di 3 volte di test():
1a
	tuavariabile==true	chiama setTimeout("test()",100);
fine 1a
setTimeout chiama test()
2a
	tuavariabile==true	chiama setTimeout("test()",100);
fine 2a
setTimeout chiama test()
3a
	tuavariabile==false	 alert("mò è false!") e non richiama setTimeout
fine 3a
La funzione non richiama mai se stessa, anche dopo aver richiamato
setTimeout termina normalmente.
'bye

 setTimeout termina normalmente.
Ottimissimo, ora il concetto è ancora più chiaro!  : )
Abbiate pietà, sono due anni che non vado in ferie... : /
La mia mente svanisce...


 quest'ultima che si occuperà di invocare nuovamente test().
Ottimo, aggiusto ulteriormente il tiro.. : )


 FERMA attendendo il risultato (di sè stessa) per poter andare avanti.
Ah, ora ho capito, thanks!  : )
