排序对象属性和JSON.stringify

94

我的应用程序具有大量对象，我将它们进行字符串化并将其保存到磁盘。不幸的是，当数组中的对象被操纵并且有时被替换时，对象上的属性以不同的顺序列出（它们的创建顺序？）。当我在数组上执行JSON.stringify（）并将其保存时，一个diff显示以不同顺序列出的属性，当尝试使用diff和合并工具进一步合并数据时，这很烦人。

理想情况下，我想在执行字符串化之前或作为字符串化操作的一部分，按字母顺序对对象的属性进行排序。有许多代码可以在许多地方操纵数组对象，而更改它们以始终以显式顺序创建属性将很困难。

建议将是最欢迎的！

一个简洁的例子：

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

这两个string化调用的输出是不同的，并显示在我的数据中，但是我的应用程序并不关心属性的顺序。这些对象以多种方式和位置构造。

javascript  json 
— 创新
source
请提供您要进行字符串化的对象的示例（JSON输出或JS对象文字）
— Bojangles
4
不保证对象中的对象键具有固定的顺序。这是设计使然。
— 路人2013年
1
— Satpal
1
@rab，您在哪里找到的？注意：它可以工作（并且可能在大多数时候都可以工作），但是我的意思是不能保证。
— Dogbert
1
OP在这里。这里不依赖于属性顺序，只是一个关于如何避免序列化数据中差异的问题。最终，通过将属性存储在数组中并在序列化之前对它们进行排序来解决此问题，就像在下面的可接受答案中一样。
— Innovine

Answers:

73

更简单，现代且当前受浏览器支持的方法如下：

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

要通过编程进行一些调整，您需要将对象的属性名称放入数组中，然后按字母顺序对数组进行排序，然后遍历该数组（顺序正确），然后从对象中选择每个值那个命令。同时也检查“ hasOwnProperty”，因此您绝对只有对象自己的属性。这是一个例子：

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

同样，这应确保您按字母顺序进行遍历。

最后，以最简单的方式进行扩展，该库将递归地允许您对传递给它的JSON进行排序：https : //www.npmjs.com/package/json-stable-stringify

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}
— Markyzm
source
9
这是我一直在努力避免的事情：)但是，谢谢，似乎是正确的解决方案，即使沉重的解决方案也是如此。
— Innovine
1
这段代码中有一个错误。您不能obj[i]在for循环中进行引用，因为它i是一个整数，并且属性名称不一定是（因此有此问题）。应该是obj[arr[i]]。
— Andrew Ensley 2013年
1
回调并非异步行为所独有。
— markyzm 2015年
2
@Johann通过在此处使用回调，他变成iterateObjectAlphabetically了可重用的函数。如果没有回调，则“有效载荷代码”将必须在函数本身内部。我认为这是一个非常优雅的解决方案，并且已在许多库和JS核心本身中使用。例如Array.forEach。
— Stijn de Witt
1
@marksyzm没关系，就我而言，我只需要对一部分字段进行字符串化处理。因此，您的回答使我陷入困境。谢谢
— Benj
39

我认为，如果您控制着JSON的生成（听起来像是这样），那么出于您的目的，这可能是一个不错的解决方案：json-stable-stringify

从项目网站：

具有自定义排序的确定性JSON.stringify（），可从字符串化结果中获取确定性哈希

如果生成的JSON是确定性的，则您应该可以轻松地对其进行比较/合并。

— 斯蒂金·维特
source
请注意，该存储库的状态不佳：3年未更新，并且有未解决的问题和请求请求。我认为最好查看一些较新的答案。
— 汤姆（Tom）
3
@Tom还请注意，该存储库每周有500万次下载（！）。换句话说，它正在被积极使用。拥有“未解决”的未解决问题和/或请求请求并没有多大意义。只是作者不在乎这些问题或没有时间等。并不是每个库都需要每隔几个月更新一次。实际上，恕我直言，最好的库很少获得更新。当某件事完成时，它就完成了。我并不是说这个项目没有实际问题，但是如果是这样，请指出。我没有参与这个lib BTW。
— Stijn de Witt
ES6我猜想它能够按指定的顺序对对象（非数组）进行排序。我需要此文件进行用户编辑。即使顺序对计算机也没有关系。它对用户进行编辑。值得尝试。
— TamusJRoyce
除了@Tom所说的之外，我还要指出该项目没有运行时依赖项。这意味着，如果此存储库中没有安全/维护问题，那么它可能相当稳定且可以安全使用。另外，我刚刚在ES6上进行了测试，它似乎运行良好（至少在Firefox中）。
— Phil
27

您可以传递属性名称的排序数组作为的第二个参数JSON.stringify()：

JSON.stringify(obj, Object.keys(obj).sort())
— 克里斯蒂安·德·赫里乌斯
source
1
是否有任何有关此行为的书面保证？
— 富人remer
4
@richremer是的，在ECMAScript标准中，的第二个参数JSON.stringify()被调用replacer并且可以是一个数组。它用于构建PropertyList，然后用于SerializeJSONObject()按该顺序附加属性。这是自5的ECMAScript记录
— 基督教D'Heureuse
14
注意，如果obj中有嵌套对象，则嵌套键也必须出现在第二个参数中；否则，它们将被丢弃！反例：> JSON.stringify({a: {c: 1, b: 2}}, ['a']) '{"a":{}}' 一种构建所有相关键的列表的（棘手的）方法是使用JSON.stringify遍历对象： function orderedStringify(obj) { const allKeys = []; JSON.stringify(obj, (k, v) => { allKeys.push(k); return v; }); return JSON.stringify(obj, allKeys.sort()); } 示例：> orderedStringify({a: {c: 1, b: 2}}) '{"a":{"b":2,"c":1}}'
— Saif Hakim
Object.keys（）不是递归的。这不适用于任何包含嵌套数组或对象的对象。
— JOR
25

我不明白为什么要递归地获取所有密钥，为什么需要当前最佳答案的复杂性。除非需要完美的性能，在我看来，我们只能打JSON.stringify()两次电话，第一次是获取所有密钥，第二次是真正完成这项工作。这样，所有的递归复杂度都由来处理stringify，我们知道它知道其内容以及如何处理每种对象类型：

function JSONstringifyOrder( obj, space )
{
    var allKeys = [];
    JSON.stringify( obj, function( key, value ){ allKeys.push( key ); return value; } )
    allKeys.sort();
    return JSON.stringify( obj, allKeys, space );
}
— 乔尔
source
那很有趣，但实际上您已经使用stringify将所有键映射到数组“欺骗了”。该数组可以更容易，更好地和经由Object.keys得到更安全
— Z. Khullah
5
不，要点是它Object.keys()不是递归的，因此，如果您有一个类似的对象，{a: "A", b: {c: "C"} }并且在其上调用Object.keys，则只会获取key a和b，而不是c。JSON.stringify知道关于JSON序列化过程处理的每个对象类型的递归的所有信息，无论是类似于对象的对象还是数组（并且它已经实现了识别两者的逻辑），因此它应该为我们正确处理所有内容。
— 约旦
1
喜欢这个解决方案，看起来非常优雅，而且很安全。
— 马库斯
14

更新2018-7-24：

此版本对嵌套对象进行排序，并且还支持数组：

function sortObjByKey(value) {
  return (typeof value === 'object') ?
    (Array.isArray(value) ?
      value.map(sortObjByKey) :
      Object.keys(value).sort().reduce(
        (o, key) => {
          const v = value[key];
          o[key] = sortObjByKey(v);
          return o;
        }, {})
    ) :
    value;
}


function orderedJsonStringify(obj) {
  return JSON.stringify(sortObjByKey(obj));
}

测试用例：

  describe('orderedJsonStringify', () => {
    it('make properties in order', () => {
      const obj = {
        name: 'foo',
        arr: [
          { x: 1, y: 2 },
          { y: 4, x: 3 },
        ],
        value: { y: 2, x: 1, },
      };
      expect(orderedJsonStringify(obj))
        .to.equal('{"arr":[{"x":1,"y":2},{"x":3,"y":4}],"name":"foo","value":{"x":1,"y":2}}');
    });

    it('support array', () => {
      const obj = [
        { x: 1, y: 2 },
        { y: 4, x: 3 },
      ];
      expect(orderedJsonStringify(obj))
        .to.equal('[{"x":1,"y":2},{"x":3,"y":4}]');
    });

  });

