obj = {}; obj.name="X"; obj.os="linux";JSON.stringify(obj);obj = {}; obj.os="linux"; obj.name="X";JSON.stringify(obj);

JSON.stringify(sortMyObj, Object.keys(sortMyObj).sort());

{"a":{"h":4,"z":3},"b":2,"c":1}

var flattenObject = function(ob) {    var toReturn = {};    for (var i in ob) {        if (!ob.hasOwnProperty(i)) continue;        if ((typeof ob[i]) == ''object'') {            var flatObject = flattenObject(ob[i]);            for (var x in flatObject) {                if (!flatObject.hasOwnProperty(x)) continue;                toReturn[i + ''.'' + x] = flatObject[x];            }        } else {            toReturn[i] = ob[i];        }    }    return toReturn;};JSON.stringify(sortMyObj, Object.keys(flattenObject(sortMyObj)).sort());

var obj = {"a":1,"b":2,"c":3};function iterateObjectAlphabetically(obj, callback) {    var arr = [],        i;    for (i in obj) {        if (obj.hasOwnProperty(i)) {            arr.push(i);        }    }    arr.sort();    for (i = 0; i < arr.length; i++) {        var key = obj[arr[i]];        //console.log( obj[arr[i]] ); //here is the sorted value        //do what you want with the object property        if (callback) {            // callback returns arguments for value, key and original object            callback(obj[arr[i]], arr[i], obj);        }    }}iterateObjectAlphabetically(obj, function(val, key, obj) {    //do something here});

var stringify = require(''json-stable-stringify'');var obj = { c: 8, b: [{z:6,y:5,x:4},7], a: 3 };console.log(stringify(obj));

{"a":3,"b":[{"x":4,"y":5,"z":6},7],"c":8}

" + str_pretty1 + "

" + str_pretty2 + "

JSON.parse()和JSON.stringify(),这两个JavaScript内置的方法，对低版本浏览器不兼容，。

需要引入JSON2.js插件

JSON.parse()和JSON.stringify()

JSON.stringify(value [,replacer] [,space])

          
          

           
           
varcontact=newObject();
           
           
contact.firstname="Jesper";
           
           
contact.surname="Aaberg";
           
           
contact.phone=["555-0100","555-0120"];
           
           

           
           
varmemberfilter=newArray();
           
           
memberfilter[0]="surname";
           
           
memberfilter[1]="phone";
           
           
varjsonText=JSON.stringify(contact,memberfilter,"\t");
           
           
document.write(jsonText);
           
           
//Output:
           
           
//{"surname":"Aaberg","phone":["555-0100","555-0120"]}
          
          

          
          

           
           
varcontinents=newArray();
           
           
continents[0]="Europe";
           
           
continents[1]="Asia";
           
           
continents[2]="Australia";
           
           
continents[3]="Antarctica";
           
           
continents[4]="northAmerica";
           
           
continents[5]="SouthAmerica";
           
           
continents[6]="Africa";
           
           

           
           
varjsonText=JSON.stringify(continents,replacetoupper);
           
           

           
           
functionreplacetoupper(key,value){
           
           
returnvalue.toString().toupperCase();
           
           
}
           
           

           
           
//Output:
           
           
//"EUROPE,ASIA,AUSTRALIA,ANTARCTICA,norTHAMERICA,SOUTHAMERICA,AFRICA"
          
          

          
          

           
           
varcontact=newObject();
           
           
contact.firstname="Jesper";
           
           
contact.surname="Aaberg";
           
           
contact.phone=["555-0100","555-0120"];
           
           

           
           
contact.toJSON=function(key)
           
           
{
           
           
varreplacement=newObject();
           
           
for(varvalinthis)
           
           
{
           
           
if(typeof(this[val])==='string')
           
           
replacement[val]=this[val].toupperCase();
           
           
else
           
           
replacement[val]=this[val]
           
           
}
           
           
returnreplacement;
           
           
};
           
           

           
           
varjsonText=JSON.stringify(contact);
           
           
document.write(jsonText);
           
           

           
           
//Output:
           
           
{"firstname":"JESPER","surname":"AABERG","phone":["555-0100","555-0120"]}
           
           

           
           

           
           

           
           
'{"firstname":"JESPER","surname":"AABERG","555-0120"]}'
           
           
*/
          
          

JSON.parse()和JSON.stringify()--json对象<=>字符串

1.parse 用于从一个字符串中解析出json 对象。例如

var str='{"name":"cpf","age":"23"}'

经 JSON.parse(str) 得到：

Object: age:"23"

name:"cpf"

_proto_:Object

ps:单引号写在{}外，每个属性都必须双引号，否则会抛出异常

2.stringify用于从一个对象解析出字符串，例如

var a={a:1,b:2}

经 JSON.stringify(a)得到：

“{“a”:1,"b":2}”

JSON.stringify()和JSON.parse()

我们知道，JSON.stringify() 和 JSON.parse() 是一对处理JSON数据的方法，前者是将JSON对象序列化为字符串，而后者是将JSON字符串解析为JSON对象。

但是你有较为深入地去了解过它们吗？它们分别可以传入几个参数以及每个参数对应的作用是什么呢？

一、JSON.stringify()

JSON.stringify() 方法能将一个 JavaScript 对象或值转换成一个 JSON 字符串，是用于调试的最常见函数。

//初始化一个 user 对象
const user = {
    "name": "Mark Lee", 
    "age":26
}
console.log(JSON.stringify(user));
// 结果
// "{"name":"Prateek Singh","age":26}"

一般来说，开发人员使用 stringify 函数的场景较为普遍，就像上面做的那样。但我要告诉你一些隐藏的秘密，这些小秘密会让你开发起来更加轻松。

JSON.stringify 基础语法

JSON.stringify(value[, replacer [, space]])

它可以传入三个参数，参数1 是需要字符串化的对象，参数2 是用于指定对象序列化过程中需要被处理的属性，参数3 是用于指定输出字符串的缩进格式。后两个参数是可选的，而我们最常用的就是只传一个参数。

第一个参数

需要字符串化的对象，且该对象须是安全的JSON对象，而对于不安全的JSON对象都不能被正常序列化。

1、不安全的JSON对象

何为不安全的JSON对象？

undefined、function、symbol和包含循环的引用的对象都不符合JSON结构标准，所以它们本身以及包含它们的对象都是不安全的JSON对象。

那么对于不安全的JSON对象，JSON.stringify()会如何处理它们呢？

1) undefined、function、symbol

单独处理它们，直接返回undefined。

JSON.stringify(undefined);    //  undefined
JSON.stringify(function(){});    //  undefined
JSON.stringify(Symbol());    //  undefined

包含它们的对象，自动将其忽略。

JSON.stringify({a:1, b:undefined, c:function(){}, [Symbol()]:1});    //  "{"a":1}"

包含它们的数组，自动将其转成null

JSON.stringify([1,undefined,function(){},Symbol()]);    //  "[1,null,null,null]"

2) 包含循环引用的对象

