Question

考虑一下：

[{name:'John'},{age:25},{address:'some street'}]

正如您所看到的，没有一个键是一致的名称，所以我无法使用。

arr.sort((a,b)=> a.consistentKey < b.consistentKey);

我如何按名称和价值排序？

所以按字母顺序按键排序的是：

[{address:'some street'},{age:25},{name:'John'}]

Answer 1

如果您正在考虑先根据键进行排序，然后再进一步对值进行排序，可以尝试以下方法：

＆＃13;

var a = [{name:'John'},{age:25},{address:'some street'}];
        
    alert(JSON.stringify(a.sort((a, b) => {
      nameA = Object.keys(a)[0];
      nameB = Object.keys(b)[0];
    
      if (nameA < nameB) {
        return -1;
      }
      if (nameA > nameB) {
        return 1;
      }
    
      // names must be equal
      return 0;
    })));

＆＃13;

这里我只考虑了一个键，但你总是可以将它扩展到多个键，同样你也可以根据值进一步排序。

Answer 2

如果使用Object.keys提取密钥名称，则可以获得执行比较所需的值：

[{name: 'John'}, {age: 25}, {address:'some street'}].sort((a, b) => {
  const keyA = Object.keys(a)[0]
  const valA = a[keyA]
  const keyB = Object.keys(b)[0]
  const valB = a[keyB]

  if (keyA > keyB) {
    return 1
  } else if (keyA < keyB) {
    return -1
  } else /* equal */ {
   if (valA > valB) {
      return 1
    } else if (valA < valB) {
      return -1
    } else /* equal */ {
      return 0
    }
  }
})

Answer 3

您可以使用

执行此操作

input.sort((a, b) => {
  const keya = Object.keys(a)[0];
  const keyb = Object.keys(b)[0];

  return keya.localeCompare(keyb) || a[keya].localeCompare(b[keyb]);
});

面对不同的语言区域设置，使用localeCompare更短，更健壮。

Answer 4

以下是我将使用的解决方案。此解决方案仅提供键排序，值仅排序，键然后值排序，值然后键 sort。

class FunkySort {
  sort (sortType) {
    switch (sortType) {
      case 'keysOnly':
        return data => this._sortByKey(data);
      case 'valuesOnly':
        return data => this._sortByValue(data);
      case 'valuesPrimary':
        return data => {
          data = this._sortByKey(data);
          return this._sortByValue(data);
        };
      case 'keysPrimary':
        return data => {
          data = this._sortByValue(data);
          return this._sortByKey(data);
        };
    }
  }

  _sortByKey (data) {
    return data.sort((a, b) => {
      var keyA = Object.keys(a)[0];
      var keyB = Object.keys(b)[0];
      return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
    });
  }

  _sortByValue (data) {
    return data.sort((a, b) => {
      // note that in Node >=v7 you could use `Object.values()`, but not in <v7.0
      var valueA = a[Object.keys(a)[0]];
      var valueB = b[Object.keys(b)[0]];
      return valueA < valueB ? -1 : valueA > valueB ? 1 : 0;
    });
  }
}

const dataArr = [{name:'John'},{age:25},{address:'some street'}];
const fs = new FunkySort();
fs.sort('keysPrimary')(dataArr);

请注意fs.sort是一个curried函数。第一个调用设置要完成的排序类型，因此fs.sort('keysPrimary')返回一个函数，该函数接受一个对象数组并首先按值对其进行排序，然后按键排序，从而生成按键排序的对象数组，如果有多个具有相同键的对象，则按值排序。

如果您在排序类型中不需要这种级别的灵活性，那么只需_sortByKey辅助方法即可。

基于键并基于值对对象数组进行排序

4 个答案: