Oggetto XHR globale

Ma guarda, sono un po' come quelli che partecipano ai reality, non sanno
fare un caxxo e poi fanno TV (con il malumore degli adetti ai lavori)
Io, un giorno non troppo lontano ho scoperto l'informatica e da quasi
autodidatta mi sono inventato un lavoro e poi un altro e non ho ancora
capito come faccio ancora sd andare avanti...

Perfetto, ti seguo su questa metafora:
Nel momento in cui i partecipanti ai reality fanno TV, arriva un punto
in cui
[cut]

ok fermati, capito

E' del tutto normale che s'inizi come te: di certo, quando ho studiato
io, il "web" non lo insegnavano. E neppure i Design Pattern. In questo
campo, qui dentro, credo che gli autodidatti spopolino.

sì, il problema mio, come forse si è intuito, è che mancano delle
conoscenze (parecchie) sui metodi progettuali e il mio modo di programmare
è il peggiore è nato come procedurale e più oop proprio grazie all'ambito
web...

[cut]

Con la "manutenibilità" che si rivolta metaforicamente nella tomba.

molto istruttivo, come sempre

in effetti, ma più che altro, volevo evitare che si vedesse
l'inizializzazione

.. Mi hai appena fatto cascare le braccia, lo sai vero?

mi dispiace, non volevo, fai conto che non abbia detto niente
mi vergogno di quello che ho detto, nel rileggere il post non ci volevo
credere

, ma non la stai neppure dichiarando!

io pensavo di sì

No, non la stai dichiarando. Una dichiarazione senza inizializzazione,
sarebbe:

var xmlhttp;
function ...

Mentre tu la usi direttamente, senza dichiararla. Il parser la vede, e
dice "che roba è questa? E' una variabile locale? No, non la vedo. Bòn
sarà una proprietà dell'oggetto globale" e va ad impostarla in window,
nel nostro caso, implicitamente.
Tant'è che una variabile globale così fatta, è leggermente differente,
da una dichiarata tramite var, comportandosi esattamente come se fosse
una proprietà dell'oggetto.

cavolo, io pensavo che una variabile globale venisse messa in una proprietà
omonima nell'oggetto window

Lo usi l'ICEBrowser?

eccerto

Credo tu sia il primo che abbia mai incontrato.

No, stavo scherzando, manco so' di che browser stai parlando

Ni. Devi ragionare in termini di OOP, non di "funzioni" procedurali.

e appunto, questo è uno dei miei problemi

I Design Pattern (e quindi il Singleton) si applicano alla OOP.

Sarebbe bello/interessante che mi potessi fare un'esempio

Google it's your friend:
http://www.google.it/search?q=singleton+javascript

bene tra i miei mille casini sono andato a spulciare qualche link...
e sono subito rimasto folgorato facendo scoperte nuove,
ok, io ho trovato questo:
http://html.it/guide/esempi/oop/sing...avascript.html

dal quale ho fatto la scoperta incredibile che all'interno di una funzione
si possono richiamare le variabili nel proprio interno usando il
riferimento della funzione stessa, io pensavo si potesse fare solo con
this, ho capito che in questo modo si è un po' simulato il concetto di
variabile privata e pubblica.
Al chè ho voluto subito fare un mio singleton (di cui ne esisteranno 10000)
un po' più generico di quello dell'esempio del link, e questo è quello che
ho prodotto:

function Singleton( objectName )
{
if( typeof Singleton[objectName] == 'undefined' )
eval( "Singleton['"+objectName+"'] = "+objectName+"( );" );

return Singleton[objectName];
}

però non mi fa impazzire perchè ho usato eval, ma mi sembra che funzioni e
che sia generico, però l'utilizzo che ne ho subito fatto temo che non sia
molto orientato agli oggetti:

praticamente nella funzione di qualche post fa io non faccio altro che
dichiarare una variabile locale che prende il riferimento:

function async_get_request( query, callback )
{
var xmlhttp = Singleton( 'getXmlHttpRequest' );

if( xmlhttp && query )
{
xmlhttp.open( "GET", query, true );
xmlhttp.setRequestHeader( "If-Modified-Since",
"Sat, 11 Jan 1977 00:00:00 GMT" );

xmlhttp.onreadystatechange = function( evt )
{
if( xmlhttp.readyState == 4 )
{
if( xmlhttp.status == 200 )
callback( xmlhttp.responseText );
else
alert( "Error; status = " + xmlhttp.status );
}
}

xmlhttp.send( );
}
}

