Javascript 如何按照与给定键数相同的键数作为参数对对象数组进行排序？

我有一个带有一些键的基本对象，还有一个带有相似但不一定完全相同键的对象列表

const o1 = {k1: "", k2: "", k3: ""} // the basic object
const o2 = {k1: "", k4: ""}         // 1 the same key
const o3 = {k1: "", k3: ""}         // 2 the same keys
const o4 = {k3: "", k1: "", k2: ""} // 3 the same keys
const o5 = {k5: ""}                 // 0 the same keys

我想写一个函数，它接受基本对象和其他对象的数组，它将根据给定对象中相似键的数量对它们进行排序/排序

function order(obj, arr) {
  // ...
}

结果应该是基于与基本对象相同的键数的给定对象的有序数组

order(o1, [o2, o3, o4, o5])
// result: [o4, o3, o2, o5]

你会用什么

---

我正在考虑按对象键上的相交长度进行排序。

您可以使用Object.keys和filter的组合来确定数组的实际长度并进行适当排序：

常量o1={k1:，k2:，k3:}//基本对象 常数o2={k1:，k4:}//1相同的键 常量o3={k1:，k3:}//2相同的键 常量o4={k3:，k1:，k2:}//3相同的键 常量o5={k5:}//0相同的键 函数orderobj，arr{ 返回arr.sorta，b=> Object.keysb.filterk=>obj.length中的k- Object.keysa.filterk=>obj.length中的k； }

---

console.logordero1[o2，o3，o4，o5] 您可以使用Object.keys和filter的组合来确定数组的实际长度并进行适当排序：

常量o1={k1:，k2:，k3:}//基本对象 常数o2={k1:，k4:}//1相同的键 常量o3={k1:，k3:}//2相同的键 常量o4={k3:，k1:，k2:}//3相同的键 常量o5={k5:}//0相同的键 函数orderobj，arr{ 返回arr.sorta，b=> Object.keysb.filterk=>obj.length中的k- Object.keysa.filterk=>obj.length中的k； }

---

console.logordero1[o2，o3，o4，o5] 您可以对相同的键进行计数，并使用此值进行排序

常数 o1={k1:，k2:，k3:}，//基本对象 o2={k1:，k4:}，//1相同的键 o3={k1:，k3:}，//2相同的键 o4={k3:，k1:，k2:}，//3相同的键 o5={k5:}；//0相同的键 函数orderobject，数组{ 函数getCounto{ return Object.keysobject.reduces，k=>o中的s+k，0； } return array.sorta，b=>getCountb-getCounta； }

---

console.logordero1[o2，o3，o4，o5]；//[o4，o3，o2，o5]您可以对相同的键进行计数，并使用此值进行排序

常数 o1={k1:，k2:，k3:}，//基本对象 o2={k1:，k4:}，//1相同的键 o3={k1:，k3:}，//2相同的键 o4={k3:，k1:，k2:}，//3相同的键 o5={k5:}；//0相同的键 函数orderobject，数组{ 函数getCounto{ return Object.keysobject.reduces，k=>o中的s+k，0； } return array.sorta，b=>getCountb-getCounta； } console.logordero1[o2，o3，o4，o5]；//[o4，o3，o2，o5]使用lodash：

function order(reference, objs) {
  const referenceKeys = _.keys(reference);
  return _.sortBy(objs, obj => -_(referenceKeys).intersection(_.keys(obj)).size());
}

另一种方式：

function order(reference, objs) {
  const referenceKeys = new Set(_.keys(reference));
  return _.sortBy(objs, obj => _(obj).keys().sumBy(key => referenceKeys.has(key) ? -1 : 0))
}

使用lodash：

function order(reference, objs) {
  const referenceKeys = _.keys(reference);
  return _.sortBy(objs, obj => -_(referenceKeys).intersection(_.keys(obj)).size());
}

另一种方式：

function order(reference, objs) {
  const referenceKeys = new Set(_.keys(reference));
  return _.sortBy(objs, obj => _(obj).keys().sumBy(key => referenceKeys.has(key) ? -1 : 0))
}

---

Object.keys、Array.sort和任何形式的循环来检查/计数匹配的属性Object.keys、Array.sort和任何形式的循环来检查/计数匹配的属性只是一个警告：Array.sort将变异arr，这可能是一个问题。只是一个警告：Array.sort将变异arr，这可能是一个问题。我非常喜欢第一个示例！我真的很喜欢第一个例子！