AJAX mehrere Requests parallel laufen lassen und Status abfragen

[madhippie]

Hallo,

ich habe da mal eine Verständnisfrage zum Thema Ajax.
Ich befasse mich seit heute morgen mit dem XMLHttpRequest Objekt und komme bei Folgendem nicht weiter:

    function handle_response() {  
  
  
            alert(client.readyState);  
  
    }  
  
  
    var url = "http://example.com";  
    var name = "test";  
  
  
    //Create XML String  
  
    var services = new Array("http://blogsearch.google.com/ping/RPC2", "http://api.moreover.com/ping" );  
  
    for (var i = 0; i < services.length; i++) {  
  
        var param = "name=" + name + "&url=" + url + "&service=" + services[i];  
        var client = new XMLHttpRequest();  
        client.onreadystatechange = handle_response();  
  
        client.open( "POST", "/pingtool/ping_ixr.php", false);  
  
        client.setRequestHeader("Content-Type", "application/x-www-form-urlencoded")  
        client.setRequestHeader("Content-Length", param.length );  
        client.setRequestHeader("Connection", "close");  
  
  
        client.send(param);  
  
  
    } 

Es wird lediglich einmalig der readyState 0 ausgegeben. Ich liege doch aber mit meiner Vermutung richtig, dass die For Schleife erst weiter durchlaufen wird wenn der erste Request beendet ist, oder?

Für die Zukunft plane ich, die Pings asynchron zu starten - finde aber keine Antwort auf die Frage wie ich dann den Status für die einzelnen Requests abfragen kann. Hab da schon was probiert, das würde ich dann aber erst posten nachdem ich eine Lösung für o.g. Problem habe...

Ich danke Euch im Voraus für Eure Zeit und Hilfestellungen.

Beste Grüße,
madhippie.

[madhippie]

Kleiner Nachtrag:

Ich hab's gerade nochmal in anderen Browsern probiert und es funktioniert.
Im FF allerdings schmeißt immer den gleichen readyState aus.
FireBug meldet aber keinerlei Probleme.

[fastix®]

Moin!

Du kannst natürlich nicht immer das selbe Objekt abfragen, Du kannst aber mehrere Objekte in einem Array aufbauen:

  
var clients=new Array();  
for  (i = 0; i < services.length; i++) {  
        clients[i] = new  XMLHttpRequest();  
        var param = "name=" + name + "&url=" + url + "&service=" + services[i];  
        cclients[i].onreadystatechange = handle_response();  
        clients[i].open( "POST", "/pingtool/ping_ixr.php", false);  
        clients[i].setRequestHeader("Content-Type", "application/x-www-form-urlencoded")  
        clients[i].setRequestHeader("Content-Length", param.length );  
        clients[i].setRequestHeader("Connection", "close");  
        clients[i].send(param);  
}  

und dann weiterverarbeiten...

Was willst Du eigentlich machen? Spammen?

MFFG (Mit freundlich- friedfertigem Grinsen)

fastix

[madhippie]

Moin!

Moin fastix!

ich möchte NATÜRLICH nicht spammen ;)

Ich bin dabei einen Pingservice für Webblogs zu schreiben.
Da gibt's denn ein Array mit verschiedenen Pingdiensten.

Die ping_ixr.php sendet dann eben an die aktuelle Service URL die zu pingende Seite mit Titel.

var clients=new Array();  
for  (i = 0; i < services.length; i++) {  
        clients[i] = new  XMLHttpRequest();  
        var param = "name=" + name + "&url=" + url + "&service=" + services[i];  
        cclients[i].onreadystatechange = handle_response();  
        clients[i].open( "POST", "/pingtool/ping_ixr.php", false);  
        clients[i].setRequestHeader("Content-Type", "application/x-www-form-urlencoded")  
        clients[i].setRequestHeader("Content-Length", param.length );  
        clients[i].setRequestHeader("Connection", "close");  
        clients[i].send(param);  
}

So habe ich das dann auch schon probiert. Allerdings kriege ich, wenn ich die asynchronous Flag auf true setze, dann immer dubiose Ausgaben der handle_response() - bzw. Wird da readyState immer der Wert des aktuellen clients sein. Ich probiere gerade nochmal ein bischen rum.

Vielen Dank für Deine schnelle Antwort!

Grüße,
madhippie.

[hotti]

Moin!