A proposito, io pensavo felicemente che una funzione così, potesse andare
bene, ma mi sono accorto che FF si incaxxa di brutto se cerco di fare più
richieste ravvicinate , cioè se l'ultima richiesta non è conclusa, mi va in
errore a differenza di IE che ignora la precedente e cosidera solo l'ultima
(comportamento che pensavo avrebbe avuto anche FF)
come posso fare?

this, ho capito che in questo modo si è un po' simulato il concetto di
variabile privata e pubblica.

Anzi non è coretto, forse è meglio dire: statica e privata...

On Sat, 1 Dec 2007 00:15:27 +0100, Ugo wrote:

E' del tutto normale che s'inizi come te: di certo, quando ho studiato
io, il "web" non lo insegnavano. E neppure i Design Pattern. In questo
campo, qui dentro, credo che gli autodidatti spopolino.

sì, il problema mio, come forse si è intuito, è che mancano delle
conoscenze (parecchie) sui metodi progettuali

Lacune che dovresti colmare: Ed il tempo per farlo lo si trova se uno
davvero vuole. Come hai visto, non è mai tempo perso perché poi aiuta
a modificare l'approccio nello sviluppo e manutenzione, riducendone i
tempi.
Sono lacune che si possono colmare anche in corso d'opera, ovvero nel
mentre stai sviluppando.

, ma non la stai neppure dichiarando!

io pensavo di sì

No, non la stai dichiarando. Una dichiarazione senza inizializzazione,
sarebbe:

var xmlhttp;
function ...

Mentre tu la usi direttamente, senza dichiararla. Il parser la vede, e
dice "che roba è questa? E' una variabile locale? No, non la vedo. Bòn
sarà una proprietà dell'oggetto globale" e va ad impostarla in window,
nel nostro caso, implicitamente.
Tant'è che una variabile globale così fatta, è leggermente differente,
da una dichiarata tramite var, comportandosi esattamente come se fosse
una proprietà dell'oggetto.

cavolo, io pensavo che una variabile globale venisse messa in una proprietà
omonima nell'oggetto window

Viene considerata "come" una proprietà dell'oggetto globale, e lo è a
tutti gli effetti se non la dichiari. Un esempio lampante:

var myvar = "12";
myprop = "34";

alert(window.myvar); // 12
alert(window.myprop); // 34

delete window.myprop; // ok
delete window.myvar; // errore, non è davvero una proprietà

Lo usi l'ICEBrowser?

eccerto

Credo tu sia il primo che abbia mai incontrato.

No, stavo scherzando, manco so' di che browser stai parlando

Allora risottolineo, senza ripeterlo, quello che ti ho detto nel post
precedente.

Ni. Devi ragionare in termini di OOP, non di "funzioni" procedurali.

e appunto, questo è uno dei miei problemi

La OOP è un modello che rispecchia più fedelmente la realtà, rispetto
alla programmazione procedurale. Paradossalmente, ti sforzi di più se
devi adattare la "realtà" al modello procedurale.

bene tra i miei mille casini sono andato a spulciare qualche link...

Dovresti sempre trovare il tempo per farlo. Come vedi, è tempo che si
ripaga abbondantemente da sé.

e sono subito rimasto folgorato facendo scoperte nuove,
ok, io ho trovato questo:

L'idea viene più o meno resa, ma ci sono sicuramente esempi migliori,
a giro. Decisamente migliori.

dal quale ho fatto la scoperta incredibile che all'interno di una funzione
si possono richiamare le variabili nel proprio interno usando il
riferimento della funzione stessa,

Vediamo di fare un po' di chiarezza. Non c'è niente di "incredibile":
un costruttore è una funzione ed è un oggetto allo stesso tempo.
Quello che viene fatto in quel codice, non è altro che aggiungere una
proprietà all'oggetto "Singleton". E fin qui non c'è nulla di strano,
no? L'hai già fatto sicuramente altre volte di aggiungere una in modo
dinamico una proprietà ad un oggetto:

var MyObj = {};
MyObj.myprop = "123";

E' la stessa identica cosa.
Quindi, in primo luogo, non si tratta di "variabili".

Per quanto riguarda invece il "riferimento alla funzione stessa", non
dovrebbe colpirti in modo particolare. Javascript non è compilato, ma
interpretato sul momento. Quindi, se tu scrivi un codice tipo:

function myFunction(){
alert(myFunction);
}

E' perfettamente lecito, in quanto sebbene l'oggetto myFunction *non*
è ancora stato dichiarato, e quindi non esiste, esisterà quando detto
codice sarà eseguito.

Tant'è che anche un codice del genere:

function myFunction(){
chiamaUnaFunzioneCheNonEsiste();
}

Non ti darà errore fintanto che non invochi myFunction.

io pensavo si potesse fare solo con this,