不建议使用的答案：

ES2016中的简洁版本。来自https://stackoverflow.com/a/29622653/94148的 @codename 

function orderedJsonStringify(o) {
  return JSON.stringify(Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {}));
}
— 阿龙
source
语法不太正确。应该是-function orderedJsonStringify(o) { return JSON.stringify(Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {})); }
— 奔
目前，这已解决了C＃DataContractJsonSerializer和“ __type”未在json字符串中首先列出的问题。谢谢。
— 智者酸奶
2
请注意，这与Christian的答案一样，对嵌套对象有不良行为。
— 丹尼尔·格里斯康
未定义sortObjPropertiesByKey。您是要使用sortObjByKey吗？
— 保罗·林奇
似乎并没有sortObjByKey()检查循环引用，因此请小心，它可能会死于无限循环，具体取决于输入数据。例如：var objA = {}; var objB = {objA: objA}; objA.objB = objB;-> sortObjByKey(objA);->VM59:6 Uncaught RangeError: Maximum call stack size exceeded
— Klesun '19
4

这与Satpal Singh的答案相同

function stringifyJSON(obj){
    keys = [];
    if(obj){
        for(var key in obj){
            keys.push(key);
        }
    }
    keys.sort();
    var tObj = {};
    var key;
    for(var index in keys){
        key = keys[index];
        tObj[ key ] = obj[ key ];
    }
    return JSON.stringify(tObj);
}

obj1 = {}; obj1.os="linux"; obj1.name="X";
stringifyJSON(obj1); //returns "{"name":"X","os":"linux"}"

obj2 = {}; obj2.name="X"; obj2.os="linux";
stringifyJSON(obj2); //returns "{"name":"X","os":"linux"}"
— Giridhar CR
source
3

您可以添加自定义 toJSON向您的对象函数，以用于自定义输出。在函数内部，按特定顺序将当前属性添加到新对象应在字符串化时保留该顺序。

看这里：

https://developer.mozilla.org/zh-CN/docs/JavaScript/Reference/Global_Objects/JSON/stringify

没有用于控制排序的内置方法，因为JSON数据是通过键访问的。

这是一个带有小示例的jsfiddle：

http://jsfiddle.net/Eq2Yw/

尝试注释该toJSON函数-属性的顺序相反。请注意，这可能是特定于浏览器的，即规范中不正式支持订购。它可以在当前版本的Firefox中运行，但是如果您想要100％健壮的解决方案，则可能必须编写自己的stringifier函数。

编辑：

另请参阅有关SO的不确定性输出的SO问题，尤其是Daff关于浏览器差异的详细信息：

如何确定性地验证尚未修改JSON对象？

