Fiquei confuso sobre quando usar esses dois métodos de análise.

Depois de ecoar meus dados json_encoded e recuperá-los via ajax, geralmente fico confuso sobre quando devo usar JSON.stringify e JSON.parse .

Eu entro [object,object]no meu console.log quando analisado e um objeto JavaScript quando codificado.

$.ajax({
url: "demo_test.txt",
success: function(data) {
         console.log(JSON.stringify(data))
                     /* OR */
         console.log(JSON.parse(data))
        //this is what I am unsure about?
    }
});

JSON.stringify transforma um objeto JavaScript em texto JSON e armazena esse texto JSON em uma string, por exemplo:

var my_object = { key_1: "some text", key_2: true, key_3: 5 };

var object_as_string = JSON.stringify(my_object);  
// "{"key_1":"some text","key_2":true,"key_3":5}"  

typeof(object_as_string);  
// "string"  

JSON.parse transforma uma sequência de texto JSON em um objeto JavaScript, por exemplo:

var object_as_string_as_object = JSON.parse(object_as_string);  
// {key_1: "some text", key_2: true, key_3: 5} 

typeof(object_as_string_as_object);  
// "object" 

JSON.parse()é para "analisar" algo que foi recebido como JSON.
JSON.stringify()é criar uma sequência JSON de um objeto / matriz.

Eles são o inverso um do outro. JSON.stringify()serializa um objeto JS em uma string JSON, enquantoJSON.parse() desserializa uma string JSON em um objeto JS.

Eles são os opostos um do outro.

JSON.stringify ()

JSON.stringify () serializa um objeto ou valor JS em uma sequência JSON.

JSON.stringify({});                  // '{}'
JSON.stringify(true);                // 'true'
JSON.stringify('foo');               // '"foo"'
JSON.stringify([1, 'false', false]); // '[1,"false",false]'
JSON.stringify({ x: 5 });            // '{"x":5}'

JSON.stringify(new Date(2006, 0, 2, 15, 4, 5)) 
// '"2006-01-02T15:04:05.000Z"'

JSON.stringify({ x: 5, y: 6 });
// '{"x":5,"y":6}' or '{"y":6,"x":5}'
JSON.stringify([new Number(1), new String('false'), new Boolean(false)]);
// '[1,"false",false]'

JSON.parse ()

O método JSON.parse () analisa uma sequência como JSON, opcionalmente, transformando o valor produzido.

JSON.parse('{}');              // {}
JSON.parse('true');            // true
JSON.parse('"foo"');           // "foo"
JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
JSON.parse('null');            // null

Em primeiro lugar, a JSON.stringify()função converte um valor JavaScript em uma string JavaScript Object Notation (JSON). JSON.parse()A função converte uma sequência JavaScript Object Notation (JSON) em um objeto. Para mais informações sobre essas duas funções, consulte os seguintes links.

https://msdn.microsoft.com/library/cc836459(v=vs.94).aspx https://msdn.microsoft.com/library/cc836466(v=vs.94).aspx

Em segundo lugar, o exemplo a seguir será útil para você entender essas duas funções.

<form id="form1" runat="server">
    <div>
        <div id="result"></div>
    </div>
</form>

<script>
    $(function () {
        //define a json object
        var employee = { "name": "John Johnson", "street": "Oslo West 16", "phone": "555 1234567" };

        //use JSON.stringify to convert it to json string
        var jsonstring = JSON.stringify(employee);
        $("#result").append('<p>json string: ' + jsonstring + '</p>');

        //convert json string to json object using JSON.parse function
        var jsonobject = JSON.parse(jsonstring);
        var info = '<ul><li>Name:' + jsonobject.name + '</li><li>Street:' + jsonobject.street + '</li><li>Phone:' + jsonobject.phone + '</li></ul>';

        $("#result").append('<p>json object:</p>');
        $("#result").append(info);
    });
</script>

var log = { "page": window.location.href, 
        "item": "item", 
        "action": "action" };

log = JSON.stringify(log);
console.log(log);
console.log(JSON.parse(log));

// A saída será:

// Para o 1st Console é uma String Like:

'{ "page": window.location.href,"item": "item","action": "action" }'

// Para o 2nd Console é um objeto como:

Object {
page   : window.location.href,  
item   : "item",
action : "action" }

JSON.stringify() Converte um objeto em uma sequência.

JSON.parse() Converte uma string JSON em um objeto.

A verdadeira confusão aqui não é sobre análise versus stringify, é sobre o tipo de dados do dataparâmetro do retorno de chamada bem-sucedido.

data pode ser a resposta bruta, ou seja, uma string ou um objeto JavaScript, conforme a documentação:

sucesso

Tipo: Function (Qualquer coisa, String textStatus, jqXHR jqXHR) Uma função a ser chamada se a solicitação for bem-sucedida. A função recebe três argumentos: Os dados retornados do servidor, formatados de acordo com o parâmetro dataType ou a função de retorno de chamada dataFilter, se especificado; <..>

E o dataType usa como padrão uma configuração de 'palpite inteligente'