Sono due cose completamente diverse e slegate tra di loro. Il "this",
è il riferimento all'oggetto contestuale corrente.
Nel caso di una funzione usata come costruttore, il this si riferisce
(quando chiamata con il new) all'istanza appena creata. Mentre usando
il riferimento alla funzione stessa, la stai gestendo come un oggetto
qualsiasi, parimenti a document, window, o altro.
Non accedi, infatti, allo scope della funzione per intenderci.

Queste informazioni, comunque, le trovi nella reference e nella guide
di Javascript.

ho capito che in questo modo si è un po' simulato il concetto di
variabile privata e pubblica.

No, niente di tutto questo. Spero ti sia più chiaro, adesso.

Al chè ho voluto subito fare un mio singleton (di cui ne esisteranno 10000)

E ti consiglio, prima di metterti a inventare nuovamente la ruota, di
capire almeno di che forma è fatta una ruota e come funziona.

un po' più generico di quello dell'esempio del link, e questo è quello che
ho prodotto:

function Singleton( objectName )
{
if( typeof Singleton[objectName] == 'undefined' )
eval( "Singleton['"+objectName+"'] = "+objectName+"( );" );

return Singleton[objectName];
}

Dunque. In primis, questo *non* è un Singleton. Inoltre, hai di nuovo
ragionato in termini procedurali e non a oggetti.

però non mi fa impazzire perchè ho usato eval, ma mi sembra che funzioni e
che sia generico,

Un Singleton è un pattern, è già generico di suo. Deve essere usato e
implementato in un oggetto. Tu l'hai distorto in una funzione.

Questo link dovrebbe aiutarti ulteriormente:

http://it.wikipedia.org/wiki/Singleton

if( xmlhttp.status == 200 )
callback( xmlhttp.responseText );
else
alert( "Error; status = " + xmlhttp.status );

Guarda che uno status diverso da 200 non significa necessariamente un
errore.

A proposito, io pensavo felicemente che una funzione così, potesse andare
bene,

Evita la closure, se puoi, oppure cerca di farla un poco meglio.

ma mi sono accorto che FF si incaxxa di brutto se cerco di fare più
richieste ravvicinate ,

"S'incaxxa di brutto" è un sinonimo di "non funziona".. e sai che non
vuol dire poi molto.
Sono sicuro che se ti vai a leggere l'errore capisci da solo cosa non
va. E se ben ricordo ne abbiamo già discusso in questo newsgroup.

cioè se l'ultima richiesta non è conclusa, mi va in errore a differenza
di IE che ignora la precedente e cosidera solo l'ultima (comportamento
che pensavo avrebbe avuto anche FF)

Capisci cosa intendevo dire, quando ti ho scritto di non "supportare"
browser che non usi o non sei disposto a testare?

come posso fare?

Gestire l'interruzione di richieste in corso, cosa che al momento non
fai.
Se cerchi su google o nel NG, dovresti trovare informazioni in merito
alla questione.

--
~ "La realtà è ciò che, quando smetti di crederle, non va via."
(Philip K. Dick)

On Mon, 3 Dec 2007 00:30:53 +0100, Ugo wrote:

this, ho capito che in questo modo si è un po' simulato il concetto di
variabile privata e pubblica.

Anzi non è coretto, forse è meglio dire: statica e privata...

Se parliamo di "simulazione", direi che con tale approccio simuli
quelle che sono chiamate "proprietà di classe" (o anche statiche,
è vero, ma assolutamente non private).
Un metodo/proprietà statica o di classe, non viene trasmesso alle
istanze della classe ed è indipendente da queste.

In Javascript, un esempio è dato dal metodo "fromCharCode".

--
~ Io ho una filosofia semplice:
Riempi ciò che è vuoto. Vuota ciò che è pieno. Gratta ciò che prude.
(A. R. Longworth)

Sono lacune che si possono colmare anche in corso d'opera, ovvero nel
mentre stai sviluppando.

più o meno sto cercando di fare così....

bene tra i miei mille casini sono andato a spulciare qualche link...

Dovresti sempre trovare il tempo per farlo. Come vedi, è tempo che si
ripaga abbondantemente da sé.

già

e sono subito rimasto folgorato facendo scoperte nuove,
ok, io ho trovato questo:

L'idea viene più o meno resa, ma ci sono sicuramente esempi migliori,
a giro. Decisamente migliori.

a ecco

dal quale ho fatto la scoperta incredibile che all'interno di una funzione
si possono richiamare le variabili nel proprio interno usando il
riferimento della funzione stessa,

Vediamo di fare un po' di chiarezza. Non c'è niente di "incredibile":
un costruttore è una funzione ed è un oggetto allo stesso tempo.
Quello che viene fatto in quel codice, non è altro che aggiungere una
proprietà all'oggetto "Singleton". E fin qui non c'è nulla di strano,
no?