如果两个对象之间互相引用，形成一个无限循环，那么无论对其中的哪个对象进行JSON字符串化都会直接报错

var obj1 = {};
var obj2 = {
  a: obj1
};
obj1.a = obj2;
JSON.stringify(obj1);  //  Uncaught TypeError
JSON.stringify(obj2);  //  Uncaught TypeError

2、含有toJSON()方法的对象

对该类对象进行JSON字符串化，会先调用toJSON()方法，然后用它的返回值来进行序列化，而不是将整个对象转换为字符串。

const user = {
    firstName:"Mark",
    lastName:"Lee",
    age:26,
    toJSON(){
        return{
            fullName:`${this.firstName} + ${this.lastName}`
        };
    }
}
JSON.stringify(user);
//"{"fullName":"Mark + Lee"}"

这里我们可以看到，它只打印 toJSON 函数的结果，而不是打印整个对象。
再举个栗子:

var obj = {
  a: 1,
  toJSON(){
    return function(){}
  }
};
JSON.stringify(obj);  //  undefined

正常按照前面讲的忽略function来说应该要返回"{"a":1}"才对嘛，为啥是undefined呢? 这就是因为包含toJSON()方法的缘故，只要有它，直接就处理它的返回值。上例中因为toJSON()方法返回值是个不安全的JSON对象，所以就按照前面 1 中讲的方式来处理了。
下面的栗子看的更清楚一些:

var obj = {
  a: 1,
  toJSON(){
    return [1,undefined,function(){},Symbol()]
  }
};
JSON.stringify(obj);  //  "[1,null,null,null]"

第二个参数（数组）

是的，stringify 函数也可以有第二个参数。它是要在控制台中打印的对象的键数组。看起来很简单？让我们更深入一点。我们有一个对象 product 并且我们想知道 product 的 name 属性值。当我们将其打印出来：它会输出下面的结果。

{"id":"0001","type":"donut","name":"Cake","ppu":0.55,"batters":{"batter":[{"id":"1001","type":"Regular"},{"id":"1002","type":"Chocolate"},{"id":"1003","type":"Blueberry"},{"id":"1004","type":"Devil’s Food"}]},"topping":[{"id":"5001","type":"None"},{"id":"5002","type":"Glazed"},{"id":"5005","type":"Sugar"},{"id":"5007","type":"Powdered Sugar"},{"id":"5006","type":"Chocolate with Sprinkles"},{"id":"5003","type":"Chocolate"},{"id":"5004","type":"Maple"}]}

在日志中很难找到 name 键，因为控制台上显示了很多没用的信息。当对象变大时，查找属性的难度增加。stringify 函数的第二个参数这时就有用了。让我们重写代码并查看结果

JSON.stringify(product,[''name''])
// "{"name":"Cake"}"

第二个参数（函数）

