Obtendo um "parsererror" do jquery para uma solicitação do Ajax, tentei alterar o POST para um GET, retornando os dados de algumas maneiras diferentes (criando classes, etc.), mas não consigo descobrir qual é o problema.

Meu projeto está no MVC3 e estou usando o jQuery 1.5. Tenho um menu suspenso e, no evento onchange, aciono uma chamada para obter alguns dados com base no que foi selecionado.

Dropdown: (carrega as "Views" da lista no Viewbag e disparar o evento funciona bem)

@{
    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");
        }
    });
};

O código acima chama com sucesso o método MVC e retorna:

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

Mas o jquery dispara o evento de erro para o método $ .ajax () que diz "parsererror".

Encontrei recentemente esse problema e me deparei com essa pergunta.

Eu resolvi isso de uma maneira muito mais fácil.

Método Um

Você pode remover a dataType: 'json'propriedade do literal do objeto ...

Método dois

Ou você pode fazer o que @Sagiv estava dizendo retornando seus dados como Json.

A razão pela qual essa parsererrormensagem ocorre é que, quando você simplesmente retorna uma sequência ou outro valor, não é realmente Json, portanto o analisador falha ao analisá-la.

Portanto, se você remover a dataType: jsonpropriedade, ela não tentará analisá-la como Json.

Com o outro método, se você retornar seus dados como Json, o analisador saberá como manipulá-los adequadamente.

Veja a resposta de @ david-east para a maneira correta de lidar com o problema

Esta resposta é relevante apenas para um bug do jQuery 1.5 ao usar o arquivo: protocolo.

Recentemente, tive um problema semelhante ao atualizar para o jQuery 1.5. Apesar de obter uma resposta correta, o manipulador de erros foi acionado. Eu o resolvi usando o completeevento e depois verificando o valor do status. por exemplo:

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

Você especificou o dataType de resposta de chamada ajax como:

'json'

onde a resposta ajax real não é um JSON válido e, como resultado, o analisador JSON está lançando um erro.

A melhor abordagem que eu recomendaria é alterar o dataType para:

'texto'

e dentro do retorno de chamada bem-sucedido, valide se um JSON válido está sendo retornado ou não e, se a validação do JSON falhar, alerte-o na tela para que fique óbvio para que finalidade a chamada ajax está realmente falhando. Veja isso:

$.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);
    }
});

o problema é que seu controlador retorna uma string ou outro objeto que não pode ser analisado. a chamada ajax esperava receber Json em troca. tente retornar JsonResult no controlador assim:

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

    }

espero que ajude :)

Seus dados JSON podem estar errados. http://jsonformatter.curiousconcept.com/ para validá-lo.

Existem muitas sugestões para remover

dataType: "json"

Embora eu conceda que isso funcione, ignore o problema subjacente. Se você está confiante de que a sequência de retorno realmente é JSON, procure espaços em branco incorretos no início da resposta. Considere dar uma olhada no violinista. O meu ficou assim:

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

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

No meu caso, houve um problema com o PHP expelindo caracteres indesejados (nesse caso, BOMs de arquivo UTF). Depois que eu os removi, ele corrigiu o problema, mantendo

dataType: json

Certifique-se de remover qualquer código de depuração ou qualquer outra coisa que possa estar gerando informações indesejadas. Um tanto óbvio, mas fácil de esquecer no momento.

Eu não sei se isso ainda é real, mas o problema estava com a codificação. Mudar para ANSI resolveu o problema para mim.

Se você tiver esse problema usando HTTP GET no IE, resolvi esse problema configurando o cache: false. Como usei o mesmo URL para solicitações HTML e json, ele atingiu o cache em vez de fazer uma chamada 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");
    }
});

você deve remover o dataType: "json". Então veja a mágica ... o motivo de fazer isso é que você está convertendo o objeto json em uma sequência simples ... para que o json parser não possa analisar essa sequência por não ser um objeto 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");
    }
 });
};

No caso da operação Get da web .net mvc / api, certifique-se de permitir obter

     return Json(data,JsonRequestBehavior.AllowGet);

Eu também estava recebendo "Solicitação de retorno com erro: parsererror". no console javascript. No meu caso, não era problema do Json, mas tive que passar para a área de texto da visualização uma codificação válida.

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

Eu encontrei esse erro, mas depois de modificar minha resposta antes de enviá-la ao cliente, ela funcionou bem.

//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
}

Eu tive o mesmo problema, acabou que o meu web.confignão era o mesmo com meus colegas de equipe. Então, por favor, verifique o seu web.config.

Espero que isso ajude alguém.

O problema

window.JSON.parse gera um erro na função $ .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>

Minha solução

Sobrecarregando o JQuery usando a ferramenta requirejs .

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

conteúdo do arquivo 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 você não deseja remover / alterardataType: json , é possível substituir a análise rigorosa do jQuery definindo um costume 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 isso, você pode personalizar o comportamento quando a resposta não puder ser analisada como JSON (mesmo se você receber um corpo de resposta vazio!)

Com este conversor personalizado, .done()/ successserá acionado enquanto a solicitação tiver sido bem-sucedida (código de resposta 1xx ou 2xx).