ni

L'hai già fatto sicuramente altre volte di aggiungere una in modo
dinamico una proprietà ad un oggetto:

var MyObj = {};
MyObj.myprop = "123";

ma qui lo sto facendo con un'istanza

E' la stessa identica cosa.

a ecco

Per quanto riguarda invece il "riferimento alla funzione stessa", non
dovrebbe colpirti in modo particolare. Javascript non è compilato
[cut...]

giusto

Al chè ho voluto subito fare un mio singleton (di cui ne esisteranno 10000)

E ti consiglio, prima di metterti a inventare nuovamente la ruota, di
capire almeno di che forma è fatta una ruota e come funziona.

mah, diciamo che a me serviva uno strumento che mi facesse
un'inizializzazione lazy, che ho erroneamente chiamato singleton

un po' più generico di quello dell'esempio del link, e questo è quello che
ho prodotto:

function Singleton( objectName )
{
if( typeof Singleton[objectName] == 'undefined' )
eval( "Singleton['"+objectName+"'] = "+objectName+"( );" );

return Singleton[objectName];
}

Dunque. In primis, questo *non* è un Singleton.

ok, come ti dicevo era quello che cercavo di fare, però... :P

Inoltre, hai di nuovo
ragionato in termini procedurali e non a oggetti.

e già
e avrò dei problemi, per chissa' quanto...

però non mi fa impazzire perchè ho usato eval, ma mi sembra che funzioni e
che sia generico,

Un Singleton è un pattern, è già generico di suo. Deve essere usato e
implementato in un oggetto. Tu l'hai distorto in una funzione.

sono stato bravo )

Questo link dovrebbe aiutarti ulteriormente:

http://it.wikipedia.org/wiki/Singleton

ok,
allora ho prodotto questo:

function getXmlHttpRequest( singleton )
{
var xhr = null;
if( typeof singleton == 'undefined' )
singleton = true;

if( ! singleton || typeof getXmlHttpRequest.xmlhttp == 'undefined' )
{
if( typeof window.XMLHttpRequest != "undefined" )
{
xhr = new XMLHttpRequest( );
if ( xhr && xhr.overrideMimeType )
xhr.overrideMimeType('text/xml');
}
else if( typeof window.ActiveXObject != "undefined" )
{
/*@cc_on
@if( @_win32 )
{

xhr = new ActiveXObject( 'Microsoft.XMLHTTP' );
}
@end
@*/
}

if( singleton )
getXmlHttpRequest.xmlhttp = xhr;
}

return xhr || getXmlHttpRequest.xmlhttp;
}

A proposito, io pensavo felicemente che una funzione così, potesse andare
bene,

Evita la closure, se puoi, oppure cerca di farla un poco meglio.

ci ho provato, ma in vano...
volevo passare una collback che dentro di sè non dovesse controllare lo
status della richiesta ma che gli venisse passato il risultato
poi ho provato a sostituire la chiusura con this, però ora sono in delirio
è non riesco a capire perchè non si riferisca all'oggetto...

ma mi sono accorto che FF si incaxxa di brutto se cerco di fare più
richieste ravvicinate ,

"S'incaxxa di brutto" è un sinonimo di "non funziona".. e sai che non
vuol dire poi molto.

hai ragione:

1)
uncaught exception: [Exception... "Component returned failure code:
0x804b000f [nsIXMLHttpRequest.setRequestHeader]" nsresult: "0x804b000f
(<unknown>)" location: "JS frame ::
http://localhost/backoffice/includes...?lm=1196720818
:: async_get_request :: line 681" data: no]

Line 0

2)
[Exception... "Component returned failure code: 0x80040111
(NS_ERROR_NOT_AVAILABLE) [nsIXMLHttpRequest.status]" nsresult: "0x80040111
(NS_ERROR_NOT_AVAILABLE)" location: "JS frame ::
http://localhost/backoffice/includes...?lm=1196720818
:: anonymous :: line 687" data:
no]
http://localhost/backoffice/includes...?lm=1196720818
Line
687

Sono sicuro che se ti vai a leggere l'errore capisci da solo cosa non
va.

mah, ho capito che va in errore quando faccio open con l'oggetto che
poverino stava facendo dell'altro

E se ben ricordo ne abbiamo già discusso in questo newsgroup.

non ho trovato molto... cmq adesso è tardi e ho sonno

cioè se l'ultima richiesta non è conclusa, mi va in errore a differenza
di IE che ignora la precedente e cosidera solo l'ultima (comportamento
che pensavo avrebbe avuto anche FF)