dataType (padrão: palpite inteligente (xml, json, script ou html))

Tipo: String O tipo de dados que você espera do servidor. Se nenhum for especificado, o jQuery tentará deduzi- lo com base no tipo MIME da resposta (um tipo XML MIME produzirá XML, em 1,4 o JSON produzirá um objeto JavaScript, o script 1,4 executará o script e qualquer outra coisa será retornado como uma sequência).

Objeto JavaScript <-> String JSON

JSON.stringify() <-> JSON.parse()

JSON.stringify (obj) - Pega qualquer objeto serializável e retorna a representação JSON como uma sequência.

JSON.stringify() -> Object To String.

JSON.parse (string) - pega uma string JSON bem formada e retorna o objeto JavaScript correspondente.

JSON.parse() -> String To Object.

Explicação: JSON.stringify (obj [, substituto [, espaço]]);

Substituidor / Espaço - opcional ou assume um valor inteiro ou você pode chamar a função de retorno do tipo interger.

function replacer(key, value) {
    if (typeof value === 'number' && !isFinite(value)) {
        return String(value);
    }
    return value;
}

• Substituidor Just Use para substituir não finito por nulo.
• Uso do espaço para recuar Json String por espaço

Eles são o completo oposto um do outro.

JSON.parse()é usado para analisar dados que foram recebidos como JSON ; ele desserializa uma string JSON em um objeto JavaScript .

JSON.stringify()por outro lado, é usado para criar uma string JSON a partir de um objeto ou matriz ; que serializa um objeto JavaScript em uma string JSON .

Não sei se isso foi mencionado, mas um dos usos do JSON.parse (JSON.stringify (myObject)) é criar um clone do objeto original.

Isso é útil quando você deseja mexer com alguns dados sem afetar o objeto original. Provavelmente não é o caminho mais limpo / rápido, mas certamente o mais simples para objetos que não são massivamente complexos.

JSON.stringify(obj [, replacer [, space]]) - Pega qualquer objeto serializável e retorna a representação JSON como uma sequência.

JSON.parse(string) - Pega uma sequência JSON bem formada e retorna o objeto JavaScript correspondente.

Eles estão se opondo. JSON.Stringify()converte JSON em string e JSON.Parse()analisa uma string em JSON.

JSON: É usado principalmente para trocar dados de / para o servidor. Antes de enviar o objeto JSON para o servidor, ele deve ser uma sequência.

JSON.stringify() //Converts the JSON object into the string representation.
var jsonData={"Name":"ABC","Dept":"Software"};// It is a JSON object
var jsonString=JSON.stringify(jsonData);// It is a string representation of the object
// jsonString === '{"Name":"ABC","Dept":"Software"}'; is true

Também converte a matriz Javascript em string

var arrayObject=["ABC","Software"];// It is array object
var arrString=JSON.stringify(array);// It is string representation of the array (object)
// arrString === '["ABC","Software"]'; is true 

Quando recebemos os dados JSON do servidor, os dados teriam o formato de sequência. Conseqüentemente, convertemos a sequência em objeto JSON.

JSON.parse() //To convert the string into JSON object.
var data='{ "name":"ABC", "Dept":"Software"}'// it is a string (even though it looks like an object)
var JsonData= JSON.parse(data);// It is a JSON Object representation of the string.
// JsonData === { "name":"ABC", "Dept":"Software"}; is true

JSON.parse() é usado para converter String em objeto.
JSON.stringify()é usado para converter Objeto em String.

Você pode consultar isso também ...

<script type="text/javascript">

function ajax_get_json(){

    var hr = new XMLHttpRequest();
    hr.open("GET", "JSON/mylist.json", true);
    hr.setRequestHeader("Content-type", "application/json",true);
    hr.onreadystatechange = function() {
        if(hr.readyState == 4 && hr.status == 200) {
           /*  var return_data = hr.responseText; */

           var data=JSON.parse(hr.responseText);
           var status=document.getElementById("status");
           status.innerHTML = "";
           /* status.innerHTML=data.u1.country;  */
           for(var obj in data)
               {
               status.innerHTML+=data[obj].uname+" is in "+data[obj].country+"<br/>";
               }

        }
    }
    hr.send(null);
    status.innerHTML = "requesting...";
}
</script>

JSON.parse () pega uma string JSON e a transforma em um objeto JavaScript.

JSON.stringify () pega um objeto JavaScript e o transforma em uma string JSON.

const myObj = {
      name: 'bipon',
      age: 25,
      favoriteFood: 'fish curry'
};

 const myObjStr = JSON.stringify(myObj);

console.log(myObjStr);
// "{"name":"bipon","age":26,"favoriteFood":"fish curry"}"

console.log(JSON.parse(myObjStr));
 // Object {name:"bipon",age:26,favoriteFood:"fish curry"}

const myArr = ['simon', 'gomez', 'john'];

const myArrStr = JSON.stringify(myArr);

console.log(myArrStr);
// "["simon","gomez","john"]"

console.log(JSON.parse(myArrStr));
// ["simon","gomez","john"]