Du kannst natürlich nicht immer das selbe Objekt abfragen, Du kannst aber mehrere Objekte in einem Array aufbauen:

Genau, -> mehrere XHR Objekte laufen lassen. Jeder Request kriegt einen Tag als Parameter mit und auch die Response wird getagged (im HTTP-Header), damit die wieder zusammengeführt werden können (einfach durchnumerieren).

Es ist jedoch so, dass die Browser, die ich da so schon getestet haben, stets auf die Response warten, bevor die einen neuen Request rausschicken. Es geht mit den heutigen Browsern also nur seriell, nicht jedoch parallel und auch nicht asynchron mehrere asynchrone Requests rauszuschicken; wobei jeder einzelne Request an sich schon asynchron läuft.

Den Status Deiner Versuchsanordnung kannst Du jedoch auf jeden Fall abfragen, Du weißt ja, wieviele Requests rausgehen sollen und jedes Object liefert eine Response ab; kein Problem, damit eine Gauge ('Prozentmeter') zu bauen.

Nurmalso als Ausblick: Wenn die Browser mitspielen würden, könntest Du eine Übertragungsstrecke auf diese Weise richtig asynchron nutzen, mit Daten sozusagen voll hauen, dichteste Packung: nicht hintereinander, nicht nebeneinander, sondern eben asynchron. Der wesentliche Unterschied zwischen parallel/seriell <=> asynchron ist, dass die Reihenfolge und die Ordnung der Datenpakete während der Übertragung aufgehoben ist. So funktioniert prinzipiell auch ADSL, die Synchronisation wird erst am Terminator wieder hergestellt.

Viel Spaß beim Entwickeln,
Hotti

[Der Martin]

Hallo,

Genau, -> mehrere XHR Objekte laufen lassen. Jeder Request kriegt einen Tag als Parameter mit und auch die Response wird getagged (im HTTP-Header), damit die wieder zusammengeführt werden können (einfach durchnumerieren).

warum das? Jeder Request löst, wenn die Response irgendwann eintrifft, seinen eigenen onreadystatechange-Handler auf. Damit ist die Zuordnung schon eindeutig hergestellt.

Es ist jedoch so, dass die Browser, die ich da so schon getestet haben, stets auf die Response warten, bevor die einen neuen Request rausschicken.

Ich weiß nicht, was du getestet hast und unter welchen Bedingungen, vermute aber eher, dass die Browser sich hier einfach nur an das "Fair-Use"-Limit halten, das maximal 8 parallele HTTP-Requests vorsieht, davon maximal 2 von demselben Server.

Der wesentliche Unterschied zwischen parallel/seriell <=> asynchron ist, dass die Reihenfolge und die Ordnung der Datenpakete während der Übertragung aufgehoben ist.

Aber nicht die Reihenfolge der Datenpakete *eines* Requests bzw. der zugehörigen Response - abgesehen davon, dass das IP-Protokoll grundsätzlich aus keine feste Reihenfolge der Pakete garantiert, und diese Reihenfolge erst durch das darüberliegende TCP sichergestellt wird.
Asynchron heißt hier lediglich, der Request wird "irgendwann" gesendet, und die Antwort trifft "irgendwann" ein, während die Anwendung (hier: das Script) in dieser Zeit weiterläuft und sich anderen Tätigkeiten widmen kann. Asynchron heißt, dass das Zeitverhalten nicht vorhersagbar ist.

So funktioniert prinzipiell auch ADSL, die Synchronisation wird erst am Terminator wieder hergestellt.

Hä?

Ciao,
 Martin

[hotti]

hi,

warum das? Jeder Request löst, wenn die Response irgendwann eintrifft, seinen eigenen onreadystatechange-Handler auf. Damit ist die Zuordnung schon eindeutig hergestellt.

Ja. Eben die Zuordnung zu einem Request und einer Response. Hier jedoch geht es um mehrere Requests und folgerichtig auch um mehrere onreadystatechange's und nicht nur um Einen onreadystatechange.

Asynchron heißt hier lediglich, der Request wird "irgendwann" gesendet, und die Antwort trifft "irgendwann" ein, während die Anwendung (hier: das Script) in dieser Zeit weiterläuft und sich anderen Tätigkeiten widmen kann. Asynchron heißt, dass das Zeitverhalten nicht vorhersagbar ist.

Hier geht es darum, mehrere asynchrone Requests asynchron rauszuschicken. Nicht nacheinander, eventuell parallel, am besten asynchron.