Capisci cosa intendevo dire, quando ti ho scritto di non "supportare"
browser che non usi o non sei disposto a testare?

sì sì

come posso fare?

Gestire l'interruzione di richieste in corso, cosa che al momento non
fai.

Mmmm, mi dai un'idea?

On Tue, 4 Dec 2007 00:14:45 +0100, Ugo wrote:

dal quale ho fatto la scoperta incredibile che all'interno di una funzione
si possono richiamare le variabili nel proprio interno usando il
riferimento della funzione stessa,

Vediamo di fare un po' di chiarezza. Non c'è niente di "incredibile":
un costruttore è una funzione ed è un oggetto allo stesso tempo.
Quello che viene fatto in quel codice, non è altro che aggiungere una
proprietà all'oggetto "Singleton". E fin qui non c'è nulla di strano,
no?

ni

"ni"? Dove vedi la "stranezza", scusa?

L'hai già fatto sicuramente altre volte di aggiungere una in modo
dinamico una proprietà ad un oggetto:

var MyObj = {};
MyObj.myprop = "123";

ma qui lo sto facendo con un'istanza

Scusa, eh, ma qui non lo fai comunque con un'istanza?

function MyFun(){};

MyFun.myprop = "123";

E' la stessa identica cosa.

a ecco

Non dire "a ecco" se continui ad avere dei dubbi.

Al chè ho voluto subito fare un mio singleton (di cui ne esisteranno 10000)

E ti consiglio, prima di metterti a inventare nuovamente la ruota, di
capire almeno di che forma è fatta una ruota e come funziona.

mah, diciamo che a me serviva uno strumento che mi facesse
un'inizializzazione lazy,

Sono due cose diverse, un'inizializzazione lazy con lo scope delle
variabili non ha nulla a che vedere. E quindi non ti serve affatto
a rimuovere le variabili globali.
Per questo scopo ti serve un Singleton.

che ho erroneamente chiamato singleton

La tua non era né una cosa, né l'altra; ma una sorta di incrocio,
non propriamente riuscito, tra le due.. in ottica procedurale.
Direi che hai anche un bel po' di confusione in testa, anche solo
per ciò che concerne la terminologia.
Ti rinnovo il consiglio di imparare qualcosa di più sulla "ruota"
prima di prendere gli attrezzi in mano.

Inoltre, hai di nuovo
ragionato in termini procedurali e non a oggetti.

e già
e avrò dei problemi, per chissa' quanto...

Allora la prima cosa da fare è risolvere quest'aspetto, visto che
si riflette negativamente in tutto ciò che sviluppi.

Un Singleton è un pattern, è già generico di suo. Deve essere usato e
implementato in un oggetto. Tu l'hai distorto in una funzione.

sono stato bravo )

Non è esattamente quello che pensavo. :P

Questo link dovrebbe aiutarti ulteriormente:

http://it.wikipedia.org/wiki/Singleton

ok,
allora ho prodotto questo:

Aaah, ancora non ci siamo! Il Singleton è un Design Pattern che si
applica alla OOP, e qui di OOP non ne vedo traccia, c'è unicamente
una funzione.

Riguardati il link che ti ho postato sul Singleton e dimmi se c'è
qualcosa che vagamente somiglia a quello che hai scritto.

Evita la closure, se puoi, oppure cerca di farla un poco meglio.

ci ho provato, ma in vano...

Se utilizzi il pattern Singleton puoi anche farne a meno, laddove
non hai diverse istanze dell'oggetto XmlHttpRequest.

poi ho provato a sostituire la chiusura con this, però ora sono in delirio
è non riesco a capire perchè non si riferisca all'oggetto...

L'onreadystatechange è un evento decontestualizzato, è per questo
che il "this" non si riferisce all'istanza dell'oggetto XHR.

come posso fare?

Gestire l'interruzione di richieste in corso, cosa che al momento non
fai.

Mmmm, mi dai un'idea?

Cercare su Google ti dovrebbe già fornire parecchie informazioni,
ma anche un *minimo* di debugging sul tuo codice, ti dovrebbe già
chiarire cos'è che va in errore e perché, e quindi come evitarlo.
Verifica la riga che Firefox ti segnala. Metti un alert. Almeno i
fondamentali, vedi di farli. Se nonostante questo ti sfugge il
nocciolo della questione ne riparliamo. Gli approcci in tal senso
possono essere diversi.
E ne avevamo già discusso in questo NG, ripeto, almeno una volta.

--
~ "E' bello essere vivi.
Ci sono tante cose che non si possono fare da morti."

ni

"ni"? Dove vedi la "stranezza", scusa?

L'hai già fatto sicuramente altre volte di aggiungere una in modo
dinamico una proprietà ad un oggetto:

