# $.post. Asynchron. Wie am saubersten auf Antwort warten?



## jeipack (23. April 2013)

Hi


```
function test() {
  $.post("blah.php", { ID: "blah" }).done(function(data) {
    doSomethingAfterAnswer();
  }
}
```
Ich habe folgende Funktion, die ein POST Request an blah.php schickt und bei Antwort etwas macht.
Die echte Funktion ist natürlich um einiges grösser.

Nun ist es so, dass ich die Funktion von aussen aufrufe und zwingend wissen muss wann sie fertig ist. Etwa so:

```
function myStuff() {
  test();
  //Mach folgendes erst wenn alle POST Requests in test durch sind
  doStuff();
}
```

Mir fallen unschöne Konstrukte ein, wo ich im done-Teil des Post-Aufrufs eine Variable setze und dann in meiner zweiten Funktion  immer wieder auf diese Variable prüfe bis diese richtig gesetzt ist. Irgendwie so:


```
postdone=true:

function test() {
  postdone=false;
  $.post("blah.php", { ID: "blah" }).done(function(data) {
    doSomethingAfterAnswer();
    postdone=true;
  }
}


function myStuff() {
  test();
  while(!postdone) {
    //doNothing -> Wie reagiert ein Browser bei so einer Schleife? Eine Sleep-Funktion gibt es in JS ja nicht
  }
  doStuff();
}

//oder mit setInterval prüfen?
intervalId=0;
function myStuff() {
  test();
  intervalId = window.setInterval("readyToDoStuff()", 1000);
}

function readyToDoStuff() {
  if(postdone) {
    doStuff();
    window.clearInterval(intervalId);
  }
}
```

Ich denke, das mit dem Interval ist am schönsten (Allerdings noch nicht getestet ob es überhaupt so funktioniert). Aber gibt es dafür wirklich keine schönere Variante?


----------



## CPoly (23. April 2013)

Einfach von außen als Parameter eine Funktion übergeben.

Edit: Oder das Promise von test() zurückgeben lassen.


```
function test() {
  var promise = $.post("blah.php", { ID: "blah" });

  promise.done(function(data) {
    doSomethingAfterAnswer();
  };

  return promise;
}

function myStuff() {
  test().done(function() {
    //Mach folgendes erst wenn alle POST Requests in test durch sind
    doStuff();
  });
}
```

Und falls es mehrere requests werden, dann warte mittels http://api.jquery.com/jQuery.when/ darauf (http://api.jquery.com/jQuery.when/#example-0).


----------



## jeipack (23. April 2013)

Den Postrequest einfach als Returnvalue. Daran habe ich gar nicht dran gedacht. Cool.

Nun ist es so, dass in der test() Funktion mehrere asynchrone POST Requests abgesetzt werden. Soll ich die am besten in ein Array stecken und dieses zurück geben und dann mit when drauf warten:

```
var requests=new Array(); //Unnötig, aber so sieht man besser dass es sich um ein Array handelt
requests =  test(); //mehrere $.post -Requests
$.when(requests) //Weiss nicht ob das einfach so geht, hab noch zu wenig mit Arrays gemacht
//respektive
$.when(requests[0], requests[1], requests[n]) //Ansonsten halt so
.then(doStuff());
```

In etwa so?


----------



## CPoly (23. April 2013)

Ja das sollte so gehen. Probiers doch aus 

Besser noch: du gibst einfach das Ergebnis von "$.when" aus "test()" zurück. Der Aufrufer muss nicht wissen, wie viele Requests du dort machst.


----------



## jeipack (23. April 2013)

Ich glaube das würde dann nicht klappen.
(Klar, ich sollte jetzt testen und nicht weiter theoretisieren - Testergebnisse werden noch kommen)

when hat ja keinen returnvalue. Und so wie ich das verstehe unterbricht der Aufruf von when auch nicht den "Thread", sondern läuft asynchron.

also sowas wie:

```
function test() {
  var request = $.post(...);
  $.when(request).done(
    return "YEAH";
  );
  return "NOO:(";
}
```
Die Funktion wird denke ich NOO zurück geben. Wird noch getestet und Ergebnis hier geposted. Aber heute komm ich glaub ich nicht mehr dazu.


----------

