更简单、现代且当前浏览器支持的方法很简单：

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;
};
var myFlattenedObj = flattenObject(sortMyObj);
JSON.stringify(myFlattenedObj, Object.keys(myFlattenedObj).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}

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

function JSONstringifyOrder( obj, space )
{
    var allKeys = [];
    var seen = {};
    JSON.stringify(obj, function (key, value) {
        if (!(key in seen)) {
            allKeys.push(key);
            seen[key] = null;
        }
        return value;
    });
    allKeys.sort();
    return JSON.stringify(obj, allKeys, space);
}

我认为，如果您可以控制 JSON 生成（听起来像您一样），那么就您的目的而言，这可能是一个很好的解决方案：json-stable-stringify

从项目网站：

确定性 JSON.stringify() 使用自定义排序从字符串化结果中获取确定性哈希

如果生成的 JSON 是确定性的，您应该能够轻松地对其进行区分/合并。

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

JSON.stringify(obj, Object.keys(obj).sort())

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 中的简洁版本。归功于 @codename ，来自https://stackoverflow.com/a/29622653/94148

function orderedJsonStringify(o) {
  return JSON.stringify(Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {}));
}