JSON.parse() jest do "parsowania" czegoś, co zostało odebrane jako JSON.
JSON.stringify() jest utworzenie łańcucha JSON z obiektu / tablicy.

Są odwrotnością siebie nawzajem. JSON.stringify() serializuje obiekt JS do łańcucha JSON, podczas gdy JSON.parse() deserializuje łańcuch JSON do obiektu JS.

Po Pierwsze, JSON.stringify() funkcja konwertuje wartość JavaScript na łańcuch JavaScript Object Notation (JSON). JSON.parse() funkcja konwertuje łańcuch JavaScript Object Notation (JSON) na obiekt. Więcej informacji na temat tych dwóch funkcji można znaleźć pod poniższymi linkami.

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

Po Drugie, poniższa próbka będzie dla ciebie pomocna zrozum 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>

Są przeciwieństwami siebie nawzajem.

JSON.stringify()

JSON.stringify() serializuje obiekt JS do ciągu znaków 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()

JSON.metoda parse () przetwarza łańcuch znaków jako JSON, opcjonalnie przekształcając wytworzoną wartość.

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

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

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

/ / Wyjście będzie:

//dla 1. konsoli jest ciągiem typu:

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

//dla drugiej konsoli jest obiektem typu:

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

JSON.stringify() konwertuje obiekt na łańcuch znaków.

JSON.parse() konwertuje łańcuch JSON na obiekt.

Prawdziwe zamieszanie tutaj nie chodzi o parse vs stringify, ale o typ danych parametru data wywołania zwrotnego sukcesu.

data może być albo surową odpowiedzią, tj. łańcuchem znaków, albo może być obiektem JavaScript, zgodnie z dokumentacją:

Sukces

Type: Function (Anything data, String textStatus, jqXHR jqXHR ) A funkcja, która zostanie wywołana, jeśli żądanie się powiedzie. Funkcja otrzymuje przekazane trzy argumenty: dane zwrócone z serwera, sformatowany zgodnie z parametrem dataType lub wywołaniem zwrotnym dataFilter function, if specified;<..>

I domyślnym typem danych jest ustawienie 'inteligentne zgadywanie'

W tym celu należy skontaktować się z Działem Obsługi Klienta pod adresem .]}

Type: String typ danych, których oczekujesz od serwer. Jeśli nie podano żadnego, jQuery spróbuje wywnioskować na podstawie Typ MIME odpowiedzi (typ MIME XML DA XML, w 1.4 JSON wyda obiekt JavaScript, w 1.4 skrypt wykona skrypt, a Wszystko inne zostanie zwrócone jako ciąg znaków).

Są całkowitym przeciwieństwem siebie.

JSON.parse() służy do parsowanie Dane odebrane jako JSON; to deserializuje a JSON string do obiektu JavaScript.

JSON.stringify() z drugiej strony jest używany do tworzenia JSON string z obiektu lub tablicy; to serializuje a obiekt JavaScript do JSON string.

JSON.stringify(obj [, replacer [, space]]) - pobiera dowolny obiekt serializowalny i zwraca reprezentację JSON jako ciąg znaków.

JSON.parse(string) - pobiera dobrze uformowany łańcuch JSON i zwraca odpowiedni obiekt JavaScript.

Obiekt JavaScript JSON String

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

JSON.stringify (obj) - pobiera dowolny obiekt serializowalny i zwraca reprezentację JSON jako łańcuch znaków.

JSON.stringify() -> Object To String.

JSON.parse ( string) - pobiera dobrze uformowany łańcuch JSON i zwraca odpowiedni obiekt JavaScript.

JSON.parse() -> String To Object.

Wyjaśnienie: JSON.stringify(obj [, replacer [, space]]);

Replacer / Spacja-opcjonalne lub przyjmuje wartość całkowitą lub można wywołać Typ interger return funkcja.

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

• Replacer wystarczy użyć dla replace non finite no Z null.
• użycie przestrzeni do wcięcia ciągu Json przez spację

Przeciwstawiają się sobie. JSON.Stringify() konwertuje JSON na string i JSON.Parse() parsuje łańcuch do JSON.

Nie wiem, czy to było wspomniane, ale jedno z zastosowań JSON.parse (JSON.stringify (myObject)) służy do utworzenia klonu oryginalnego obiektu.

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

JSON: jest używany głównie do wymiany danych do / z serwera. Przed wysłaniem obiekt JSON do serwera, musi być ciągiem 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 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 

Kiedy otrzymaliśmy dane JSON z serwera, dane byłyby w formacie string.W związku z tym zamieniamy łańcuch 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 łańcucha znaków na obiekt.
JSON.stringify() służy do konwersji obiektu na ciąg znaków.

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