var MyObj = {};
MyObj.myprop = "123";

ma qui lo sto facendo con un'istanza

Scusa, eh, ma qui non lo fai comunque con un'istanza?

function MyFun(){};

MyFun.myprop = "123";

O_O
ignoravo che si potesse fare questa cosa

E' la stessa identica cosa.

a ecco

Non dire "a ecco" se continui ad avere dei dubbi.

Aaah, ancora non ci siamo!

eh, ci avrei giocato le palle

Il Singleton è un Design Pattern che si
applica alla OOP, e qui di OOP non ne vedo traccia, c'è unicamente
una funzione.

:P

Riguardati il link che ti ho postato sul Singleton e dimmi se c'è
qualcosa che vagamente somiglia a quello che hai scritto.

capito

Evita la closure, se puoi, oppure cerca di farla un poco meglio.

ci ho provato, ma in vano...

Se utilizzi il pattern Singleton puoi anche farne a meno, laddove
non hai diverse istanze dell'oggetto XmlHttpRequest.

questo l'ho capito

poi ho provato a sostituire la chiusura con this, però ora sono in delirio
è non riesco a capire perchè non si riferisca all'oggetto...

L'onreadystatechange è un evento decontestualizzato, è per questo
che il "this" non si riferisce all'istanza dell'oggetto XHR.

ahh

come posso fare?

Gestire l'interruzione di richieste in corso, cosa che al momento non
fai.

Mmmm, mi dai un'idea?

Cercare su Google ti dovrebbe già fornire parecchie informazioni,
ma anche un *minimo* di debugging sul tuo codice, ti dovrebbe già
chiarire cos'è che va in errore e perché,

mah, un'idea me l'ero fatta e l'avevo minimamente espressa

e quindi come evitarlo.

eh ma sono sempre dietro a reiventare le ruote pero'...
:P

Verifica la riga che Firefox ti segnala. Metti un alert. Almeno i
fondamentali, vedi di farli.

a dire il vero l'avevo fatto

Se nonostante questo ti sfugge il
nocciolo della questione ne riparliamo.

ho tratto queste mie conclusioni:
l'ogettino xhr sta "lavorando" e non vorebbe essere disturbato, non riesce
a fare 2 lavori alla volta diciamo...
allora la prima idea che mi è venuta è stata la seguente: ammesso che non
esistesse niente che lo fermasse e lo rendesse riutilizzabile, gli cabio
sotto il culo l'onreadystatechange mettendogli una funzione vuota ed eseguo
la richiesta con un nuovo oggetto xhr
poi è venuto fuori che c'è un metodo chiamata abort() che dovrebbe
interrompere l'esecuzione dell'oggetto che ha fatto open e in teoria il
gioco sarebbe dovuto essere fatto, io lo interrompevo e gli rifacevo una
nuova open, peccato che FF mi andava in errore (ora non mi ricordo più il
dove e il perchè...)
e quindi la soluzione che ho adottato è stata l'unione delle 2:

function async_get_request( query, callback )
{
var xmlhttp = getSingleXHR( );

// alert( query );
callback = callback || response_callback;

if( xmlhttp && query )
{
if( xmlhttp.readyState != 0 && xmlhttp.readyState != 4 )
{
xmlhttp.onreadystatechange = function( evt ) { };
if( typeof xmlhttp.abort != 'undefined' )
xmlhttp.abort( );
xmlhttp = getSingleXHR( 1 );
}
xmlhttp.open( "GET", 'index.php?s=' + ( new Date( ) ).getTime( ) +
Math.random( ) + '&' + query, true );
xmlhttp.setRequestHeader( "If-Modified-Since", "Sat, 11 Jan 1977
00:00:00 GMT" );

xmlhttp.onreadystatechange = function( evt )
{
var xmlhttp = getSingleXHR( );

if( xmlhttp.readyState == 4 )
{
if( xmlhttp.status == 200 )
callback( xmlhttp.responseText );
else
alert( "Error; status = " + xmlhttp.status );
}
}

xmlhttp.send( null );
}
}

dove devi perdonarmi l'approccio non oop, però l'idea dovrebbe rimanere
analoga e dove getSingleXHR restituisce sempre la stessa istanza
dell'oggetto xhr a meno che non venga forzato a crearne una nuova (passando
un parametro a 1) e passare da quell'istante la "nuova"...
ah, già che c'ero ho evitato la chiusura sull'oggetto xhr, ma non ho potuto
fare nienete per il riferimento della funzione, che pero' essendo appunto
il riferimento di una funzione, forse non genera una chiusura, boh...

