Sono stato confuso su quando utilizzare questi due metodi di analisi.

Dopo aver ripetuto i miei dati json_encoded e recuperarli tramite ajax, mi capita spesso di confondermi su quando dovrei usare JSON.stringify e JSON.parse .

Ottengo [object,object]nel mio console.log quando analizzato e un oggetto JavaScript quando sottoposto a stringing.

$.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 trasforma un oggetto JavaScript in testo JSON e memorizza il testo JSON in una stringa, ad esempio:

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 trasforma una stringa di testo JSON in un oggetto JavaScript, ad esempio:

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()è per "analizzare" qualcosa che è stato ricevuto come JSON.
JSON.stringify()è creare una stringa JSON da un oggetto / array.

Sono l'inverso dell'altro. JSON.stringify()serializza un oggetto JS in una stringa JSON, mentreJSON.parse() deserializza una stringa JSON in un oggetto JS.

Sono gli opposti l'uno dell'altro.

JSON.stringify ()

JSON.stringify () serializza un oggetto o valore JS in una stringa 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 ()

Il metodo JSON.parse () analizza una stringa come JSON, trasformando facoltativamente il valore prodotto.

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

Innanzitutto, la JSON.stringify()funzione converte un valore JavaScript in una stringa JSON (JavaScript Object Notation).JSON.parse()La funzione converte una stringa JSON (JavaScript Object Notation) in un oggetto. Per ulteriori informazioni su queste due funzioni, consultare i seguenti collegamenti.

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

In secondo luogo, il seguente esempio sarà utile per comprendere queste due funzioni.

<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));

// L'output sarà:

// Per 1st Console è una stringa come:

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

// Per 2nd Console è un oggetto simile:

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

JSON.stringify() Converte un oggetto in una stringa.

JSON.parse() Converte una stringa JSON in un oggetto.

La vera confusione qui non riguarda parse vs stringify, ma riguarda il tipo di dati di data parametro del callback di successo.

data può essere la risposta non elaborata, ovvero una stringa, oppure può essere un oggetto JavaScript, come da documentazione:

successo

Tipo: Funzione (Qualsiasi dato, String textStatus, jqXHR jqXHR) Una funzione da chiamare se la richiesta ha esito positivo. La funzione riceve tre argomenti: I dati restituiti dal server, formattati in base al parametro dataType o alla funzione di callback di dataFilter, se specificato; <..>

E dataType viene impostato automaticamente su "ipotesi intelligente"

dataType (impostazione predefinita: Intelligent Guess (xml, json, script o html))

Tipo: stringa Il tipo di dati che ti aspetti dal server. Se non viene specificato nessuno, jQuery proverà a inferirlo in base al tipo MIME della risposta (un tipo MIME XML produrrà XML, in 1.4 JSON produrrà un oggetto JavaScript, in 1.4 lo script eseguirà lo script e qualsiasi altra cosa sarà restituito come stringa).

Stringa JSON dell'oggetto <-> JavaScript

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

JSON.stringify (obj): accetta qualsiasi oggetto serializzabile e restituisce la rappresentazione JSON come stringa.

JSON.stringify() -> Object To String.

JSON.parse (stringa): accetta una stringa JSON ben formata e restituisce l'oggetto JavaScript corrispondente.

JSON.parse() -> String To Object.

Spiegazione: JSON.stringify (obj [, replacer [, space]]);

Sostituisci / Spazio: facoltativo o accetta un valore intero oppure puoi chiamare la funzione di ritorno del tipo di numero intero.

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

• Sostituisci solo per sostituire il numero non finito con null.
• Uso dello spazio per il rientro di Json String in base allo spazio

Sono l'esatto contrario reciproco.

JSON.parse()viene utilizzato per l' analisi dei dati ricevuti come JSON ; si deserializza una stringa JSON in un oggetto JavaScript .

JSON.stringify()d'altra parte viene utilizzato per creare una stringa JSON da un oggetto o un array ; si serializza un oggetto JavaScript in una stringa JSON .

Non so se sia stato menzionato, ma uno degli usi di JSON.parse (JSON.stringify (myObject)) è quello di creare un clone dell'oggetto originale.

Ciò è utile quando si desidera pasticciare con alcuni dati senza influire sull'oggetto originale. Probabilmente non è il modo più pulito / veloce, ma sicuramente il più semplice per oggetti che non sono molto complessi.

JSON.stringify(obj [, replacer [, space]]) - Accetta qualsiasi oggetto serializzabile e restituisce la rappresentazione JSON come stringa.

JSON.parse(string) - Accetta una stringa JSON ben formata e restituisce l'oggetto JavaScript corrispondente.

Si stanno opponendo. JSON.Stringify()converte JSON in stringa e JSON.Parse()analizza una stringa in JSON.

JSON: viene utilizzato principalmente per scambiare dati da / verso il server. Prima di inviare l'oggetto JSON al server, deve essere una stringa.

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

Converte anche l'array Javascript in stringa

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 avessimo ricevuto i dati JSON dal server, i dati sarebbero stati nel formato stringa, quindi convertiremo la stringa in oggetto 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() è usato per convertire String in Object.
JSON.stringify()viene utilizzato per convertire l'oggetto in stringa.

Puoi fare riferimento anche a questo ...

<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 () accetta una stringa JSON e la trasforma in un oggetto JavaScript.

JSON.stringify () accetta un oggetto JavaScript e lo trasforma in una stringa 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"]