— 戴夫·R
source
每个对象的属性都是已知的（并且大多数是字符串），因此在我自己的toJSON字符串化器中对属性进行硬编码可能比排序快得多！
— Innovine 2013年
下面的“ orderedJsonStringify”几乎可以正常工作。但这对我来说似乎是一个更好的解决方案。当我需要获取C＃DataContractJsonSerializer的'__type'作为json字符串中的第一项时。var json = JSON.stringify（myjsonobj，['__type'，'id'，'text'，'somesubobj'等.....））; 列出所有键有些痛苦。
— 智者酸奶
3

递归和简化的答案：

function sortObject(obj) {
    if(typeof obj !== 'object')
        return obj
    var temp = {};
    var keys = [];
    for(var key in obj)
        keys.push(key);
    keys.sort();
    for(var index in keys)
        temp[keys[index]] = sortObject(obj[keys[index]]);       
    return temp;
}

var str = JSON.stringify(sortObject(obj), undefined, 4);
— 杰森·帕拉姆（Jason Parham）
source
reorder应该重命名为sortObject，这不能处理数组
— Jonathan Gawrych
感谢您注意到这一点，OP的问题是使用对象而不是数组。
— 杰森·帕拉姆
@JonathanGawrych您为什么仍然要对数组排序，它们应该有顺序。数组[1,2,3]与数组[2,3,1]不同，但是对象没有属性顺序。问题是字符串化后顺序突然变得很重要-100％等效对象的字符串可能不同。不幸的是得到一个确定的字符串化的努力似乎相当可观，例如包：github.com/substack/json-stable-stringify/blob/master/index.js
— Mörre
1
@Mörre-我想我还不够具体。所谓“不处理数组”，是指数组坏了，没有未排序。问题是因为typeof arr === "object"它将数组转换成对象。例如，var obj = {foo: ["bar", "baz"]}将其{ "foo": { "0": "bar", "1": "baz"} }
— 归类
解决@JonathanGawrych发现的问题：if(obj.constructor.prototype !== Object.prototype)
— ricka
3

您可以在EcmaScript 2015中按属性名称对对象进行排序

function sortObjectByPropertyName(obj) {
    return Object.keys(obj).sort().reduce((c, d) => (c[d] = obj[d], c), {});
}
— 梅吉·内基（Mayki Nayki）
source
更好的名字也许会sortObjectPropertiesByName()或更简单sortPropertiesByName()。
— 扬
3

我从@Jason Parham那里得到了答案，并做了一些改进

function sortObject(obj, arraySorter) {
    if(typeof obj !== 'object')
        return obj
    if (Array.isArray(obj)) {
        if (arraySorter) {
            obj.sort(arraySorter);
        }
        for (var i = 0; i < obj.length; i++) {
            obj[i] = sortObject(obj[i], arraySorter);
        }
        return obj;
    }
    var temp = {};
    var keys = [];
    for(var key in obj)
        keys.push(key);
    keys.sort();
    for(var index in keys)
        temp[keys[index]] = sortObject(obj[keys[index]], arraySorter);       
    return temp;
}

这解决了将数组转换为对象的问题，并且还允许您定义如何对数组进行排序。

例：

var data = { content: [{id: 3}, {id: 1}, {id: 2}] };
sortObject(data, (i1, i2) => i1.id - i2.id)

输出：

{content:[{id:1},{id:2},{id:3}]}
— 彼得
source
2

由于某种原因，对于嵌套对象，可接受的答案对我不起作用。这导致我自己编写代码。当我写这篇文章时是2019年末，该语言中还有更多可用选项。

更新：我相信大卫·弗隆（David Furlong）的答案是我较早尝试的一种较好的方法，而我已将其消除了。我的依赖于对Object.entries（...）的支持，因此没有Internet Explorer支持。

function normalize(sortingFunction) {
  return function(key, value) {
    if (typeof value === 'object' && !Array.isArray(value)) {
      return Object
        .entries(value)
        .sort(sortingFunction || undefined)
        .reduce((acc, entry) => {
          acc[entry[0]] = entry[1];
          return acc;
        }, {});
    }
    return value;
  }
}

JSON.stringify(obj, normalize(), 2);

-

保留此旧版本以供参考

我发现该对象中所有键的简单平面数组将起作用。由于Array.prototype.flatMap（...）可用，因此在几乎所有浏览器（可以预见的不是Edge或Internet Explorer）和Node 12+中，都有一个相当短的解决方案。（等效的破折号也可以使用。）我仅在Safari，Chrome和Firefox中进行了测试，但是我看不出为什么它在其他任何支持flatMap和标准JSON.stringify（...）的地方都无法工作。

function flattenEntries([key, value]) {
  return (typeof value !== 'object')
    ? [ [ key, value ] ]
    : [ [ key, value ], ...Object.entries(value).flatMap(flattenEntries) ];
}

function sortedStringify(obj, sorter, indent = 2) {
  const allEntries = Object.entries(obj).flatMap(flattenEntries);
  const sorted = allEntries.sort(sorter || undefined).map(entry => entry[0]);
  return JSON.stringify(obj, sorted, indent);
}

这样，您就可以在没有第三方依赖的情况下进行字符串化，甚至可以传递自己的对键值条目对进行排序的排序算法，因此您可以按键，有效负载或二者的组合进行排序。适用于嵌套对象，数组以及普通旧数据类型的任何混合。

const obj = {
  "c": {
    "z": 4,
    "x": 3,
    "y": [
      2048,
      1999,
      {
        "x": false,
        "g": "help",
        "f": 5
      }
    ]
  },
  "a": 2,
  "b": 1
};

console.log(sortedStringify(obj, null, 2));

印刷品：

{
  "a": 2,
  "b": 1,
  "c": {
    "x": 3,
    "y": [
      2048,
      1999,
      {
        "f": 5,
        "g": "help",
        "x": false
      }
    ],
    "z": 4
  }
}

如果必须与旧的JavaScript引擎兼容，则可以使用这些稍微更详细的版本来模拟flatMap行为。客户端必须至少支持ES5，因此没有Internet Explorer 8或更低版本。

这些将返回与上面相同的结果。

function flattenEntries([key, value]) {
  if (typeof value !== 'object') {
    return [ [ key, value ] ];
  }
  const nestedEntries = Object
    .entries(value)
    .map(flattenEntries)
    .reduce((acc, arr) => acc.concat(arr), []);
  nestedEntries.unshift([ key, value ]);
  return nestedEntries;
}

function sortedStringify(obj, sorter, indent = 2) {
  const sortedKeys = Object
    .entries(obj)
    .map(flattenEntries)
    .reduce((acc, arr) => acc.concat(arr), [])
    .sort(sorter || undefined)
    .map(entry => entry[0]);
  return JSON.stringify(obj, sortedKeys, indent);
}
— 迈尔斯·埃兰
source
1

适用于lodash，嵌套对象，对象属性的任何值：

function sort(myObj) {
  var sortedObj = {};
  Object.keys(myObj).sort().forEach(key => {
    sortedObj[key] = _.isPlainObject(myObj[key]) ? sort(myObj[key]) : myObj[key]
  })
  return sortedObj;
}
JSON.stringify(sort(yourObj), null, 2)

依靠Chrome和Node的行为，分配给对象的第一个键首先由输出JSON.stringify。

— AJP
source
2
谢谢，但是我在4年前遇到了这个问题，我很高兴地说从那时起我一直在
— 前进
1
:)很高兴听到它。虽然我昨天遇到了这个问题，却没有找到我在您的问题（一直存在但仍然相关的问题）下的答案：）
— AJP
0

