Byłem zdezorientowany, kiedy użyć tych dwóch metod analizy.

Po powtórzeniu moich danych zakodowanych w formacie json i odzyskaniu ich z powrotem za pośrednictwem ajax często wpadam w błąd co do tego, kiedy powinienem użyć JSON.stringify i JSON.parse .

Dostaję się [object,object]do swojego pliku console.log podczas analizowania i obiektu JavaScript podczas tworzenia łańcucha.

$.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 zamienia obiekt JavaScript w tekst JSON i przechowuje ten tekst JSON w ciągu, np .:

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 zamienia ciąg tekstu JSON w obiekt JavaScript, np .:

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()służy do „analizowania” czegoś, co otrzymano jako JSON.
JSON.stringify()jest utworzenie łańcucha JSON z obiektu / tablicy.

Są odwrotni do siebie. JSON.stringify()serializuje obiekt JS do ciągu JSON, a JSON.parse()deserializuje ciąg JSON do obiektu JS.

Są przeciwieństwami.

JSON.stringify ()

JSON.stringify () serializuje obiekt JS lub wartość do ciągu 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 ()

Metoda JSON.parse () analizuje ciąg znaków jako JSON, opcjonalnie przekształcając wygenerowaną wartość.

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

Po pierwsze, JSON.stringify()funkcja konwertuje wartość JavaScript na ciąg JavaScript Object Notation (JSON). JSON.parse()funkcja konwertuje ciąg JSON (JavaScript Object Notation) na obiekt. Więcej informacji na temat tych dwóch funkcji można znaleźć w poniższych linkach.

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

Po drugie, poniższy przykład pomoże ci zrozumieć te dwie funkcje.

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

// Dane wyjściowe będą:

// Dla 1. konsoli jest ciągiem jak:

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

// Dla drugiej konsoli jest obiekt taki jak:

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

JSON.stringify() Konwertuje obiekt na ciąg.

JSON.parse() Konwertuje ciąg JSON na obiekt.

Prawdziwe zamieszanie tutaj nie dotyczy parsowania vs stringify, lecz typu danych dataparametru wywołania zwrotnego sukcesu.

data może być surową odpowiedzią, tzn. łańcuchem, lub może być obiektem JavaScript, zgodnie z dokumentacją:

sukces

Typ: Funkcja (Dowolne dane, ciąg tekstowyStatus, jqXHR jqXHR) Funkcja, która ma zostać wywołana, jeśli żądanie się powiedzie. Funkcja otrzymuje trzy argumenty: Dane zwrócone z serwera, sformatowane zgodnie z parametrem dataType lub funkcją zwrotną dataFilter, jeśli podano; <..>

A dataType domyślnie przyjmuje ustawienie „inteligentnego zgadywania”

dataType (domyślnie: Intelligent Guess (xml, json, script lub html))

Type: String Typ danych, których oczekujesz od serwera. Jeśli nie zostanie podany żaden, jQuery spróbuje wywnioskować to na podstawie typu MIME odpowiedzi (typ XML MIME da XML, w 1.4 JSON da obiekt JavaScript, w 1.4 skrypt wykona skrypt, a wszystko inne będzie zwrócone jako ciąg).

Obiekt JavaScript <-> Ciąg JSON

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

JSON.stringify (obj) - Bierze dowolny obiekt możliwy do serializacji i zwraca reprezentację JSON jako ciąg znaków.

JSON.stringify() -> Object To String.

JSON.parse (ciąg) - Pobiera dobrze sformułowany ciąg JSON i zwraca odpowiedni obiekt JavaScript.

JSON.parse() -> String To Object.

Objaśnienie: JSON.stringify (obj [, replaceer [, spacja]]);

Replacer / Space - opcjonalny lub przyjmuje wartość całkowitą lub można wywołać funkcję return typu interger.

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

• Replacer Wystarczy użyć do zamiany na nieskończony no na null.
• Wykorzystanie miejsca do wcięcia ciągu Json po spacji

Są kompletnym przeciwieństwem siebie.

JSON.parse()służy do analizowania danych odebranych jako JSON ; to deserializes na ciąg JSON do obiektu JavaScript .

JSON.stringify()z drugiej strony służy do tworzenia łańcucha JSON z obiektu lub tablicy ; to serializes do obiektu JavaScript w ciąg JSON .

Nie wiem, czy zostało wspomniane, ale jednym z zastosowań JSON.parse (JSON.stringify (myObject)) jest utworzenie klonu oryginalnego obiektu.

Jest to przydatne, gdy chcesz zepsuć niektóre dane bez wpływu na oryginalny obiekt. Prawdopodobnie nie jest to najczystszy / najszybszy sposób, ale z pewnością najprostszy dla obiektów, które nie są bardzo złożone.

JSON.stringify(obj [, replacer [, space]]) - Bierze dowolny obiekt możliwy do serializacji i zwraca reprezentację JSON jako ciąg znaków.

JSON.parse(string) - Pobiera dobrze sformatowany ciąg JSON i zwraca odpowiedni obiekt JavaScript.

Przeciwstawiają się sobie. JSON.Stringify()konwertuje JSON na ciąg i JSON.Parse()analizuje ciąg na JSON.

JSON: Służy głównie do wymiany danych do / z serwera. Przed wysłaniem obiektu JSON na serwer musi to być ciąg znaków.

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

Konwertuje również tablicę JavaScript na ciąg znaków

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 

Gdy otrzymamy dane JSON z serwera, dane będą miały format ciągów, dlatego konwertujemy ciąg na obiekt 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() służy do konwersji ciągu na obiekt.
JSON.stringify()służy do konwersji Object na String.

Możesz to również odnieść ...

<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 () pobiera ciąg JSON i przekształca go w obiekt JavaScript.

JSON.stringify () pobiera obiekt JavaScript i przekształca go w ciąg 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"]