Ich war verwirrt darüber, wann ich diese beiden Analysemethoden verwenden sollte.

Nachdem ich meine json_encoded-Daten wiedergegeben und über Ajax abgerufen habe, bin ich oft verwirrt darüber, wann ich JSON.stringify und JSON.parse verwenden soll .

Ich bekomme [object,object]in meiner console.log, wenn analysiert, und ein JavaScript-Objekt, wenn es stringifiziert ist.

$.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 wandelt ein JavaScript-Objekt in JSON-Text um und speichert diesen JSON-Text in einer Zeichenfolge, z.

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 wandelt eine Zeichenfolge aus JSON-Text in ein JavaScript-Objekt um, z.

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()dient zum "Parsen" von etwas, das als JSON empfangen wurde.
JSON.stringify()besteht darin, eine JSON-Zeichenfolge aus einem Objekt / Array zu erstellen.

Sie sind das Gegenteil voneinander. JSON.stringify()serialisiert ein JS-Objekt in eine JSON-Zeichenfolge, während JSON.parse()eine JSON-Zeichenfolge in ein JS-Objekt deserialisiert wird.

Sie sind die Gegensätze voneinander.

JSON.stringify ()

JSON.stringify () serialisiert ein JS-Objekt oder einen JSON-Wert in eine JSON-Zeichenfolge.

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

Die Methode JSON.parse () analysiert eine Zeichenfolge als JSON und transformiert optional den erzeugten Wert.

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

Zunächst JSON.stringify()konvertiert die Funktion einen JavaScript-Wert in eine JSON-Zeichenfolge (JavaScript Object Notation). JSON.parse()Die Funktion konvertiert eine JSON-Zeichenfolge (JavaScript Object Notation) in ein Objekt. Weitere Informationen zu diesen beiden Funktionen finden Sie unter den folgenden Links.

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

Zweitens ist das folgende Beispiel hilfreich, um diese beiden Funktionen zu verstehen.

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

// Die Ausgabe lautet:

// Für die 1. Konsole ist ein String wie:

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

// Für die 2. Konsole ist ein Objekt wie:

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

JSON.stringify() Konvertiert ein Objekt in eine Zeichenfolge.

JSON.parse() Konvertiert eine JSON-Zeichenfolge in ein Objekt.

Bei der wirklichen Verwirrung geht es hier nicht um Parse vs Stringify, sondern um den Datentyp des dataParameters des Erfolgsrückrufs.

data kann entweder die Rohantwort sein, dh eine Zeichenfolge, oder es kann ein JavaScript-Objekt sein, wie in der Dokumentation beschrieben:

Erfolg

Typ: Funktion (Alle Daten, Zeichenfolge textStatus, jqXHR jqXHR) Eine Funktion, die aufgerufen werden soll, wenn die Anforderung erfolgreich ist. Der Funktion werden drei Argumente übergeben: Die vom Server zurückgegebenen Daten, formatiert gemäß dem Parameter dataType oder der Rückruffunktion dataFilter, falls angegeben; <..>

Der Datentyp ist standardmäßig auf "Intelligent Guess" eingestellt.

Datentyp (Standard: Intelligent Guess (XML, JSON, Skript oder HTML))

Typ: Zeichenfolge Der Datentyp, den Sie vom Server erwarten. Wenn keine angegeben ist, versucht jQuery , sie basierend auf dem MIME-Typ der Antwort abzuleiten (ein XML-MIME-Typ liefert XML, in 1.4 JSON liefert ein JavaScript-Objekt, in 1.4 führt das Skript das Skript aus und alles andere wird ausgeführt als Zeichenfolge zurückgegeben).

JavaScript-Objekt <-> JSON-Zeichenfolge

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

JSON.stringify (obj) - Nimmt jedes serialisierbare Objekt und gibt die JSON-Darstellung als Zeichenfolge zurück.

JSON.stringify() -> Object To String.

JSON.parse (Zeichenfolge) - Nimmt eine wohlgeformte JSON-Zeichenfolge und gibt das entsprechende JavaScript-Objekt zurück.

JSON.parse() -> String To Object.

Erläuterung: JSON.stringify (obj [, replace [, space]]);

Replacer / Space - optional oder nimmt einen ganzzahligen Wert an oder Sie können die Rückgabefunktion vom Typ Interger aufrufen.

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

• Replacer Nur verwenden, um nicht endliches Nein durch Null zu ersetzen.
• Speicherplatz zum Einrücken des Json-Strings nach Leerzeichen

Sie sind das genaue Gegenteil voneinander.

JSON.parse()wird zum Parsen von Daten verwendet, die als JSON empfangen wurden ; Es deserialisiert eine JSON-Zeichenfolge in ein JavaScript-Objekt .

JSON.stringify()Auf der anderen Seite wird eine JSON-Zeichenfolge aus einem Objekt oder Array erstellt . Es serialisiert ein JavaScript-Objekt in eine JSON-Zeichenfolge .

Ich weiß nicht, ob es erwähnt wurde, aber eine der Verwendungsmöglichkeiten von JSON.parse (JSON.stringify (myObject)) besteht darin, einen Klon des ursprünglichen Objekts zu erstellen.

Dies ist praktisch, wenn Sie mit einigen Daten herumspielen möchten, ohne das ursprüngliche Objekt zu beeinträchtigen. Wahrscheinlich nicht der sauberste / schnellste Weg, aber sicherlich der einfachste für Objekte, die nicht sehr komplex sind.

JSON.stringify(obj [, replacer [, space]]) - Nimmt ein serialisierbares Objekt und gibt die JSON-Darstellung als Zeichenfolge zurück.

JSON.parse(string) - Nimmt eine wohlgeformte JSON-Zeichenfolge und gibt das entsprechende JavaScript-Objekt zurück.

Sie stehen sich gegenüber. JSON.Stringify()konvertiert JSON in einen String und JSON.Parse()analysiert einen String in JSON.

JSON: Es wird hauptsächlich zum Austausch von Daten zum / vom Server verwendet. Vor dem Senden des JSON-Objekts an den Server muss es sich um eine Zeichenfolge handeln.

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

Es konvertiert auch das Javascript-Array in einen 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 

Wenn wir die JSON-Daten vom Server erhalten haben, haben die Daten das Zeichenfolgenformat. Von dort konvertieren wir die Zeichenfolge in ein JSON-Objekt.

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()wird verwendet, um String in Object zu konvertieren.
JSON.stringify()wird verwendet, um Object in String zu konvertieren.

Sie können dies auch verweisen ...

<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 () nimmt eine JSON-Zeichenfolge und wandelt sie in ein JavaScript-Objekt um.

JSON.stringify () nimmt ein JavaScript-Objekt und wandelt es in eine JSON-Zeichenfolge um.

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"]