Javascript 使用上下文查找Array.sort的方向

我想找到一个项目的方向，给定它的排序值。然而，我发现单靠

index

无法实现我想要的

给定一个排序函数，我只想知道一个项是否根据它的值实际移动到了另一个索引，而不是因为另一个项被移动了

例如：

const things = [
  { id: 't1', val: 4 }, // This moves to index 1, see T1 notes
  { id: 't2', val: 2 },
  { id: 't3', val: 5 }, // This moves to index 0
  { id: 't4', val: 1 },
  { id: 't5', val: 3 },
]

// Sort to highest vals first
let thingOrder = things.sort((a, b) => b.val - a.val)

thingOrder = thingOrder.map((thing, index) => {
  const oldIndex = things.indexOf(thing)

  if (index === oldIndex)
    thing.direction = 'same'
  else if (index > oldIndex)
    thing.direction = 'up'
  else if (index < oldIndex)
    thing.direction = 'down'

  return thing
})

console.log(thingOrder)

T1注释：从技术上讲，id为

T1

的项目已移至索引1，但不是因为它的

val

，而是因为T3已移至其上方

---

我如何才能实现发现某个项目在列表中是否确实上移或下移的目标？

根据评论，似乎有一些关于移动意味着什么的讨论。我不确定这意味着什么（即使在评论之后）

给定一个排序函数，我只想知道一个项是否根据它的值实际移动到了另一个索引，而不是因为另一个项被移动了

项目不会根据其值移动。它的移动是基于它的价值与周围人的关系

但是如果你只是想比较一个项目从哪里开始到哪里结束，你可以这样做。 设置从零到数组长度的范围。然后根据数组的排序顺序对其进行排序。此排序范围将显示何时何地索引的索引

const things=[
{id:'t1'，val:4}，//这将移动到索引1，请参见t1注释
{id:'t2'，val:2}，
{id:'t3'，val:5}，//这将移动到索引0
{id:'t4'，val:1}，
{id:'t5'，val:3}，
]
//这是一个简单的范围：
让sortOrder=Array.from（things，（，i）=>i）
//按事物分类
sortOrder.sort（（a，b）=>things[a].val-things[b].val）
log（“排序顺序：”，sortOrder）
//映射到方向名称
//将指数与当前位置进行比较
let directions=sortOrder.map（（项目，i）=>{
如果（项目>i）返回“向上”
如果（项目console.log（directions）

根据评论，似乎有一些关于移动意味着什么的讨论。我不确定这意味着什么（即使在评论之后）

给定一个排序函数，我只想知道一个项是否根据它的值实际移动到了另一个索引，而不是因为另一个项被移动了

项目不会根据其值移动。它的移动是基于它的价值与周围人的关系

但是如果你只是想比较一个项目从哪里开始到哪里结束，你可以这样做。 设置从零到数组长度的范围。然后根据数组的排序顺序对其进行排序。此排序范围将显示何时何地索引的索引

const things=[
{id:'t1'，val:4}，//这将移动到索引1，请参见t1注释
{id:'t2'，val:2}，
{id:'t3'，val:5}，//这将移动到索引0
{id:'t4'，val:1}，
{id:'t5'，val:3}，
]
//这是一个简单的范围：
让sortOrder=Array.from（things，（，i）=>i）
//按事物分类
sortOrder.sort（（a，b）=>things[a].val-things[b].val）
log（“排序顺序：”，sortOrder）
//映射到方向名称
//将指数与当前位置进行比较
let directions=sortOrder.map（（项目，i）=>{
如果（项目>i）返回“向上”
如果（项目console.log（directions）

尽管马克的回答很有帮助，但我并没有完全理解。我想看看一个项目相对于其他项目是向上还是向下移动

我最终得到的解决方案是：

const things = [
  { id: 't1', val: 4 }, // Expected: Same
  { id: 't2', val: 2 }, // Expected: Down
  { id: 't3', val: 5 }, // Expected: Up
  { id: 't4', val: 1 }, // Expected: Down
  { id: 't5', val: 3 }, // Expected: Same
]

let thingOrder = things.slice().sort((a, b) => b.val - a.val)

indexDiff = (thing, oldIndex) => {
 const newIndex = thingOrder.indexOf(thing)
 const indexDiff = oldIndex - newIndex

 return indexDiff
}

thingOrder = things.map((thing, oldIndex) => { 
  const indexDiffVal = indexDiff(thing, oldIndex)

  const targetIndexDiff = indexDiff(
    thingOrder[oldIndex],
    things.indexOf(thingOrder[oldIndex]
  ))

  const moveDistance = indexDiffVal + targetIndexDiff
  const moveDirectionSign = Math.sign(moveDistance)

  let moveDirection = 
        (moveDirectionSign === 1) ? 'up'
        : (moveDirectionSign === -1) ? 'down' 
        : (moveDirectionSign === 0) ? 'same'
        : (moveDirectionSign === -0) ? 'same'
        : 'same'

  moveDirection = (moveDistance === 1) ? 'same' : moveDirection

  thing.direction = moveDirection

  return thing
})

console.log(thingOrder)

这些是我在试图找出这个公式时做的笔记

---

虽然马克的回答有帮助，但我并没有完全理解。我想看看一个项目相对于其他项目是向上还是向下移动

我最终得到的解决方案是：

const things = [
  { id: 't1', val: 4 }, // Expected: Same
  { id: 't2', val: 2 }, // Expected: Down
  { id: 't3', val: 5 }, // Expected: Up
  { id: 't4', val: 1 }, // Expected: Down
  { id: 't5', val: 3 }, // Expected: Same
]

let thingOrder = things.slice().sort((a, b) => b.val - a.val)

indexDiff = (thing, oldIndex) => {
 const newIndex = thingOrder.indexOf(thing)
 const indexDiff = oldIndex - newIndex

 return indexDiff
}

thingOrder = things.map((thing, oldIndex) => { 
  const indexDiffVal = indexDiff(thing, oldIndex)

  const targetIndexDiff = indexDiff(
    thingOrder[oldIndex],
    things.indexOf(thingOrder[oldIndex]
  ))

  const moveDistance = indexDiffVal + targetIndexDiff
  const moveDirectionSign = Math.sign(moveDistance)

  let moveDirection = 
        (moveDirectionSign === 1) ? 'up'
        : (moveDirectionSign === -1) ? 'down' 
        : (moveDirectionSign === 0) ? 'same'
        : (moveDirectionSign === -0) ? 'same'
        : 'same'

  moveDirection = (moveDistance === 1) ? 'same' : moveDirection

  thing.direction = moveDirection

  return thing
})

console.log(thingOrder)

这些是我在试图找出这个公式时做的笔记

---

“从技术上讲，id为

t1

的项目已移动到索引1，但不是因为它是val，而是因为

t3

已移动到其上方”。那不是真的，他们两人都是因为他们的价值观而搬家的，否则的话，他们会一直呆在那里。我知道这在技术上是不真实的。所有项目都通过.sort重新编制索引。我希望你明白我的意思，尽量不要吹毛求疵我可以问一下，你为什么需要这个吗？@ibrahimmahrir是对的。你需要自己写一个，并跟踪事情的进展。他在维基百科的文章中链接了一些不同的排序算法，这些算法都有伪代码，你可以按照这些伪代码创建自己的算法。例如：

[{a:5}，{b:3}，{c:3}]

，有人向上投票

c

，我们记录

c

的值已更改，

a

和

b

保持不变（只需复制旧数组即可），我们排序，我们得到

[{a:5}，{c:4}，{b:3}

，我们可以清楚地说，

c

独立移动，但

b

没有“从技术上讲，id为

t1

的项目移动到了索引1，但不是因为它的val，而是因为

t3

移动到了它上面”。那不是真的，他们两人都是因为他们的价值观而搬家的，否则的话，他们会一直呆在那里。我知道这在技术上是不真实的。所有项目都通过.sort重新编制索引。我希望你明白我的意思，尽量不要吹毛求疵我可以问一下，你为什么需要这个吗？@ibrahimmahrir是对的。你需要自己写一个，并跟踪事情的进展。他在维基百科的文章中链接了一些不同的排序算法，这些算法都有伪代码，你可以按照这些伪代码创建自己的算法。例如：

[{a:5}，{b:3}，{c:3}]

，有人向上投票

c

，我们记录

c

的值已更改，

a

和

b

保持不变（只需复制旧数组即可），我们排序，我们得到

[{a:5}，{c:4}，{b:3}

，我们可以清楚地说，

c

是自己移动的，但是

b

没有

indexDiff:
t1 = 1i - 2i = -1d (down)
t2 = 2i - 4i = -2d (down)
t3 = 3i - 1i = 2d (up)
t4 = 4i - 5i = -1d (down)
t5 = 5i - 3i = 2d (up)

Compare diffs of item[newIndex] to item[oldIndex]
t1 = oldIndex = 1, t3 = newIndex = 1
t1 = indexDiff(-1), t3 = indexDiff(2)
-1 + 2 = [1] (didn't really move)

t2 = oldIndex = 2, t1 = newIndex = 2
t2 = indexDiff(-2), t1 = indexDiff(-1)
-2 + -1 = [-3] (did move down)

t3 = oldIndex = 3, t5 = newIndex = 3
t3 = indexDiff(2), t5 = indexDiff(2)
2 + 2 = [4] (did move up)

t4 = oldIndex = 4, t2 = newIndex = 4
t4 = indexDiff(-1), t2 = indexDiff(-2)
-1 + -2 = [-3] (did move down)

t5 = oldIndex = 5, t4 = newIndex = 5
t5 = indexDiff(2), t4 = indexDiff(-1)
2 + -1 = [1] (didn't really move)