Hotti

[Der Martin]

Hallo,

warum das? Jeder Request löst, wenn die Response irgendwann eintrifft, seinen eigenen onreadystatechange-Handler auf. Damit ist die Zuordnung schon eindeutig hergestellt.
Ja. Eben die Zuordnung zu einem Request und einer Response. Hier jedoch geht es um mehrere Requests und folgerichtig auch um mehrere onreadystatechange's und nicht nur um Einen onreadystatechange.

eben drum - für jeden Request nimmt man, wenn man sich nicht selbst ins Knie schießen will, ein eigenes XHR-Objekt. Damit ist die Zuordnung perfekt, egal ob ich einen asynchronen Request habe oder drei Dutzend.

Ciao,
 Martin

[madhippie]

Hallo,

warum das? Jeder Request löst, wenn die Response irgendwann eintrifft, seinen eigenen onreadystatechange-Handler auf. Damit ist die Zuordnung schon eindeutig hergestellt.
Ja. Eben die Zuordnung zu einem Request und einer Response. Hier jedoch geht es um mehrere Requests und folgerichtig auch um mehrere onreadystatechange's und nicht nur um Einen onreadystatechange.

eben drum - für jeden Request nimmt man, wenn man sich nicht selbst ins Knie schießen will, ein eigenes XHR-Objekt. Damit ist die Zuordnung perfekt, egal ob ich einen asynchronen Request habe oder drei Dutzend.

Ciao,
Martin

Moin Martin,

also erstmal vielen Dank an Euch 3 für die vielen Denkanstöße und Tipps :)

Also ich bin zwar der Noob hier aber ich stehe vor folgendem Problem, wenn das mein Fehler ist gerne verbessern:

In der handle_response() werfe ich, bei nur einem Request z.B. client.responseText aus. So schön so gut. In der o.g. FOR-Schleife müsste ich aber client[i].responseText auswerfen. Da aber bei asynchronem Modus(?) die FOR-Schleife nicht "aufgehalten" wird ist beim readyState i aber schon ein ganz anderer Wert.

Grüße,
madhippie.

EDIT: Hab gerade gesehen, dass man der handle_response() natürlich einfach das i übergeben kann. Dank an hotti!

[madhippie]

Moin!

Moin!

Du kannst natürlich nicht immer das selbe Objekt abfragen, Du kannst aber mehrere Objekte in einem Array aufbauen:

Genau, -> mehrere XHR Objekte laufen lassen. Jeder Request kriegt einen Tag als Parameter mit und auch die Response wird getagged (im HTTP-Header), damit die wieder zusammengeführt werden können (einfach durchnumerieren).

Wie meinst Du das genau?
Eine Art "Zählvariable" im Header mit übertragen um dann bei Antwort die Antwort dem ursprünglichen Request zuordnen zu können? Was würde ich da setzen?

Es ist jedoch so, dass die Browser, die ich da so schon getestet haben, stets auf die Response warten, bevor die einen neuen Request rausschicken. Es geht mit den heutigen Browsern also nur seriell, nicht jedoch parallel und auch nicht asynchron mehrere asynchrone Requests rauszuschicken; wobei jeder einzelne Request an sich schon asynchron läuft.

Schade, dass einem die Technik da so im Weg steht. Bin extra auf AJAX ausgewichen, da ich mit PHP leider in der Tat nur Anfrage auf Anfrage duchführen kann und nun steh ich vor dem Gleichen Problem...(ist aber schon wesentlich performanter).

Den Status Deiner Versuchsanordnung kannst Du jedoch auf jeden Fall abfragen, Du weißt ja, wieviele Requests rausgehen sollen und jedes Object liefert eine Response ab; kein Problem, damit eine Gauge ('Prozentmeter') zu bauen.

Das versuch' ich mir gerade zusammen zu basteln :)

Nurmalso als Ausblick: Wenn die Browser mitspielen würden, könntest Du eine Übertragungsstrecke auf diese Weise richtig asynchron nutzen, mit Daten sozusagen voll hauen, dichteste Packung: nicht hintereinander, nicht nebeneinander, sondern eben asynchron. Der wesentliche Unterschied zwischen parallel/seriell <=> asynchron ist, dass die Reihenfolge und die Ordnung der Datenpakete während der Übertragung aufgehoben ist. So funktioniert prinzipiell auch ADSL, die Synchronisation wird erst am Terminator wieder hergestellt.

