Come si rileva l'errore jQuery $ .getJSON (o $ .ajax con tipo di dati impostato su 'jsonp') quando si utilizza JSONP?

Question

È possibile rilevare un errore quando si utilizza JSONP con jQuery? Ho provato entrambi i metodi $ .getJSON e $ .ajax ma nessuno dei due rileverà l'errore 404 che sto testando. Ecco cosa ho provato (tieni presente che funzionano tutti correttamente, ma voglio gestire il caso quando fallisce):

jQuery.ajax({
    type: "GET",
    url: handlerURL,
    dataType: "jsonp",
    success: function(results){
        alert("Success!");
    },
    error: function(XMLHttpRequest, textStatus, errorThrown){
        alert("Error");
    }
});

E anche:

jQuery.getJSON(handlerURL + "&callback=?", 
    function(jsonResult){
        alert("Success!");
    });

Ho anche provato ad aggiungere $ .ajaxError ma non ha funzionato neanche:

jQuery(document).ajaxError(function(event, request, settings){
   alert("Error");
});

Grazie in anticipo per eventuali risposte!

Answer 1

Sembra che le richieste JSONP che non restituiscono un risultato positivo non innescino mai alcun evento, successo o fallimento e, nel bene o nel male, apparentemente in base alla progettazione.

Dopo aver cercato il loro bug tracker, c'è una patch che potrebbe essere una possibile soluzione utilizzando un callback di timeout. Vedi segnalazione bug # 3442 . Se non riesci a catturare l'errore, puoi almeno il timeout dopo aver atteso un ragionevole lasso di tempo per il successo.

Answer 2

Ecco la mia ampia risposta a una domanda simile.

Ecco il codice:

jQuery.getJSON(handlerURL + "&callback=?", 
    function(jsonResult){
        alert("Success!");
    })
.done(function() { alert('getJSON request succeeded!'); })
.fail(function(jqXHR, textStatus, errorThrown) { alert('getJSON request failed! ' + textStatus); })
.always(function() { alert('getJSON request ended!'); });

Answer 3

Rilevamento di problemi JSONP

Se non si desidera scaricare una dipendenza, è possibile rilevare manualmente lo stato di errore. È facile.

Sarai in grado di rilevare errori JSONP solo usando una sorta di timeout. Se non c'è una risposta valida in un determinato momento, quindi assumere un errore. L'errore potrebbe essere praticamente qualsiasi cosa, però.

Ecco un modo semplice per verificare gli errori. Usa solo un success flag:

var success = false;

$.getJSON(url, function(json) {
    success = true;
    // ... whatever else your callback needs to do ...
});

// Set a 5-second (or however long you want) timeout to check for errors
setTimeout(function() {
    if (!success)
    {
        // Handle error accordingly
        alert("Houston, we have a problem.");
    }
}, 5000);

Come menzionato nei commenti, nei dettagli è stato possibile utilizzare anche clearTimeout:

var errorTimeout = setTimeout(function() {
    if (!success)
    {
        // Handle error accordingly
        alert("Houston, we have a problem.");
    }
}, 5000);

$.getJSON(url, function(json) {
    clearTimeout(errorTimeout);
    // ... whatever else your callback needs to do ...
});

Perché? Continua a leggere ...

---

Ecco come funziona JSONP in breve:

JSONP non utilizza XMLHttpRequest come le normali richieste AJAX. Invece, inserisce un tag <script> nella pagina, dove & Quot; src & Quot; l'attributo è l'URL della richiesta. Il contenuto della risposta è racchiuso in una funzione Javascript che viene quindi eseguita quando scaricata.

Ad esempio.

Richiesta JSONP: https://api.site.com/endpoint?this=that&callback=myFunc

Javascript inserirà questo tag di script nel DOM:

<script src="https://api.site.com/endpoint?this=that&callback=myFunc"></script>

Cosa succede quando un tag callback viene aggiunto al DOM? Ovviamente, viene eseguito.

Supponiamo quindi che la risposta a questa query abbia prodotto un risultato JSON come:

{"answer":42}

Per il browser, è la stessa cosa della fonte di uno script, quindi viene eseguito. Ma cosa succede quando esegui questo:

<script>{"answer":42}</script>

Bene, niente. È solo un oggetto. Non viene archiviato, salvato e non succede nulla.

Ecco perché le richieste JSONP racchiudono i loro risultati in una funzione. Il server, che deve supportare la serializzazione JSONP, vede il parametro myFunc specificato e restituisce invece questo:

myFunc({"answer":42})

Quindi questo viene eseguito invece:

<script>myFunc({"answer":42})</script>

... che è molto più utile. Da qualche parte nel tuo codice c'è, in questo caso, una funzione globale chiamata <=>:

