Newsgroup: it.comp.lang.javascript
Titolo: setTimeout a zero millisecondi

disponibili da dom.
Ora dopo aver provato l'esempio e aver verificato che effettivamente il
setTimeout('test()', 0); risolve il problema,
vorrei capire perché bastano 0 millisecondi per risolverlo.
Ciao,
--Gabriele

 setTimeout("myfunc()",0)
Sostanzialmente con setTimeout avvii un thread parallelo di esecuzione.
pippo1 istanzia un nuovo processo che immediatamente va in esecuzione.
Se vi fossero altre istruzioni in pippo1 successive alla chiamata di
setTimeout, queste verrebbero eseguite altrettanto immediatamente, senza
cioé attendere la fine di myfunc()
Non so a cosa serva lo script riportato come esempio.
Immagino che tutti i processi "secondari" vengano avviati al caricamento
della pagina.
Questo script dimostra come due "processi" potrebbero contendersi una
risorsa condivisa (giusto per sprecare CPU e divertirsi facendolo...)
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
 <title>War and peace</title>
</head>
<body>
<script>
function incrementa()
{
 document.testForm.testText.value=(1.0*document.testForm.testText.value)+1
}
function decrementa()
{
 document.testForm.testText.value=(1.0*document.testForm.testText.value)-1
}
function loopIncrementa()
{
 while (document.testForm.testText.value<1000)
 {
  incrementa()
 }
}
function loopDecrementa()
{
 while (document.testForm.testText.value>-1000)
 {
  decrementa()
 }
}
function peace()
{
 timer1=setInterval("incrementa()",5);
 timer2=setInterval("decrementa()",2.5);
}
function war()
{
 timer1=setTimeout("loopIncrementa()",5);
 timer2=setTimeout("loopDecrementa()",5);
}
function stop()
{
clearTimeout(timer1);
clearTimeout(timer2);
clearInterval(timer1);
clearInterval(timer2);
}
</script>
<form name=testForm>
<input type=text name=testText value="0"><br />
<button onclick="incrementa()">Incrementa</button>
<button onclick="decrementa()">Decrementa</button><br />
<button onclick="loopIncrementa()">Loop Incrementa</button>
<button onclick="loopDecrementa()">Loop Decrementa</button><br />
<button onclick="peace()">Peace</button>
<button onclick="war()">War</button><br />
<button onclick="stop()">Stop</button>
</form>
</body>
</html>
-- 
___________________________________________________________
a p bertolini
(
www.webwarrior.org
)

 pippo1 istanzia un nuovo processo che immediatamente va in esecuzione.
Anche il processo e' unico.
Una setTimeout non fa altro che "schedulare" l'esecuzione di un codice, non
crea un thread parallelo.
-- 
C'ya,
  ZER0 :: coder.gfxer.webDesigner();
"When you have eliminated the impossible, whatever remains,
however improbable, must be the truth." (S.H.)


Nel mio esempio, usando "setInterval", si ha un comportamento molto simile
a quello di un ambiente multi-threaded
D'altra parte, perň, se clicchi su "war" ottieni "-1000", anche modificando
i valori. Ergo non si ha un parallelismo reale ed effettivo.
Alex.


 crea un thread parallelo.
Mettendo in file le cose... vediamo se ho capito.
function pippo1 () {
    setTimeout("myfunc()",0)
    altrefunzioni();
}
function pippo2 () {
    myfunc();
    altrefunzioni();
}
la differenza quindi è che in pippo2() altrefunzioni() viene eseguito
successivamente a myfunc();
mentre nella pippo1(), altrefunzioni() viene eseguita in
"presudo-parallelismo" a myfunc(). OK?
Ora però riprendiamo l'esempio
http://groups.google.it/groups?selm=799L7.83%24r42.4210%40news.it.colt.net&o
utput=gplain
Scrivo al volo queste due funzioni:
function test1() {
    carica_contenuto_iframe();
    setTimeout("accedi_DOM_iframe()",0)
    altrefunzioni();
}
function test2 () {
    carica_contenuto_iframe();
    accedi_DOM_iframe();
    altrefunzioni();
}
Accade il contrario di ciò che mi aspettavo.
Con test1, è possibile accedere al DOM dell'iframe. Con test2 no?!?.
Vorrei focalizzare la discussione di cio che viene invocato *prima*
del setTimeout.
La funzione carica il contenuto dell'iframe.
Quando la funzione ha terminato (che non significa che l'iframe sia stato
completamente caricato),
viene lanciata la funzione  accedi_DOM_iframe(); nel test2 mentre viene
richiamato
setTimeout("accedi_DOM_iframe()",0) nel primo caso test1().
E' qui... mi sfugge la differenza, il perché test1 funziona mentre test2 no.
Spero di essermi spiegato un po' meglio.. soltanto che il discorso non è
facile :-P
Ciao,
--Gabriele.

 a quello di un ambiente multi-threaded
Ma e' sbagliatissimo vederlo in quell'ottica, anche se ti puo' *sembrare*
che vi siano analogie.


 E' qui... mi sfugge la differenza, il perché test1 funziona mentre test2 no.
Perche' non dai tempo al browser di "respirare", come ho detto prima. Non
ha nulla a che vedere con i thread.


 E' qui... mi sfugge la differenza, il perché test1 funziona mentre test2 no.
Perche' non dai tempo al browser di "respirare", come ho detto prima. Non 
ha nulla a che vedere con i thread.
-- 


 all'engine del browser il tempo di "respirare".
Non mi è molto chiaro il concetto di "dare tempo di respirare all'engine del
browser".
Scusa ma sono duro di "comprendonio" :-)
No a parte gli scherzi.
Mi stai dicendo che con il setTimeOut (anche con 0ms) sto dicendo al
browser:
"non eseguire subito subito la funzione accedi_DOM_iframe(),  aspetta 0 ms
che finisco di fare
le mie cose".
Continua a sfuggirmi come un setTimeout a 0 possa fare la differenza :-(
Ciao
--Gabriele

 Continua a sfuggirmi come un setTimeout a 0 possa fare la differenza :-(
Perché non è multi-thread...cioé: in realtà non ci mette 0 millisecondi, ma
ci mette il tempo strettamente necessario per terminare ciò che sta già
facendo...quindi termina la tua function e POI esegue quello che hai
schedulato

 le mie cose".
Non esattamente. Se tu scrivi:
do_function_A();
do_function_B();
do_function_C();
Il browser non ha "il tempo di respirare" tra le tre funzioni, le fa tutte
"una di filata all'altra".
Mentre:
do_function_A();
setTimeout("do_function_B();",0);
do_function_C();
E' un discorso completamente diverso. do_function_B() non viene eseguita
direttamente, ma gli dici di schedularla. Cio' fa "tirare fiato" al
browser.