尝试：

function obj(){
  this.name = '';
  this.os = '';
}

a = new obj();
a.name = 'X',
a.os = 'linux';
JSON.stringify(a);
b = new obj();
b.os = 'linux';
b.name = 'X',
JSON.stringify(b);
— 3年3
source
谢谢，但是显然顺序是不确定的，只能碰巧起作用。有趣的方法！
— Innovine
0

我做了一个函数来对对象进行排序，并使用回调..实际上创建了一个新对象

function sortObj( obj , callback ) {

    var r = [] ;

    for ( var i in obj ){
        if ( obj.hasOwnProperty( i ) ) {
             r.push( { key: i , value : obj[i] } );
        }
    }

    return r.sort( callback ).reduce( function( obj , n ){
        obj[ n.key ] = n.value ;
        return obj;
    },{});
}

并用object调用它。

var obj = {
    name : "anu",
    os : "windows",
    value : 'msio',
};

var result = sortObj( obj , function( a, b ){
    return a.key < b.key  ;    
});

JSON.stringify( result )

哪个打印{"value":"msio","os":"windows","name":"anu"}，并与价值排序。

var result = sortObj( obj , function( a, b ){
    return a.value < b.value  ;    
});

JSON.stringify( result )

哪个打印 {"os":"windows","value":"msio","name":"anu"}

— 拉布
source
1
效果很好，但是不幸的是它不是递归的。
— Jonathan Gawrych
0

如果列表中的对象不具有相同的属性，请在进行字符串化之前生成一个组合的主对象：

let arr=[ <object1>, <object2>, ... ]
let o = {}
for ( let i = 0; i < arr.length; i++ ) {
  Object.assign( o, arr[i] );
}
JSON.stringify( arr, Object.keys( o ).sort() );
展开摘要

— 尼尔斯·吉丁·奥尔森
source
0 
function FlatternInSort( obj ) {
    if( typeof obj === 'object' )
    {
        if( obj.constructor === Object )
        {       //here use underscore.js
            let PaireStr = _( obj ).chain().pairs().sortBy( p => p[0] ).map( p => p.map( FlatternInSort ).join( ':' )).value().join( ',' );
            return '{' + PaireStr + '}';
        }
        return '[' + obj.map( FlatternInSort ).join( ',' ) + ']';
    }
    return JSON.stringify( obj );
}