Ich freue mich auf diesen Moment!

Viel Spaß beim Entwickeln,
Hotti

Danke - den hab' ich gerade!

Vielen Dank für die Denkanstöße!

Beste Grüße,
madhippie.

[hotti]

hi,

Genau, -> mehrere XHR Objekte laufen lassen. Jeder Request kriegt einen Tag als Parameter mit und auch die Response wird getagged (im HTTP-Header), damit die wieder zusammengeführt werden können (einfach durchnumerieren).

Wie meinst Du das genau?
Eine Art "Zählvariable" im Header mit übertragen um dann bei Antwort die Antwort dem ursprünglichen Request zuordnen zu können? Was würde ich da setzen?

Im Request setzt Du einen Parameter, name=nummer => tag=1 oder entity=2 o.ä. Für die Response, die i.d.R. mit PHP oder Perl erstellt wird, gibtst Du einen eigenen HTTP-Header mit rein, der mit dem XHR-Objekt abgefragt werden kann. Ich habe für sowas mal den Etag (HTTP-Header) missbraucht, besser ist jedoch ein eigener Header, das steht Dir völlig frei.

Beispiele zur Abfrage eines Headers:
hash.etag = xhr.getResponseHeader("ETag");
hash.type = xhr.getResponseHeader("Content-Type");

Hinweis: Wenn Du einen Header abfragst, den ist nicht gibt, meldet die Konsole einen Fehler. Stelle also vorher fest, ob der Header abgefragt werden soll (falls Du eine eigene Library aufbaust).

Das Tagging im HTTP-Header zu machen, hat den Vorteil, dass die eigentliche Response (Message-Body, JSON, XML usw.) von der "Technik" getrennt ist.

Hotti

[madhippie]

Beispiele zur Abfrage eines Headers:
hash.etag = xhr.getResponseHeader("ETag");
hash.type = xhr.getResponseHeader("Content-Type");

Hinweis: Wenn Du einen Header abfragst, den ist nicht gibt, meldet die Konsole einen Fehler. Stelle also vorher fest, ob der Header abgefragt werden soll (falls Du eine eigene Library aufbaust).

Das Tagging im HTTP-Header zu machen, hat den Vorteil, dass die eigentliche Response (Message-Body, JSON, XML usw.) von der "Technik" getrennt ist.

Hotti

Moin Hotti,

alles klar ich werd's morgen mal ausprobieren und Rückmeldung geben!
Vielen lieben Dank.

BTW: gibt's eine gescheite Möglichkeit die Threads zu abonnieren und zu lesen? Ich verliere hier immer komplett die Übersicht wer-wo-wem antwortet :)

[Der Martin]

Hallo,

BTW: gibt's eine gescheite Möglichkeit die Threads zu abonnieren und zu lesen?

jein ... du kannst als Bookmark speichern, genügt das nicht?

Ich verliere hier immer komplett die Übersicht wer-wo-wem antwortet :)

Und das bei der übersichtlichen Darstellung, wie sie besser fast nicht sein könnte ...

Wenn du dich registrierst, kannst du das komplette Erscheinungsbild, die Darstellungsart, die Sortierfolge alles nach deinen Wünschen anpassen, deine eigenen Posting hervorheben lassen, gelesene von ungelesenen Beiträgen unterscheiden, sogar ein komplett eigenes Stylesheet anwenden ...

So long,
 Martin

[madhippie]

Hallo,

BTW: gibt's eine gescheite Möglichkeit die Threads zu abonnieren und zu lesen?

jein ... du kannst als Bookmark speichern, genügt das nicht?

Ich verliere hier immer komplett die Übersicht wer-wo-wem antwortet :)

Und das bei der übersichtlichen Darstellung, wie sie besser fast nicht sein könnte ...

Wenn du dich registrierst, kannst du das komplette Erscheinungsbild, die Darstellungsart, die Sortierfolge alles nach deinen Wünschen anpassen, deine eigenen Posting hervorheben lassen, gelesene von ungelesenen Beiträgen unterscheiden, sogar ein komplett eigenes Stylesheet anwenden ...

So long,
Martin

Ich erkenne das Problem, hab das Bookmark auf einen bestimmten Beitrag gesetzt - da war die Navi oben nicht da :)

Und nach dem netten Empfang wird sich selbstverständlich sofort registriert!