myFunc(data)
{
    alert("The answer to life, the universe, and everything is: " + data.answer);
}

Questo è tutto. Questa è la & Quot; magic & Quot; di JSONP. Quindi compilare un controllo di timeout è molto semplice, come mostrato sopra. Invia la richiesta e subito dopo, avvia un timeout. Dopo X secondi, se la bandiera non è stata ancora impostata, la richiesta è scaduta.

Answer 4

So che questa domanda è un po 'vecchia ma non ho visto una risposta che dia una soluzione semplice al problema, quindi ho pensato di condividere la mia soluzione "semplice".

$.getJSON("example.json", function() {
      console.log( "success" );
}).fail(function() { 
      console.log( "error" ); 
}); 

Possiamo semplicemente usare il .fail() callback per verificare se si è verificato un errore.

Spero che questo aiuti :)

Answer 5

Se si collabora con il provider, è possibile inviare un altro parametro della stringa di query come funzione da richiamare in caso di errore.

?? &

callback = amp;? Errore =

Questo si chiama JSONPE ma non è affatto uno standard defacto.

Il provider passa quindi le informazioni alla funzione di errore per facilitare la diagnosi.

Tuttavia non aiuta con gli errori di comunicazione - jQuery dovrebbe essere aggiornato per richiamare anche la funzione di errore al timeout, come nella risposta di Adam Bellaire.

Answer 6

Sembra che funzioni ora:

jQuery(document).ajaxError(function(event, request, settings){
   alert("Error");
});

Answer 7

Lo uso per rilevare un errore JSON

try {
   $.getJSON(ajaxURL,callback).ajaxError();
} catch(err) {
   alert("wow");
   alert("Error : "+ err);
}

Modifica: In alternativa puoi anche ricevere il messaggio di errore. Questo ti farà sapere qual è esattamente l'errore. Prova a seguire la sintassi nel blocco catch

alert("Error : " + err);

Answer 8

Mayby funziona?

.complete(function(response, status) {
    if (response.status == "404")
        alert("404 Error");
    else{
        //Do something
    }   
    if(status == "error")
        alert("Error");
    else{
        //Do something
    }
});

Non so quando lo stato va in " errore " modalità. Ma l'ho provato con 404 e ha risposto

Answer 9

puoi gestire esplicitamente qualsiasi numero di errore aggiungendo questo attributo nella richiesta ajax:

statusCode: {
        404: function() {
          alert("page not found");
        }
    }

quindi, il tuo codice dovrebbe essere così:

jQuery.ajax({
type: "GET",
statusCode: {
        404: function() {
          alert("page not found");
        }
},
url: handlerURL,
dataType: "jsonp",
success: function(results){
    alert("Success!");
},
error: function(XMLHttpRequest, textStatus, errorThrown){
    alert("Error");
}
});

spero che questo ti aiuti :)

Answer 10

Ho anche pubblicato questa risposta in stack overflow - Gestione degli errori nelle chiamate getJSON

So che è passato un po 'di tempo da quando qualcuno ha risposto qui e il poster probabilmente ha già ottenuto la sua risposta da qui o da qualche altra parte. Tuttavia, penso che questo post aiuterà chiunque cerchi un modo per tenere traccia di errori e timeout durante le richieste getJSON. Pertanto di seguito la mia risposta alla domanda

La struttura getJSON è la seguente (disponibile in http://api.jqueri.com ):

$(selector).getJSON(url,data,success(data,status,xhr))

la maggior parte delle persone lo implementa usando

$.getJSON(url, datatosend, function(data){
    //do something with the data
});

dove usano l'URL var per fornire un collegamento ai dati JSON, il datatosend come luogo per aggiungere "?callback=?" e altre variabili che devono essere inviate per ottenere i dati JSON corretti restituiti, e la funzione di successo come una funzione per l'elaborazione dei dati.

Puoi comunque aggiungere lo stato e le variabili xhr nella tua funzione di successo. La variabile status contiene una delle seguenti stringhe: & Quot; success & Quot ;, & Quot; non modificata & Quot ;, & Quot; errore & Quot ;, & Quot ; timeout " ;, oppure " parsererror " ;, e la variabile xhr contiene l'oggetto XMLHttpRequest restituito ( trovato su w3schools )

$.getJSON(url, datatosend, function(data, status, xhr){
    if (status == "success"){
        //do something with the data
    }else if (status == "timeout"){
        alert("Something is wrong with the connection");
    }else if (status == "error" || status == "parsererror" ){
        alert("An error occured");
    }else{
        alert("datatosend did not change");
    }         
});

In questo modo è facile tenere traccia di timeout ed errori senza dover implementare un tracker di timeout personalizzato che viene avviato una volta effettuata una richiesta.

Spero che questo aiuti qualcuno che sta ancora cercando una risposta a questa domanda.