//示例如下。在每一层中，对于{}等对象，按键排序进行展平。用于数组，数字或字符串，像JSON.stringify一样扁平化。

FlatternInSort（{c：9，b：{y：4，z：2，e：9}，F：4，a：[{j：8，h：3}，{a：3，b：7}] }）

“ {” F“：4，” a“：[{” h“：3，” j“：8}，{” a“：3，” b“：7}]，” b“：{” e“ ：9，“ y”：4，“ z”：2}，“ c”：9}“

— 圣托
source
请解释为什么使用外部库，正如@DeKaNszn所说，添加一些解释和介绍。将不胜感激。
— 杰
此功能是从我的项目中复制的。我在其中使用underscore.js。
— saintthor
0

扩展AJP的答案，以处理数组：

function sort(myObj) {
    var sortedObj = {};
    Object.keys(myObj).sort().forEach(key => {
        sortedObj[key] = _.isPlainObject(myObj[key]) ? sort(myObj[key]) : _.isArray(myObj[key])? myObj[key].map(sort) : myObj[key]
    })
    return sortedObj;
}
— bl
source
0

惊讶的是没有人提到lodash的isEqual功能。

在两个值之间进行深度比较以确定它们是否等效。

注意：此方法支持比较数组，数组缓冲区，布尔值，日期对象，错误对象，映射，数字，对象对象，正则表达式，集合，字符串，符号和类型化数组。对象对象通过它们自己的（而不是继承的）可枚举属性进行比较。通过严格相等（即===）比较函数和DOM节点。

https://lodash.com/docs/4.17.11#isEqual

最初的问题-密钥的顺序不一致-这是一个很好的解决方案-当然，如果发现冲突，它将停止，而不是盲目地序列化整个对象。

为了避免导入整个库，请执行以下操作：

import { isEqual } from "lodash-es";

奖励示例：您也可以将此RxJS与此自定义运算符一起使用

export const distinctUntilEqualChanged = <T>(): MonoTypeOperatorFunction<T> => 
                                                pipe(distinctUntilChanged(isEqual));
— 西蒙·韦弗
source
0

毕竟，它需要一个可在嵌套对象中缓存所有键的Array（否则它将忽略未缓存的键。）最早的答案是完全错误的，因为第二个参数并不关心点符号。因此，答案（使用Set）变为。

function stableStringify (obj) {
  const keys = new Set()
  const getAndSortKeys = (a) => {
    if (a) {
      if (typeof a === 'object' && a.toString() === '[object Object]') {
        Object.keys(a).map((k) => {
          keys.add(k)
          getAndSortKeys(a[k])
        })
      } else if (Array.isArray(a)) {
        a.map((el) => getAndSortKeys(el))
      }
    }
  }
  getAndSortKeys(obj)
  return JSON.stringify(obj, Array.from(keys).sort())
}
— 波尔夫
source
0

这是一种克隆方法...在转换为json之前先克隆对象：

function sort(o: any): any {
    if (null === o) return o;
    if (undefined === o) return o;
    if (typeof o !== "object") return o;
    if (Array.isArray(o)) {
        return o.map((item) => sort(item));
    }
    const keys = Object.keys(o).sort();
    const result = <any>{};
    keys.forEach((k) => (result[k] = sort(o[k])));
    return result;
}

If非常新，但似乎可以在package.json文件上正常工作。

— 科里·阿里克斯
source
-3

有一种Array.sort方法可能对您有所帮助。例如：

yourBigArray.sort(function(a,b){
    //custom sorting mechanism
});
— Egor4eg
source
1
我不想排序数组。实际上，数组部分并不重要。.我希望对对象的属性进行排序..从一些快速实验中，看起来属性按照创建顺序列出。一种方式是创建一个新的对象，并复制按字母顺序排列的属性，但我希望能有一些更简单/快..
— Innovine
1
@Innovine，即使那样也行不通，因为规范不能保证按创建时间对键进行排序。
— Dogbert
然后，问题就变成了，如何以固定的键顺序对对象进行字符串化处理..对我来说，并非不可能（将obj中的键）存储在临时数组中并手动对其进行排序构造一个字符串..但我非常希望有一种更简单的方法
— Innovine
不，那是差不多的方法。欢迎使用JavaScript。
— markyzm 2013年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.