Grüße,
madhippie.

[madhippie]

Moin,

also ich hab nochmal etwas rumgespielt und im Grunde funktioniert, zumindest auf AJAX Seite alles so wie ich es mir vorstelle allerdings hab ich da noch ein kleines Problem welches ich mir nicht erklären kann. Mein Code sieht nun wie folgt aus:

  
	function meincallback(i) {  
		  
		alert(i);  
		  
		 if(client[i].readyState == 4){  
  
			 if(client[i].status == 200){  
  
				 	alert(client[i].responseText);  
  
			}  
  
		 }  
			  
	}  
  
		  
	var url = "http://example.com";  
	var name = "test";  
	  
	  
	//Create XML String  
	var client = new Array();  
	var services = new Array("http://blogsearch.google.com/ping/RPC2", "http://api.moreover.com/ping");  
	  
	for (var i = 0; i < services.length; i++) {  
		  
  
		  
		  
		var param = "name=" + name + "&url=" + url + "&service=" + services[i];  
  
		client[i] = new XMLHttpRequest();  
		  
		client[i].onreadystatechange = function() { meincallback(i); };		  
		client[i].open( "POST", "/pingtool/ping_ixr.php", true);  
		client[i].setRequestHeader("Content-Type", "application/x-www-form-urlencoded");  
		client[i].setRequestHeader("Content-Length", param.length );  
		client[i].setRequestHeader("Connection", "close");  
				  
		client[i].send(param);  
		  
	  
	}  

Ihr seht oben im Callback das alert(i); Beim Durchlaufen wirft das Skript dann folgendes aus:

0
0
0
0
Response.Text vom ersten Durchlauf
0 (?)
Response.Text vom ersten Durchlauf(?)

und das gleiche Schema dann beim 2. Durchlauf.

Wenn ich das alert(i); rausnehme wird gar nichts ausgegeben und die FireBug Konsole meldet, dass die Anfragen korrekt durchgeführt wurden und schmeißt dahinter 4x "Error: client[i] is not defined" aus.

Sehe ich den Wald vor lauter Bäumen nicht?

Beste Grüße und vielen Dank im Voraus,
madhippie

[Struppi]

  client[i].onreadystatechange = function() { meincallback(i); };		  

Welchen Wert hat i, wenn dieser Event aufgerufen wird?

Struppi.

[madhippie]

Welchen Wert hat i, wenn dieser Event aufgerufen wird?

Moin Struppi,

Beim ersten Durchlauf 0 und beim zweiten 1.
Im Opera funktioniert auch alles super, nur im FF tritt dieses Verhalten auf.

Grüße,
madhippie.

[Struppi]

Welchen Wert hat i, wenn dieser Event aufgerufen wird?

Beim ersten Durchlauf 0 und beim zweiten 1.

Nein, das i wird in der Schleife ja nicht irgendwie gespeichert, wenn der Event auftritt hat i den Wert: services.length + 1

Im Opera funktioniert auch alles super, nur im FF tritt dieses Verhalten auf.

Das kann nicht stimmen, Opera verhält sich wie alle anderen Browser auch.

Struppi.

[madhippie]

Nein, das i wird in der Schleife ja nicht irgendwie gespeichert, wenn der Event auftritt hat i den Wert: services.length + 1

Ja da hast Du Recht, entschuldige ich stehe gerade wirklich auf dem Schlauch :)

Gibt es denn eine gescheite Möglichkeit den übergebenen Wert fix zu machen, bzw. eine eindeutige Zuordnung herzustellen?

Danke und beste Grüße,
madhippie.

[madhippie]

Heureka ich denke ich hab's :)

Aus client[i].onreadystatechange = function() { meincallback(client[i]); }; wird client[i].onreadystatechange = function() { meincallback(this); };

und die meincallback() sieht nun so aus:

  
	function meincallback(q) {  
		  
	  
		  
		 if(q.readyState == 4){  
  
			if(q.status == 200){  
  
				 	alert(q.responseText);  
  
			} else {  
				  
				alert('Es konnte keine Verbindung hergestellt werden');  
				  
			}  
  
		 }  
		  
			  
	}  

Ist das eine elegante Lösung?

Beste Grüße,
madhippie.

[hotti]

hi,

