事实上，我非常惊讶的是，给出了30多个答案，但没有一个给出了这个问题的完整深度解决方案。有些解决方案很浅，而另一些解决方案很深，但有缺陷（如果未定义，则会崩溃，函数或符号将在json中）。

以下是完整的解决方案：

function sortObject(unordered, sortArrays = false) {
  if (!unordered || typeof unordered !== 'object') {
    return unordered;
  }

  if (Array.isArray(unordered)) {
    const newArr = unordered.map((item) => sortObject(item, sortArrays));
    if (sortArrays) {
      newArr.sort();
    }
    return newArr;
  }

  const ordered = {};
  Object.keys(unordered)
    .sort()
    .forEach((key) => {
      ordered[key] = sortObject(unordered[key], sortArrays);
    });
  return ordered;
}

const json = {
  b: 5,
  a: [2, 1],
  d: {
    b: undefined,
    a: null,
    c: false,
    d: true,
    g: '1',
    f: [],
    h: {},
    i: 1n,
    j: () => {},
    k: Symbol('a')
  },
  c: [
    {
      b: 1,
      a: 1
    }
  ]
};
console.log(sortObject(json, true));

很多人都提到“对象无法排序”，但在那之后，他们给了你一个可行的解决方案。矛盾，不是吗？

没有人提及这些解决方案为何奏效。它们是这样的，因为在大多数浏览器的实现中，对象中的值是按照添加它们的顺序存储的。这就是为什么如果您从排序的键列表中创建新对象，它将返回预期结果。

我认为我们可以再增加一个解决方案——ES5功能方式：

function sortObject(obj) {
    return Object.keys(obj).sort().reduce(function (result, key) {
        result[key] = obj[key];
        return result;
    }, {});
}

上述ES2015版本（格式为“一行”）：

const sortObject = o => Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {})

上述示例的简短解释（如评论中所要求的）：

Object.keys为我们提供了所提供对象（obj或o）中的键列表，然后我们使用默认排序算法对这些键进行排序，接下来使用reduce将数组转换回对象，但这次对所有键进行了排序。

我将一些Java枚举转换为javascript对象。

这些对象为我返回了正确的数组。如果对象键是混合类型（string、int、char），则存在问题。

var助手={isEmpty：函数（obj）{回来obj | | obj===null | | obj===未定义| | Array.isArray（obj）&&obj.length===0；},isObject：函数（obj）{return（对象类型==“object”）；},sortObjectKeys:函数（对象）{return Object.keys（对象）.sort（函数（a，b）{c=a-b；返回c});},containsItem:函数（arr，item）{if（arr&&Array.isArray（arr））{return arr.indexOf（项）>-1；}其他{返回arr==项；}},pushArray：函数（arr1，arr2）{if（arr1&&arr2&&Array.isArray（arr1））{arr1.push.apply（arr1，Array.isArray（arr2）？arr2:[arr2]）；}}};函数TypeHelper（）{var_types=参数[0]，_defTypeIndex＝0，_电流类型，_价值；if（arguments.length==2）{_defTypeIndex=参数[1]；}对象定义属性（this{关键字：{get:函数（）{return _currentType；},集合：函数（val）{_currentType.setType（val，true）；},可枚举：真},值：{get:函数（）{返回类型[_currentType]；},集合：函数（val）{_value.setType（val，false）；},可枚举：真}});this.getAsList=函数（键）{var列表=[]；Helper.sortObjectKeys（_types）.forEach（函数（键、idx、数组）{if（键和类型[key]）{if（！Helper.isEmpty（keys）&&Helper.containsItem（keys，key）|| Helper.isEmpty（key））{var json=｛｝；json.Key=密钥；json.Value=_types[key]；Helper.pushArray（列表，json）；}}});返回列表；};this.setType=函数（值，isKey）{if（！Helper.isEmpty（value））{Object.keys（_types）.forEach（函数（key，idx，array）{if（Helper.isObject（值））{if（value&&value.Key==Key）{_currentType=键；}}else if（isKey）{if（value&&value.toString（）==key.toString（））{_currentType=键；}}否则如果（value&&value.toString（）==_types[key]）{_currentType=键；}});}其他{this.setDefaultType（）；}return isKey_类型[_currentType]：_currentType；};this.setTypeByIndex=函数（索引）{var keys=Helper.sortObjectKeys（_types）；对于（var i=0；i<keys.length；i++）{如果（索引==i）{_currentType=键[index]；打破}}};this.setDefaultType=函数（）{this.setTypeByIndex（_defTypeIndex）；};this.setDefaultType（）；}变量类型A={“-1”：“任意”，“2”：“2L”，“100”：“100L”，“200”：“200L”，“1000”：“1000升”};变量类型B={“U”：“任意”，“W”：“1L”，“V”：“2L”，“A”：“100L”，“Z”：“200L”，“K”：“1000L”};console.log（'keys of TypeA'，Helper.sortObjectKeys（TypeA））//A类钥匙[“-1”、“2”、“100”、“200”、“1000”]console.log（'keys of TypeB'，Helper.sortObjectKeys（TypeB））//B类键[“U”、“W”、“V”、“A”、“Z”、“K”]var objectTypeA=新TypeHelper（TypeA），objectTypeB=新的TypeHelper（TypeB）；console.log（'listofobjectA='，objectTypeA.getAsList（））；console.log（'listofobjectB='，objectTypeB.getAsList（））；

Types:

var TypeA = {
    "-1": "Any",
    "2": "2L",
    "100": "100L",
    "200": "200L",
    "1000": "1000L"
};

var TypeB = {
    "U": "Any",
    "W": "1L",
    "V": "2L",
    "A": "100L",
    "Z": "200L",
    "K": "1000L"
};


Sorted Keys(output):

Key list of TypeA -> ["-1", "2", "100", "200", "1000"]

Key list of TypeB -> ["U", "W", "V", "A", "Z", "K"]

这是一个轻量级的解决方案，可以满足JSON排序所需的一切。

function sortObj(obj) {
    if (typeof obj !== "object" || obj === null)
        return obj;

    if (Array.isArray(obj))
        return obj.map((e) => sortObj(e)).sort();

    return Object.keys(obj).sort().reduce((sorted, k) => {
        sorted[k] = sortObj(obj[k]);
        return sorted;
    }, {});
}

// if keys are char/string
const sortObject = (obj) => Object.fromEntries(Object.entries(obj).sort( ));
let obj = { c: 3, a: 1 };
obj = sortObject(obj)

// if keys are numbers
const sortObject = (obj) => Object.fromEntries(Object.entries(obj).sort( (a,b)=>a-b ));
let obj = { 3: 'c', 1: 'a' };
obj = sortObject(obj)

这里有一个单行解决方案（不是最有效的，但当涉及到像您的示例中那样的瘦对象时，我宁愿使用本机JS函数，也不要使用草率的循环）

const无序=｛“b”：“asdsad”，“c”：“masdas”，“a”：“dsfdsfsdf”｝const ordered=Object.fromEntries（Object.entries（无序）.sort（））console.log（已订购）；//a->b->c