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

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

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",
};

这个

对象.keys

目前由3个元素分割，我只关心第一个和第三个

[1]/[2]/[3]

我目前正在运行一个

foreach

，它循环遍历所有对象键，但我想按条件1和条件3对其进行排序

我的循环：

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

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

我的分类：

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

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

目标是检查key

a/a/something

，当它到达循环时，它应该在到达foreach之前检查sort对象

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"
};

---

你可以这样做：

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",
};

const data={“a/a/somethinges”：“somethines/ehere”、“a/b/somethinges”：“somethines/there/here”、“a/b/somethinges different”：“somethines/other/different”、“a/somethinges/somethinges”：“somethines/other/somethinges”、“b/b/somethinges differentialsd”：“某物/其他/某物不同”}；
常量排序={“a”：[“某物”，“某物不同”，“某物不同”]，“b”：[“某物不同”，“某物不同”]
常量拆分器=（s）=>{
设arr=s.split（'/'），index=sort[arr[0]].indexOf（arr[2]）
返回（{k:arr[0]，v:index<0？Number.MAX\u SAFE\u INTEGER:index}）
}
常量分类器=（a，b）=>拆分器（a）.v-拆分器（b）.v
const result=Object.entries(
对象。键（数据）
.reduce（（r，c）=>（r[splitter（c）.k]=[…r[splitter（c）.k]| |[]，c]，r），{}）
)
.map（（[k，v]）=>v.sort（分拣机））
.减少（（r，c）=>r.concat（c））
.reduce（（r，c）=>Object.assign（r，（{[c]：data[c]}）），{}）
log（result）

javascript中的对象未排序，所以您无法对键进行排序。不过，假设您希望得到一个已排序的键数组

const inputData={
“a/a/something”：“something/ehere”，
“a/b/somethingelse”：“某物/其他/此处”，
“a/b/something different”：“something/other/different”，
“a/c/somethinges”：“somethines/other/somethinges”，
“b/a/somethinges”：“somethines/other/somethinges”，
“b/a/something different”：“something/other/somethinges”，
“b/b/something differenting”数据：“something/else/something differenting”
};
常量排序函数=（x，y）=>{
设[a，b，c]=x.split（'/'）；
设[A，B，C]=y.split（'/'）；
if（aconsole.log（sortedKeys）；

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

var数据={
“a/a/something”：“something/ehere”，
“a/b/somethingelse”：“某物/其他/此处”，
“a/b/something different”：“something/other/different”，
“a/c/somethinges”：“somethines/other/somethinges”，
“b/a/somethinges”：“somethines/other/somethinges”，
“b/a/something different”：“something/other/somethinges”，
“b/b/something differenting”数据：“something/other/something differenting”，
};
变量排序={
“a”：[“某物”、“某物不同”、“某物相同”]，
“b”：[“某物”、“某物差异”]
}
设tmpData={}
for（让对象的[key，value]项（数据））{
tmpData[key.split（'/'）[0]]=tmpData[key.split（'/'）[0]]|{
tmpData[key.split（'/'）[0]][key.split（'/'）[2]]={[key]：值，值：999}
}
设tmpResult={}
for（让Object.entries的[key，args]（排序））{
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））
}
设{value，…result}=tmpResult
console.log（result）

预期的输出是什么？@Akrion，刚刚添加到foreachIts之前的预期结果中，不清楚您想要什么，但您可能应该

.split（“/”）

somewhere谢谢你，问题，你在这里引用了排序对象的什么地方？它如何知道如何排序？从你的问题中令人担忧的是，你会获取第一个

数据

，并使用

[0]/[1]/[2]对其进行排序

索引。因此，这将从

数据中获取输入，并通过只共享
[0]/[2]
索引对它们进行排序。如果这不正确，请告诉我。抱歉，Akrion，我想我可能把大家都弄糊涂了。
var sort
应该是我排序的基础，其背后的想法是我目前有
“a“
对象，该对象具有一个数组，该数组包含它应该如何排序，。但是，要将其拆分，您需要
[0]
和
[2]
更新答案