client[i].onreadystatechange = function() { meincallback(i);

Dein Code ist nicht schön. Zum Überdenken, die callback()-Funktion gehört woandershin. Also: xhr.onreadystatechange ruft eine Funktion, in der geprüft wird, welcher readyState bzw. status vorliegt:

xhr.onreadystatechange = rx; // Empfangsfunktion, danke Struppi

  
   function rx(){  
      if(xhr.readyState == 4){  
          if(xhr.status == 200){  
            // hier hinein die custom callbackfunktion  
          }  
          else{  
            // Fehlerbehandlung  
          }  
      }  
   }  

Alles zusammen, siehe mein Post von gestern abend. Das Ajax-Geraffel ist dann überall gleich, lediglich die callback-Funktion ist anzupassen. Wg. Organisation v. JS und closures siehe auch die verlinkten Artikel von SELFHTML.

Hotti

[Struppi]

Es ist jedoch so, dass die Browser, die ich da so schon getestet haben, stets auf die Response warten, bevor die einen neuen Request rausschicken.

Dann hast du falsch getestet, das stimmt nicht.

Struppi.

[hotti]

Es ist jedoch so, dass die Browser, die ich da so schon getestet haben, stets auf die Response warten, bevor die einen neuen Request rausschicken.

Dann hast du falsch getestet, das stimmt nicht.

Jow, kann schon sein. Im Ergebnis dessen bin ich zu dem Schluss (vorerst) gekommen, dass es wenig Sinn macht, mit mehreren xhr-Objects zu arbeiten. Wenn Du magst, zeig mir ein online-Beispiel, was sinnvoll mit mehreren xhr-Objects abrbeitet, etwa um eine vorhandene Übertragungsstrecke performanter zu nutzen, ok?

Wg. meinem Umzug bin ich z.Z. ein bischen eingeschränkt, was das Programmieren betrifft. Vorrangig ist da z.B. eine Elektroninstallation und ein Haufen Drecksarbeit in der neuen Wohnung, die ist noch lange nicht fertig und letzte Nacht haben wir wiedermal im Hotel verbracht, weil wir kein Wasser hatten...

Viele Grüße von einem zukünftigen Nachbarn im Lkrs. Mainz-Bingen,
der Oppenheimer.

PS: Im Keller hab ich einen Schatz gefunden, ca. 20 Flaschen Wein, der Jüngste ist 35 Jahre alt. Nicht, dass ich da weg. der Mainzelmännchen Wachen aufstellen muss ;-)

[Struppi]

Dann hast du falsch getestet, das stimmt nicht.

Jow, kann schon sein. Im Ergebnis dessen bin ich zu dem Schluss (vorerst) gekommen, ...

Das ist etwas anderes, zumal es mit denen von Martin erwähnten Einschränkungen auch, je nach Browser, nicht unbedingt soviel performance bringt.

Es ging nur um die Aussage:" Es ist jedoch so, dass die Browser, die ich da so schon getestet haben, stets auf die Response warten, bevor die einen neuen Request rausschicken" - das ist nicht richtig.

Viele Grüße von einem zukünftigen Nachbarn im Lkrs. Mainz-Bingen,
der Oppenheimer.

Also doch Oppenheim, ich hoffe ihr habt die richtige Wahl getroffen. Ich weiß zwar nicht wie die Leut' in Oppenheim sind, aber an sich ist es hier schön.

PS: Im Keller hab ich einen Schatz gefunden, ca. 20 Flaschen Wein, der Jüngste ist 35 Jahre alt. Nicht, dass ich da weg. der Mainzelmännchen Wachen aufstellen muss ;-)

Für die Keller ist Oppenheim bekannt, der ganze Ort ist über z.T. zugeschüttete Keller verbunden. Ich bin aber eher profaner Biertrinker.

In meinem Keller hab' ich auch eine Flasche Wein gefunden. Ein '92 Amselfelder, vermutlich vom Plus x-) - ob der noch trinkbar ist bezweifle ich aber.

Struppi.

[hotti]

moin,

Es ging nur um die Aussage:" Es ist jedoch so, dass die Browser, die ich da so schon getestet haben, stets auf die Response warten, bevor die einen neuen Request rausschicken" - das ist nicht richtig.

Meine Tests vor einiger Zeit haben ergeben, dass die Reihenfolge der Responsen genauso ist, wie die Reihenfolge der Requests (mehrere xhr-Objects). Das kann Zufall sein, es kann aber auch so sein, dass der UA wartet. Meine Erwartung war die, dass die Responsen unabhängig voneinander eintrudeln. Wenn Du Lust hast, untersuche das mal genauer.

