6

The setup

In a web application I 'm maintaining there are lots of AJAX calls to submit forms that go like this:

jQuery.post($form.attr("action"), $form.serialize())
    .always(commonProcessing)
    .done(function() {
        // the post succeeded, do something specific (e.g. close a dialog)
    });

The commonProcessing function looks for "well known" parts in the JSON response and takes appropriate action (the response may also include request-specific information). It reads something like this:

function commonProcessing(result, outcome) {
    switch (outcome) {
        case "success":
            if (result.notify) {
                // show a growl-style notification
            }
            else if (...) ;
            break;
        case "error":
            // show a generic "unexpected error" notification
            break;
    }
}

The problem

In many cases I 'd prefer to return an HTTP error code -- say 400 for a submitted form that has invalid data -- because, in addition to this being the natural order of things, it allows me to conveniently put the "successful request" code in a .done handler (if a 200 OK were returned instead then the content would be always parsed, but the .done handler would need to try and find out if this is an "error" or a "really OK" response). At the same time I want to respond to the request with specific information when an error occurs (for example the notify object can contain an error message that explains exactly what was wrong with the request).

The problem is that when an HTTP error code is returned, jQuery does not attempt to parse the response content, in which case the result argument is a jqXHR object instead of the typical parsed JSON.

Is there an elegant way of saying "I know that there was an error, but I also want you to parse the response content"? I could of course do $.parseJSON(result.responseText) since we 're talking about JSON, but that feels clumsy because it sidesteps all the nice jQuery code that sniffs the content type and does the parsing.

Improve this question
2
  • Is this for any error, or specifically 5xx? Commented Sep 28, 2012 at 16:13
  • Also, what is the actual error you get (in the error condition handler that is fired). Commented Sep 28, 2012 at 16:18

4 Answers 4

Reset to default
2

What about using a try/catch block of code?

try{ 
     var response = $.parseJSON(response) etc 
}
catch(error){ 
     console.log(error) //error handling here
}

That is what I use to account for the instances where the response is not in JSON format as expected but an error code of some sort. Apologies in advance if I have misunderstood the question!

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

This is in fact about what I 'm doing right now as a best practical approach. But ideally I 'd want to leverage existing jQuery functionality to automatically parse the response into an appropriate format, be it JSON or anything else that jQuery understands.
1

I don't think you can modify the jqXHR object to behave like that. Looking through the API (here) the closest thing that occurs to me that might solve your issue is the overrideMimeType() method. Something like: 

beforeSend: function(xhr){
    xhr.overrideMimeType("application/json; charset=UTF-8");
}

If you're looking to take control in a more fine-grained manner, why not implement the AJAX call manually and return the object you wish, in the format you need it?

Improve this answer

4 Comments

The MIME type is correctly sent by the server. The problem is that jQuery sees the HTTP 400 code and chooses not to touch the content (it simply makes it available as a string).
Yeah, I see what you mean, though it confuses me that you're still expecting a fully formed response when an error occurs... ie. if you get a 404, what sort of response are you expecting to parse? Fine grain your messages on HTTP status codes with the statusCode map.
Obviously we are not talking specifically about a 404.
Or a 400, or 500. jQuery's jqXHR is a superset of the original XHR. If you want the response parsed to JSON you won't have much of a choice but to do it manually, and wherever you do it you'll have to call JSON.parse, or an equivalent, eventually. Take a look at the XHR spec to get a better idea of how the overriding is handled, if the implementation doesn't suit you.
0

You can easily manage callbacks with:

$.ajax({
  url: $form.attr("action"),
  type: 'POST',
  data: $form.serialize(),
  complete: function(response) {},
  success: function(response) {},
  error: function(response) {}
});
Improve this answer

6 Comments

I 'm not sure what you are saying here. I am already using the complete and success callbacks (albeit by their other names). The issue is that for complete, if the HTTP code is an error then response is not the parsed content as I would like it to be.
I think I misunderstood then :). Did you try to use dataType: json?
The problem is not a wrong or missing Content-Type value. It's that jQuery as written does not attempt to touch the content at all if the HTTP status code is a 4xx or 5xx.
So result.responseText is type of string for you? Can you post what the string looks like?
It's a string for anyone: responseText. And it's also a perfectly good JSON string. Please understand that my issue is completely unrelated to basic "cannot get correct response" problems.
|
-1

My way of trying to maintain control over error response body is that I have written my php to catch most of the things that could go wrong and still return a valid json object, and inside of my JS success callback, I handle that object in there.

success: function( response ) {
    if(response) {

    } else {

    }
},
error: function( xhr ) {
    //everything worse gets sent here
}

From then, any really fundamental error that causes an ugly error code gets handled by the error callback.

Improve this answer

7 Comments

I do that as well. The problem is that I want to return an HTTP error code along with the JSON, and that code causes the error handler to execute instead. It is possible to grab the JSON and parse it inside the error handler, but it's not convenient.
Actually, come to think of it, I can't see why that would ever work. basically if you were to load a page in your browser that failed immediately with some error code, where would the message be? in the header? if so, i guess my next question is, can you achieve this with a HEAD request? if not, then you should assume it cannot be done with a GET or POST
It would be in the response body as always, which is perfectly valid if not very common. The HTTP response code is independent of the content. For example, try curl -i http://www.google.com/letsgeta404. The server returns HTML content along with a 404 error code.
Oh nice I never knew about this google "letsgeta404" url! OK i see your point
There's nothing special about that URL, I just made it up ;-)
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.