按另一个对象排序对象（字符串）

Question

我目前有一个如下所示的对象：

var data = {
    "a/a/something": "something/ehere"
    "a/b/somethingelse": "something/else/here",
    "a/b/somethingdifferent": "something/else/different",
    "a/c/somethingess": "something/else/somethingess",
    "b/a/somethingess": "something/else/somethingess",
    "b/a/somethingdifferent": "something/else/somethingess",
    "b/b/somethingdifferentasdasd": "something/else/somethingdifferent",
};

这个Object.keys目前被分割成3个元素，我只关心第一个和第三个[1]/[2]/[3]。

我目前正在运行一个 foreach 循环遍历所有对象键，但我想按标准 1 和标准 3 对其进行排序。

我的循环：

Object.keys(data).forEach((dataID) => {
    register(dataID);
});

我的排序：

var sort = {
    "a": ["something", "somethingdifferent", "somethingelse"],
    "b": ["somethingess", "somethingdifferentasdasd"]
}

它的目的是检查是否键a/a/something，当它到达循环时，它应该在它到达foreach之前检查排序对象。

forEach 之前的预期结果

var data = {
    "a/a/something": "something/ehere"
    "a/b/somethingdifferent": "something/else/different",
    "a/b/somethingelse": "something/else/here",
    "a/c/somethingess": "something/else/somethingess",
    "b/a/somethingess": "something/else/somethingess",
    "b/b/somethingdifferentasdasd": "something/else/somethingdifferent",
    "b/a/somethingdifferent": "something/else/somethingess"
};

Answer 1

您可以尝试以下方法来处理您的场景

var data = {
    "a/a/something": "something/ehere",
    "a/b/somethingelse": "something/else/here",
    "a/b/somethingdifferent": "something/else/different",
    "a/c/somethingess": "something/else/somethingess",
    "b/a/somethingess": "something/else/somethingess",
    "b/a/somethingdifferent": "something/else/somethingess",
    "b/b/somethingdifferentasdasd": "something/else/somethingdifferent",
};

var sort = {
    "a": ["something", "somethingdifferent", "somethingelse"],
    "b": ["somethingess", "somethingdifferentasdasd"]
}

let tmpData = {}
for(let [key, value] of Object.entries(data)) {
  tmpData[key.split('/')[0]] = tmpData[key.split('/')[0]] || {}
  tmpData[key.split('/')[0]][key.split('/')[2]] = { [key]: value, value: 999 }
}

let tmpResult = {}
for(let [key, args] of Object.entries(sort)) {
  args.forEach((d,i) => tmpData[key][d]['value'] = i)
  
  Object.assign(tmpResult, ... Object.entries(tmpData[key]).map(([, v]) => v).sort((a, b) => a.value - b.value))
}

let {value, ...result} = tmpResult
console.log(result)

Answer 2

你可以这样做：

const data = { "a/a/something": "something/ehere", "a/b/somethingelse": "something/else/here", "a/b/somethingdifferent": "something/else/different", "a/c/somethingess": "something/else/somethingess", "b/a/somethingess": "something/else/somethingess", "b/a/somethingdifferent": "something/else/somethingess", "b/b/somethingdifferentasdasd": "something/else/somethingdifferent", };
const sort = { "a": ["something", "somethingdifferent", "somethingelse"], "b": ["somethingess", "somethingdifferentasdasd"] }

const splitter = (s) => {
  let arr = s.split('/'), index = sort[arr[0]].indexOf(arr[2])
  return ({ k: arr[0], v: index < 0 ? Number.MAX_SAFE_INTEGER : index})
}
const sorter = (a, b) => splitter(a).v - splitter(b).v
const result = Object.entries(
    Object.keys(data)
    .reduce((r, c) => (r[splitter(c).k] = [...r[splitter(c).k] || [], c], r), {})
  )
  .map(([k, v]) => v.sort(sorter))
  .reduce((r, c) => r.concat(c))
  .reduce((r, c) => Object.assign(r, ({ [c]: data[c]})), {})

console.log(result)

想法是通过Object.keys 获取键，然后按索引[0] 对它们进行分组，对它们进行排序，然后组成最终对象。

注意：Object props order is not guaranteed：

对象是对象类型的成员。它是一个无序的 属性集合，每个属性都包含一个原始值， 对象或功能。存储在对象属性中的函数是 称为方法。

虽然 SO 控制台会在 Chrome 控制台中显示所需的顺序，但您不会得到相同的输出。仅供参考。

因此请记住，如果您替换最后一行，而不是 reduce，您会使用 map，因此最终结果是一个数组：

const data = { "a/a/something": "something/ehere", "a/b/somethingelse": "something/else/here", "a/b/somethingdifferent": "something/else/different", "a/c/somethingess": "something/else/somethingess", "b/a/somethingess": "something/else/somethingess", "b/a/somethingdifferent": "something/else/somethingess", "b/b/somethingdifferentasdasd": "something/else/somethingdifferent", };
const sort = { "a": ["something", "somethingdifferent", "somethingelse"], "b": ["somethingess", "somethingdifferentasdasd"] }

const splitter = (s) => {
  let arr = s.split('/'), index = sort[arr[0]].indexOf(arr[2])
  return ({ k: arr[0], v: index < 0 ? Number.MAX_SAFE_INTEGER : index})
}
const sorter = (a, b) => splitter(a).v - splitter(b).v
const result = Object.entries(
    Object.keys(data)
    .reduce((r, c) => (r[splitter(c).k] = [...r[splitter(c).k] || [], c], r), {})
  )
  .map(([k, v]) => v.sort(sorter))
  .reduce((r, c) => r.concat(c))
  .map(x => ({[x] : data[x]}))

console.log(result)

您将获得有保证的索引顺序和正确/推荐输出。您不能依赖对象道具顺序。

Answer 3

javascript 中的对象未排序，因此您无法对键进行排序。但是，假设您希望得到一个排序后的键数组...

const inputData = {
  "a/a/something": "something/ehere",
  "a/b/somethingelse": "something/else/here",
  "a/b/somethingdifferent": "something/else/different",
  "a/c/somethingess": "something/else/somethingess",
  "b/a/somethingess": "something/else/somethingess",
  "b/a/somethingdifferent": "something/else/somethingess",
  "b/b/somethingdifferentasdasd": "something/else/somethingdifferent"
};

const sortingFunction = (x, y) => {
  let [a, b, c] = x.split('/');
  let [A, B, C] = y.split('/');
  if (a < A) {
    return -1;
  } else if (A < a) {
    return 1;
  } else {
    if (c < C) {
      return -1;
    } else if (C < c) {
      return 1;
    } else {
      return 0;
    }
  }
};

const sortedKeys = Object.keys(inputData);
sortedKeys.sort(sortingFunction);

console.log(sortedKeys);