Für die Keller ist Oppenheim bekannt, der ganze Ort ist über z.T. zugeschüttete Keller verbunden. Ich bin aber eher profaner Biertrinker.

Tja, ich mache mir weder aus Bier, noch aus Wein was. Wenn ich richtigen Durscht habe, freue ich mich über ne Cola ;-)

In meinem Keller hab' ich auch eine Flasche Wein gefunden. Ein '92 Amselfelder, vermutlich vom Plus x-) - ob der noch trinkbar ist bezweifle ich aber.

Vermutlich mit erheblicher Restsüße, da besteht die Gefahr einer Nachgärung und die Flasche steht unter Druck. Kenntlich an einer etwaigen Trübung.

Oppenheimer (sind nette Leute)

[Struppi]

Es ging nur um die Aussage:" Es ist jedoch so, dass die Browser, die ich da so schon getestet haben, stets auf die Response warten, bevor die einen neuen Request rausschicken" - das ist nicht richtig.

Meine Tests vor einiger Zeit haben ergeben, dass die Reihenfolge der Responsen genauso ist, wie die Reihenfolge der Requests (mehrere xhr-Objects). Das kann Zufall sein, es kann aber auch so sein, dass der UA wartet. Meine Erwartung war die, dass die Responsen unabhängig voneinander eintrudeln. Wenn Du Lust hast, untersuche das mal genauer.

Das hatte ich bereits. Sie "trudeln" mehr oder weniger in zufälliger Reihenfolge unabhängig voneinander ein. Der Effekt ist natürlich kaum spürbar, wenn der Response bei allen Anfragen identisch ist. Aber ich habe grad mal 10 parallele Request an den localhost gesendet und in dieser Reihenfolge kamen sie an:
start
ready: 0
ready: 3
ready: 4
ready: 5
ready: 6
ready: 7
ready: 8
ready: 9
ready: 1
ready: 2

Du kannst das gerne auch mal testen: http://selfhtml.jstruebig.de/ajax_test.html (20 Request)

Für die Keller ist Oppenheim bekannt, der ganze Ort ist über z.T. zugeschüttete Keller verbunden. Ich bin aber eher profaner Biertrinker.

Tja, ich mache mir weder aus Bier, noch aus Wein was. Wenn ich richtigen Durscht habe, freue ich mich über ne Cola ;-)

Ach so, es ging um Durst :-D

In meinem Keller hab' ich auch eine Flasche Wein gefunden. Ein '92 Amselfelder, vermutlich vom Plus x-) - ob der noch trinkbar ist bezweifle ich aber.

Vermutlich mit erheblicher Restsüße, da besteht die Gefahr einer Nachgärung und die Flasche steht unter Druck. Kenntlich an einer etwaigen Trübung.

Das bereitet mir auch Sorge, aber die Flasche steht im Keller, da kann nicht viel passieren.

Oppenheimer (sind nette Leute)

hehe, weil du jetzt da bist, oder was? :-P

Struppi.

[hotti]

hi,

danke für Deine Tests. Interessant, ich werde das später mal wiederaufnehmen....

Oppenheimer (sind nette Leute)

hehe, weil du jetzt da bist, oder was? :-P

Ja, ne, is klar. Du kannst Dir gar nicht vorstellen, wie hilflos ich am Montag war, als mir der Meister sagte, dass meine Wasserleitung Schrott ist. Er und seine Firma haben mir dann ganz unbürokratisch und zeitnah einen Termin eingeräumt, die Wasserwerker herbeigeholt und von der Uhr bis ins Bad/Küche alles neu verlegt. Mann bin ich froh, jetzt läufts wieder (seit gestern mittag) und der neue Anschluss in der Wohnküche 1.OG steht mit Eckventil und Abflussrohr.

Elektrokabel, Koax und Cat-7-Kabel kann ich selbst verlegen, aber mit einer Wasserleitung bin ich hoffnungslos überfordert. Es lebe das Handwerk (Programmieren ist auch Handwerk)!

Viele Grüße,
Hotti

[hotti]

hi,

Du kannst das gerne auch mal testen: http://selfhtml.jstruebig.de/ajax_test.html (20 Request)

Cool!!! Das geht ja einwandfrei und auch mal (gottseidank) durcheinander. Genauso soll es sein. Danke Dir!