Gli approcci in tal senso
possono essere diversi.
E ne avevamo già discusso in questo NG, ripeto, almeno una volta.

mi sono salvato un link che forse potrebbe essere la volta di cui parli,
appena posso domani ci darò un'occhiata

Ciao e grazie

On Wed, 5 Dec 2007 00:01:11 +0100, Ugo wrote:

L'hai già fatto sicuramente altre volte di aggiungere una in modo
dinamico una proprietà ad un oggetto:

var MyObj = {};
MyObj.myprop = "123";

ma qui lo sto facendo con un'istanza

Scusa, eh, ma qui non lo fai comunque con un'istanza?

function MyFun(){};

MyFun.myprop = "123";

O_O
ignoravo che si potesse fare questa cosa

Ah, Santa Pazienza... Se anche tu l'avessi ignorato fin'ora, non te
l'avevo forse scritto qui:

<news:1jlwd2ennjfj0.dlg (AT) ID-171124 (DOT) news.individual.net>

Che una funzione *è* un oggetto?

Aaah, ancora non ci siamo!

eh, ci avrei giocato le palle

Mio nonno mi ha insegnato ad evitare di scommettere, soprattutto a non
scommettere MAI i gioielli di famiglia.

Cercare su Google ti dovrebbe già fornire parecchie informazioni,
ma anche un *minimo* di debugging sul tuo codice, ti dovrebbe già
chiarire cos'è che va in errore e perché,

mah, un'idea me l'ero fatta e l'avevo minimamente espressa

Non è un'idea che ti devi fare; devi solamente analizzare le prove. Le
prove non mentono mai (come direbbero in "siesai", ed ho pure fatto la
rima :P).

e quindi come evitarlo.

eh ma sono sempre dietro a reiventare le ruote pero'...
:P

Qui il discorso è diverso: ancora alla ruota non ci sei arrivato, stai
cercando di comprendere appieno la necessità che poi ti porterà forse,
a reinventare la ruota.

Verifica la riga che Firefox ti segnala. Metti un alert. Almeno i
fondamentali, vedi di farli.

a dire il vero l'avevo fatto

Se l'hai fatto, dove sono i risultati?

Se nonostante questo ti sfugge il
nocciolo della questione ne riparliamo.

ho tratto queste mie conclusioni:

Hai tratto le conclusioni prematuramente.

l'ogettino xhr sta "lavorando" e non vorebbe essere disturbato, non riesce
a fare 2 lavori alla volta diciamo...

Questa è la tua conclusione, che NON corrisponde ai fatti.
Il browser va in errore per un motivo. E tale motivo è ben esposto nel
messaggio di errore. Tu questo passaggio l'hai bellamente ignorato; ti
sei concentrato sull'effetto e non sulla causa.
Effetto che a un essere umano, può sembrare qualcosa tipo "l'oggettino
xhr sta lavorando e non vuole essere disturbato"; ma ovviamente JS non
ragiona di certo in questi termini.

[cut]

dove devi perdonarmi l'approccio non oop,

Beh, te lo perdono anche... Non l'avrei fatto se tu lavorassi alle mie
dirette dipendenze; ma dato che non è così, non è un mio problema.

JS è un linguaggio OOP prototype-based: se ci sviluppi in tale ottica,
allora ne beneficerà il tuo lavoro.

dell'oggetto xhr a meno che non venga forzato a crearne una nuova (passando
un parametro a 1) e passare da quell'istante la "nuova"...

Non commento. :P

ah, già che c'ero ho evitato la chiusura sull'oggetto xhr, ma non ho potuto
fare nienete per il riferimento della funzione, che pero' essendo appunto
il riferimento di una funzione, forse non genera una chiusura, boh...

La funzione l'hai definita all'interno di altra, quindi è una closure.

mi sono salvato un link che forse potrebbe essere la volta di cui parli,
appena posso domani ci darò un'occhiata

Ciao e grazie

De nada.

--
~ "Ciò che il cuore conosce oggi, la testa comprenderà domani"
(Seneca)

e quindi come evitarlo.

eh ma sono sempre dietro a reiventare le ruote pero'...
:P

Qui il discorso è diverso: ancora alla ruota non ci sei arrivato, stai
cercando di comprendere appieno la necessità che poi ti porterà forse,
a reinventare la ruota.

è vero

Verifica la riga che Firefox ti segnala. Metti un alert. Almeno i
fondamentali, vedi di farli.

a dire il vero l'avevo fatto

Se l'hai fatto, dove sono i risultati?

