Ho ricevuto un "parsererror" da jquery per una richiesta Ajax, ho provato a cambiare il POST in un GET, restituendo i dati in diversi modi (creazione di classi, ecc.) Ma non riesco a capire quale sia il problema.

Il mio progetto è in MVC3 e sto usando jQuery 1.5 Ho un menu a discesa e sull'evento onchange spengo una chiamata per ottenere alcuni dati in base a ciò che è stato selezionato.

Elenco a discesa: (carica le "Viste" dall'elenco nel Viewbag e l'attivazione dell'evento funziona correttamente)

@{
    var viewHtmls = new Dictionary<string, object>();
    viewHtmls.Add("data-bind", "value: ViewID");
    viewHtmls.Add("onchange", "javascript:PageModel.LoadViewContentNames()");
}
@Html.DropDownList("view", (List<SelectListItem>)ViewBag.Views, viewHtmls)

Javascript:

this.LoadViewContentNames = function () {
    $.ajax({
        url: '/Admin/Ajax/GetViewContentNames',
        type: 'POST',
        dataType: 'json',
        data: { viewID: $("#view").val() },
        success: function (data) {
            alert(data);
        },
        error: function (data) {
            debugger;
            alert("Error");
        }
    });
};

Il codice precedente chiama correttamente il metodo MVC e restituisce:

[{"ViewContentID":1,"Name":"TopContent","Note":"Content on the top"},
 {"ViewContentID":2,"Name":"BottomContent","Note":"Content on the bottom"}]

Ma jquery genera l'evento di errore per il metodo $ .ajax () che dice "parsererror".

Di recente ho riscontrato questo problema e mi sono imbattuto in questa domanda.

L'ho risolto in un modo molto più semplice.

Metodo Uno

Puoi rimuovere la dataType: 'json'proprietà dall'oggetto letterale ...

Metodo due

Oppure puoi fare quello che @Sagiv stava dicendo restituendo i tuoi dati come Json.

Il motivo per cui si parsererrorverifica questo messaggio è che quando si restituisce semplicemente una stringa o un altro valore, non lo è realmente Json, quindi il parser non riesce durante l'analisi.

Quindi se rimuovi la dataType: jsonproprietà, non proverà ad analizzarla come Json.

Con l'altro metodo se ti assicuri di restituire i tuoi dati come Json, il parser saprà come gestirli correttamente.

Vedi la risposta di @ david-est per il modo corretto di gestire il problema

Questa risposta è rilevante solo per un bug con jQuery 1.5 quando si utilizza il file: protocollo.

Di recente ho avuto un problema simile durante l'aggiornamento a jQuery 1.5. Nonostante abbia ricevuto una risposta corretta, il gestore degli errori ha generato. L'ho risolto utilizzando l' completeevento e quindi verificando il valore dello stato. per esempio:

complete: function (xhr, status) {
    if (status === 'error' || !xhr.responseText) {
        handleError();
    }
    else {
        var data = xhr.responseText;
        //...
    }
}

È stato specificato la risposta chiamata ajax dataType come:

'Json'

dove la risposta ajax effettiva non è un JSON valido e di conseguenza il parser JSON genera un errore.

L'approccio migliore che consiglierei è di modificare il tipo di dati in:

'testo'

e, in caso di successo, il callback verifica se viene restituito o meno un JSON valido e, in caso di esito negativo della convalida JSON, avvisalo sullo schermo in modo che sia ovvio per quale scopo la chiamata ajax stia effettivamente fallendo. Dai un'occhiata a questo:

$.ajax({
    url: '/Admin/Ajax/GetViewContentNames',
    type: 'POST',
    dataType: 'text',
    data: {viewID: $("#view").val()},
    success: function (data) {
        try {
            var output = JSON.parse(data);
            alert(output);
        } catch (e) {
            alert("Output is not valid JSON: " + data);
        }
    }, error: function (request, error) {
        alert("AJAX Call Error: " + error);
    }
});

il problema è che il controller restituisce una stringa o un altro oggetto che non può essere analizzato. la chiamata ajax prevedeva di ottenere in cambio Json. prova a restituire JsonResult nel controller in questo modo:

 public JsonResult YourAction()
    {
        ...return Json(YourReturnObject);

    }

spero che sia d'aiuto :)

I tuoi dati JSON potrebbero essere errati. http://jsonformatter.curiousconcept.com/ per convalidarlo.

Ci sono molti suggerimenti da rimuovere

dataType: "json"

Mentre concedo che questo funzioni, ignora il problema di fondo. Se sei sicuro che la stringa di ritorno sia davvero JSON, cerca uno spazio vuoto errato all'inizio della risposta. Prendi in considerazione l'idea di suonare il violinista. Il mio sembrava così:

Connection: Keep-Alive
Content-Type: application/json; charset=utf-8

{"type":"scan","data":{"image":".\/output\/ou...

Nel mio caso questo era un problema con PHP che emetteva caratteri indesiderati (in questo caso le distinte materiali del file UTF). Una volta rimossi questi risolveva il problema mantenendo anche

dataType: json

Assicurati di rimuovere qualsiasi codice di debug o qualsiasi altra cosa che potrebbe produrre informazioni indesiderate. Un po 'ovvio, ma facile da dimenticare nel momento.

Non so se questo è ancora reale, ma il problema era con la codifica. Il passaggio ad ANSI ha risolto il problema per me.

Se si riscontra questo problema utilizzando HTTP GET in Internet Explorer, ho risolto il problema impostando la cache: false. Dato che ho usato lo stesso url per entrambe le richieste HTML e json, ha colpito la cache invece di fare una chiamata json.

$.ajax({
    url: '/Test/Something/',
    type: 'GET',
    dataType: 'json',
    cache: false,
    data: { viewID: $("#view").val() },
    success: function (data) {
        alert(data);
    },
    error: function (data) {
        debugger;
        alert("Error");
    }
});

è necessario rimuovere il tipo di dati: "json". Quindi vedi la magia ... la ragione per fare una cosa del genere è che stai convertendo un oggetto JSON in una semplice stringa ... quindi il parser JSON non è in grado di analizzare quella stringa a causa del fatto che non è un oggetto JSON.

this.LoadViewContentNames = function () {
$.ajax({
    url: '/Admin/Ajax/GetViewContentNames',
    type: 'POST',
    data: { viewID: $("#view").val() },
    success: function (data) {
        alert(data);
    },
    error: function (data) {
        debugger;
        alert("Error");
    }
 });
};

in caso di operazione Get da web .net mvc / api, assicurarsi di consentire get

     return Json(data,JsonRequestBehavior.AllowGet);

Stavo anche ricevendo "Richiesta di restituzione con errore: parsererror". nella console javascript. Nel mio caso non era una questione di Json, ma dovevo passare all'area di testo della vista una codifica valida.

  String encodedString = getEncodedString(text, encoding);
  view.setTextAreaContent(encodedString);

Ho riscontrato questo errore, ma dopo aver modificato la mia risposta prima di inviarla al client ha funzionato bene.

//Server side
response = JSON.stringify('{"status": {"code": 200},"result": '+ JSON.stringify(result)+'}');
res.send(response);  // Sending to client

//Client side
success: function(res, status) {
    response = JSON.parse(res); // Getting as expected
    //Do something
}

Ho avuto lo stesso problema, ho scoperto che web.confignon era lo stesso con i miei compagni di squadra. Quindi per favore controlla il tuo web.config.

Spero che questo aiuti qualcuno.

Il problema

window.JSON.parse genera un errore nella funzione $ .parseJSON.

<pre>
$.parseJSON: function( data ) {
...
// Attempt to parse using the native JSON parser first
if ( window.JSON && window.JSON.parse ) {
return window.JSON.parse( data );
}
...
</pre>

La mia soluzione

Sovraccarico di JQuery mediante lo strumento Requirejs .

<pre>
define(['jquery', 'jquery.overload'], function() { 
    //Loading jquery.overload
});
</pre>

contenuto del file jquery.overload.js

<pre>
define(['jquery'],function ($) { 

    $.parseJSON: function( data ) {
        // Attempt to parse using the native JSON parser first
        /**  THIS RAISES Parsing ERROR
        if ( window.JSON && window.JSON.parse ) {
            return window.JSON.parse( data );
        }
        **/

        if ( data === null ) {
            return data;
        }

        if ( typeof data === "string" ) {

            // Make sure leading/trailing whitespace is removed (IE can't handle it)
            data = $.trim( data );

            if ( data ) {
                // Make sure the incoming data is actual JSON
                // Logic borrowed from http://json.org/json2.js
                if ( rvalidchars.test( data.replace( rvalidescape, "@" )
                    .replace( rvalidtokens, "]" )
                    .replace( rvalidbraces, "")) ) {

                    return ( new Function( "return " + data ) )();
                }
            }
        }

        $.error( "Invalid JSON: " + data );
    }

    return $;

});
</pre>

Se non si desidera rimuovere / modificaredataType: json , è possibile ignorare l'analisi rigorosa di jQuery definendo un'abitudine converter:

$.ajax({
    // We're expecting a JSON response...
    dataType: 'json',

    // ...but we need to override jQuery's strict JSON parsing
    converters: {
        'text json': function(result) {
            try {
                // First try to use native browser parsing
                if (typeof JSON === 'object' && typeof JSON.parse === 'function') {
                    return JSON.parse(result);
                } else {
                    // Fallback to jQuery's parser
                    return $.parseJSON(result);
                }
            } catch (e) {
               // Whatever you want as your alternative behavior, goes here.
               // In this example, we send a warning to the console and return 
               // an empty JS object.
               console.log("Warning: Could not parse expected JSON response.");
               return {};
            }
        }
    },

    ...

Usando questo, puoi personalizzare il comportamento quando la risposta non può essere analizzata come JSON (anche se ottieni un corpo di risposta vuoto!)

Con questo convertitore personalizzato, .done()/ successverrà attivato finché la richiesta avrà esito positivo (codice di risposta 1xx o 2xx).