Нахождение направления Array.sort, с контекстом - PullRequest
Новая
       23

Нахождение направления Array.sort, с контекстом

0 голосов
/ 16 декабря 2018

Я бы хотел найти направление элемента, учитывая его значение сортировки.Тем не менее, я обнаружил, что один 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)

Ожидаемый результат: 

{ id: 't3', val: 5 }, // Up
{ id: 't1', val: 4 }, // Same
{ id: 't5', val: 3 }, // Same
{ id: 't2', val: 2 }, // Down
{ id: 't4', val: 1 }, // Down

Примечания T1: Технически элемент с идентификатором t1 перемещен в индекс1, но не из-за val, а из-за того, что T3 переместился над ним.

Как мне достичь цели, чтобы определить, действительно ли элемент перемещается вверх или вниз в списке?

Ответы [ 2 ]

0 голосов
/ 16 декабря 2018

Хотя ответ Марка помог, он меня не совсем понял.Я хотел посмотреть, движется ли предмет вверх или вниз относительно других предметов.

Решение, которое я выбрал, заключается в следующем: 

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)

Это заметки, которые я сделал при попыткечтобы понять эту формулу. 

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)
0 голосов
/ 16 декабря 2018

Судя по комментариям, похоже, что идет дискуссия о том, что значит двигаться.Я не уверен, что это значит (даже после комментариев)

Учитывая функцию сортировки, я только хочу выяснить, действительно ли элемент перемещен в другой индекс на основе его значения, а непотому что другой элемент был перемещен

Элемент не перемещен в зависимости от его стоимости.Он перемещается на основе отношения его стоимости к окружающим.

Но если вы просто хотите сравнить, где заканчивается элемент, начинается с того места, где он начинается, вы можете сделать это.Сделайте диапазон от нуля до длины массива.Затем сортируйте это по порядку сортировки массива.Этот отсортированный диапазон покажет вам, когда и где индексирован. 

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 },
  ]

// This is a simple range:
let sortOrder = Array.from(things, (_, i) => i)

// Sort it based on things
sortOrder.sort((a, b) => things[a].val - things[b].val )

console.log("sort order:", sortOrder)

// map to direction names
// by comparing index to current position
let directions = sortOrder.map((item, i) => {
    if (item > i) return "up"
    if (item < i) return "down"
    return "same"
})

console.log(directions)
...