Oppenheimer

[fastix®]

Moin!

Es ist jedoch so, dass die Browser, die ich da so schon getestet haben, stets auf die Response warten, bevor die einen neuen Request rausschicken.

Auch wenn es mehrere verschiedene Server sind? Bei einem könnte ich mir das vorstellen, sonst müssten parallele Verbindungen genutzt werden (obwohl ja auch das geht(network.http.max-connections-per-server))

Gewissheit wird man wohl nur bekommen, wenn man die Programmierer der Browser fragt oder etwas dazu im Handbuch findet oder den Datenverkehr mit wireshark beaufsichtigt.

Ach so. Der "Callbackfunktion" "handle_response" sollte vielleicht noch übergeben werden, welcher Request denn fertig ist. Also:

clients[i].onreadystatechange = handle_response(i);

MFFG (Mit freundlich- friedfertigem Grinsen)

fastix

[hotti]

hi,

Ach so. Der "Callbackfunktion" "handle_response" sollte vielleicht noch übergeben werden, welcher Request denn fertig ist. Also:

clients[i].onreadystatechange = handle_response(i);

Logo, ein überschaubarer Code sollte es schon sein ;-)

Bisher war das für mich ausreichend:

  
// Erstelle XHR Objekt  
function mob(){  
	var mob = (window.XMLHttpRequest) ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP");  
	return mob;  
}  
  
// CompatMode  
// ajax core  
function ajaxRequest(hash){  
	var xhr = mob();  
  
	function rx(){  
		if(xhr.readyState == 4){  
			if(xhr.status == 200){  
				if(hash.headers){  
					hash.etag = xhr.getResponseHeader("ETag");  
					hash.type = xhr.getResponseHeader("Content-Type");  
				}			  
				hash.callback(xhr.responseText);  
			}  
			else{ hash.errstr = 'Server anwortet nicht'; }  
		}  
	}  
  
	if(hash.method == 'POST'){  
		xhr.open("POST", hash.url, true);  
		xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");  
		xhr.setRequestHeader("Content-length", hash.params.length);  
		xhr.setRequestHeader("Connection", "close");  
		xhr.send(hash.params);  
		xhr.onreadystatechange = rx;  
	}  
	else{  
		var url = hash.url + '?' + hash.params;  
		xhr.open("GET", url, true);  
		xhr.send(null);  
		xhr.onreadystatechange = rx;  
	}  
  
	return true;  
}  

Ein Req. => ein Objekt. Ein weiteres Object wird der Funktion ajaxRequest() übergeben, da steckt auch die callback() Funktion drin, die im <script> entsprechend angepasst werden muss. Grundgerüst und die entsprechenden Attribute für das angepasste Objekt:

  
        <script type="text/javascript">  
            var stat = {  
                callback: function(response){  
                  // Einbau Response im DOM  
                  // JSON oder eigene Struktur  
                },  
                call: function(){  
                    this.url = '/cgi-bin/perllog.cgi';  
                    this.params = 'x=y'  
                    this.method = 'POST';  
                    ajaxRequest(this);  
                }  
            }  
  
            stat.call();  
  
        </script>  
  

Hotti

[dedlfix]

Hi!

Ach so. Der "Callbackfunktion" "handle_response" sollte vielleicht noch übergeben werden, welcher Request denn fertig ist. Also:
clients[i].onreadystatechange = handle_response(i);

Wenn es sich bei handle_response() um eine Funktion handelt, die ein Funktionsobjekt zurückliefert, das dann zum Ereignis aufgerufen wird und sich um die Response kümmert, ist das so in Ordnung. Dann fände ich den Namen aber seltsam. Üblicherweise will man die Handler-Funktion nur dem Eventhandler zuweisen und nicht gleich dabei schon aufrufen und nur den Rückgabewert speichern. Zur individuellen Datenübergabe kann eine Closure verwendet werden. Siehe Artikel Organisation von JavaScripten, besonders die Abschnitte Object-Methoden in anderen Kontexten ausführen und Einführung in Closures ff.

Lo!

[madhippie]

Siehe Artikel Organisation von JavaScripten, besonders die Abschnitte Object-Methoden in anderen Kontexten ausführen und Einführung in Closures ff.

Lo!

Jo Danke Dir!

Les ich mir glatt mal durch :)

Grüße,
madhippie.