我们还可以传入函数作为第二个参数。它根据函数中写入的逻辑来计算每个键值对。如果返回 undefined，则不会打印键值对。

const user = {
    "name": "Mark Lee", 
    "age":26
}
JSON.stringify(user,(key,value)=>{
    if(typeof value === ''string''){
        return undefined;
    }
    return value;
})
// 结果
// "{"age":26}"

只有 age 被打印出来，因为函数判断 typeOf 为 String 的值返回 undefined。

第三个参数为数字

第三个参数控制最后一个字符串的间距。如果参数是一个数字，则字符串化中的每个级别都将缩进这个数量的空格字符。

const user = {
    "name": "Mark Lee", 
    "age":26
}
JSON.stringify(user,null,2);
//"{
//  "name": "Mark Lee",
//  "age": 26
//}"

第三个参数为字符串

如果第三个参数是 string，那么将使用它来代替上面显示的空格字符。

JSON.stringify(user,null,''**'')
//"{
//**"name": "Mark Lee",
//**"age": 26
//}"

二、JSON.parse()

了解完了JSON.stringify()，我们再来看看它的逆操作函数JSON.parse()。

JSON.parse(text[, reviver])

它可以传入两个参数，参数1 是需要被解析的字符串，参数2 是用于修改解析生成的原始值。后一个参数是可选的，而我们最常用的就是只传一个参数。

1. 参数一（text）

该参数必须是符合JSON规范的字符串，如果是其他类型，则会被强制类型转换成字符串格式，如果不符合JSON规范，则会报错。

JSON.parse(''[1,2]'');  // [1,2]
JSON.parse(''null'');  // null
JSON.parse(''false'');  // false
JSON.parse(''{"a":1}'');  // {a: 1}
JSON.parse(''{a:1}'');  // Uncaught SyntaxError
JSON.parse("{''a'':1}");  // Uncaught SyntaxError
JSON.parse(''undefined'');  // Uncaught SyntaxError

注意JSON字符串中的key必须有双引号（单引号也不行），不然是不符合JSON规范的。

2. 参数二（reviver）

该参数是个函数，作用类似于前面JSON.stringify()的第二个参数replacer，同样是对属性进行遍历，同样有key和value两个参数。

var str = ''{"a": 1, "b":2}'';
JSON.parse(str, function(key,value){
  if(key === ''a'') { 
    console.log(value);   //  1
    return function(){} 
  }
  if(key === ''b'') { 
    console.log(value);   //  2
    return ''bbb''
   }
  if(key === '''') { 
    console.log(value);   //  {a: function(){}, b: "bbb"}
    return {a:1,c:2}
  }
});   //  {a: 1, c: 2}

前面属性的遍历可以修改输出对象的属性值，但最终输出的值关键还是取决于key为空字符串时的返回值，它可以将之前所有的努力都变为徒劳。

总结

• 单独字符串化undefined、function和symbol结果都为undefined；
• 字符串化含有undefined、function和symbol的对象，这些值所在的属性都会被忽略；
• 字符串化含有undefined、function和symbol的数组，这些值都会被转化为null；
• 字符串化含有循环引用的对象会报错；
• 字符串化含有toJSON()方法的对象，会直接字符串化该方法执行的返回值；
• JSON.stringify()的三个参数作用依次为 指定需要字符串化的对象、指定对象序列化过程中需要被处理的属性 和 指定输出字符串的缩进格式；

• JSON.parse()的两个参数作用依次为 指定需要被解析的字符串 和 修改解析生成的原始值。

  两者结合使用场景

  1、localStorage/sessionStorage 存储对象

  我们知道 localStorage/sessionStorage 只可以存储字符串，当我们想存储对象的时候，需要使用 JSON.stringify 转换成字符串，获取的时候再 JSON.parse

  // 存
  function setLocalStorage(key,val) {
    window.localStorage.setItem(key, JSON.stringify(val));
  };
  // 取
  function getLocalStorage(key) {
    let val = JSON.parse(window.localStorage.getItem(key));
    return val;
  };

  2、实现对象深拷贝

  let myIntro = {
  name: ''Gopal'',
  age: 25,
  like: ''FE''
  }
  
  function deepClone() {
  return JSON.parse(JSON.stringify(myIntro))
  }
  
  let copyMe = deepClone(myIntro)
  copyMe.like = ''Fitness''
  console.log(myIntro, copyMe)
  
  // { name: ''Gopal'', age: 25, like: ''FE'' } { name: ''Gopal'', age: 25, like: ''Fitness'' }

今天关于排序对象属性和JSON.stringify和对象的排序的讲解已经结束，谢谢您的阅读，如果想了解更多关于JSON 字符串转换为JavaScript 对象.JSON.parse()和JSON.stringify()、JSON.parse()和JSON.stringify()、JSON.parse()和JSON.stringify()--json对象<=>字符串、JSON.stringify()和JSON.parse()的相关知识，请在本站搜索。