allora i risultati sono i seguenti, in effetti dopo uno studio un po' più
approfondito della cosa e dopo avergli messo alert avvunque (evitiamo
volgarità
Chissa' quante cose mi correggerai :|

per FF gli stati intermedi allo 0 (uninitialized) e al 4 (complete) sono
sacri, cioè tentativi di leggere lo status, rispedire header di un nuovo
messaggio e/o sperirlo proprio, lo fanno andare in errore perchè non viene
invocato un abort del messaggio come invece sembra che accada con ie in
automatico...
ma il bello deve ancora venire, se si lancia l'abort() l'oggetto va in
readyState = 4 (il chè potrebbe avere anche senso) pero' sollevando
un'eccezione meravigliosa rispetto al readyState = 4 di quando viene
terminata "normalmente", infatti la proprietà status in questo caso non è
accessibile similmente agli stati intermedi di cui si parlava prima
in conclusione bisogna gestire quest'eccezione evitando di trattare
readyState = 4 come si farebbe nei casi di no-abort().
E il bello non è ancora arrivato, mi sembra di aver capito che FF, finchè
non invia quel readyState = 4 a seguito dell'abort() non permette l'invio
di un nuovo msg analogamente ai casi precedenti, quindi se si vuole
sovraporre una nuova richiesta ignorando la precedente, credo che
bisognerebbe agire direttamente all'interno dell'onreadystatechange che in
teoria si potrebbe cambiare prima di evocare l'abort
Insomma che ci ho perso la mattina e forse mi sono un po' più chiarito
l'idee, pero' non sono riuscito a fare niente di meglio di quello fatto
inconsapevolmante ieri e cioè: anullare l'onreadystatechange evocare
l'abort e utilizzare una nuova istanza dell'oggetto XHR permettendo al
precedente di impegare quei millesimi di secondi a terminare e/o a fare
quello che vuole...

Non nascondo che arrivato a questo punto mi piacerebbe riuscire ad evitare
il riistanziamento che sono sicuro essere evitabile, ma avrei bisogno di
una dritta, perchè sono altrettanto sicuro che mi sono perso qualcosa...


ciao
aspetto le tue correzioni
fiducioso che tu mi dia anche 2 righe di codice :P

On Thu, 6 Dec 2007 00:11:37 +0100, Ugo wrote:

Verifica la riga che Firefox ti segnala. Metti un alert. Almeno i
fondamentali, vedi di farli.

a dire il vero l'avevo fatto

Se l'hai fatto, dove sono i risultati?

allora i risultati sono i seguenti, in effetti dopo uno studio un po' più
approfondito della cosa e dopo avergli messo alert avvunque (evitiamo
volgarità
Chissa' quante cose mi correggerai :|

[stacut]

Da una lettura veloce, mi sembra che tu sia abbastanza fuori strada..

Ma chiediti questo: cos'è lo status? A cosa si riferisce la proprietà
omonima? Cos'è il readystate?
E quando viene invocato l'evento onreadystatechange? Gli unici motivi
per cui tu sia fuori strada, è che non ti sei risposto a domande come
queste.

Leggiti la reference dell'oggetto XMLHttpRequest, se hai dei dubbi.

per FF gli stati intermedi allo 0 (uninitialized) e al 4 (complete) sono
sacri, cioè tentativi di leggere lo status,
rispedire header di un nuovo
messaggio e/o sperirlo proprio, lo fanno andare in errore

No, non direi proprio. E c'è anche un post recentissimo che smentisce
questa tua affermazione.

ma il bello deve ancora venire, se si lancia l'abort() l'oggetto va in
readyState = 4 (il chè potrebbe avere anche senso) pero' sollevando
un'eccezione meravigliosa

Non è questo che solleva un'eccezione. Scritta in questo modo, la tua
è un'affermazione errata.
E' il tuo codice ad esser sbagliato, a contenere un errore di logica,
ed è tale errore a sollevare l'eccezione.
Questo ti è stato chiaramente detto da Firefox, nell'error console.

terminata "normalmente", infatti la proprietà status in questo caso non è
accessibile similmente agli stati intermedi di cui si parlava prima

Se mi dici queste cose, ti consiglio davvero una lettura approfondita
alla reference dell'oggetto XMLHttpRequest di Gecko.

Ti rinnovo anche il mio consiglio di cercare sul newsgroup, visto che
questa problematica fu discussa già in passato, e anche in modo molto
approfondito, se la mia memoria non m'inganna.

ciao
aspetto le tue correzioni
fiducioso che tu mi dia anche 2 righe di codice :P

Codice per cosa? Qui il problema è di conoscenza e di logica, non vi
è alcun codice da scrivere, c'è solo da capire.

--
~ "Io ho fatto questo, dice la mia memoria
Io non posso aver fatto questo, dice il mio orgoglio.
Alla fine, è la memoria ad arrendersi." (Nietzsche)