Tengo un objeto con la siguiente estructura:

root_object: {
    ITEM_ONE: {
        order: 2,
        prop_one: '123',
        prop_two: '456',
    },
    ITEM_TWO: {
        order: 1,
        prop_one: '789',
        prop_two: '321',
    },
    ITEM_THREE: {
        order: 3,
        prop_one: '654',
        prop_two: '987',
    },
}

Como resultado final, tendré que obtener la lista de claves:

['ITEM_ONE', 'ITEM_TWO', 'ITEM_THREE']

PERO deben ordenarse en función de la propiedad order, lo que dará como resultado:

['ITEM_TWO', 'ITEM_ONE', 'ITEM_THREE']

Prefiero utilizar la biblioteca _lodash para este propósito, pero ni siquiera estoy seguro de cómo comenzar, ya que la estructura para root_object es un objeto y no una lista.

0
delux 9 may. 2019 a las 21:11

6 respuestas

La mejor respuesta

Puede hacer esto con js sin formato utilizando el método sort y Object.keys.

const data = {"ITEM_ONE":{"order":2,"prop_one":"123","prop_two":"456"},"ITEM_TWO":{"order":1,"prop_one":"789","prop_two":"321"},"ITEM_THREE":{"order":3,"prop_one":"654","prop_two":"987"}}
const res = Object.keys(data).sort((a, b) => data[a].order - data[b].order)
console.log(res)
4
Nenad Vracar 9 may. 2019 a las 18:13

Puede ordenar las claves tomando el valor para ordenar.

var object = { root_object: { ITEM_ONE: { order: 2, prop_one: '123', prop_two: '456' }, ITEM_TWO: { order: 1, prop_one: '789', prop_two: '321' }, ITEM_THREE: { order: 3, prop_one: '654', prop_two: '987' } } },
    keys = Object.keys(object.root_object);
    
keys.sort((a, b) => object.root_object[a].order - object.root_object[b].order);

console.log(keys);
.as-console-wrapper { max-height: 100% !important; top: 0; }
1
Nina Scholz 9 may. 2019 a las 18:13

Esta es una solución O (n) (ordenar es O (nlogn)) que funciona solo para valores únicos order .

Puede usar lodash para asignar los valores de cada propiedad al orden ({ ITEM_ONE: 2, ITEM_TWO: 1, ... }), luego invertir las claves y los valores ({ 1: ITEM_TWO, 2: ITEM_ONE, ... }) y extraer los valores. Esto le proporcionará los elementos en el pedido correcto:

const { flow, partialRight: pr, mapValues, invert, values } = _

const fn = flow(
  pr(mapValues, 'order'), // convert to { ITEM_ONE: 2, ITEM_TWO: 1, ... }
  invert, // convert to { 1: ITEM_TWO, 2: ITEM_ONE, ... }
  values // get the array of keys
)

const root_object = {"ITEM_ONE":{"order":2,"prop_one":"123","prop_two":"456"},"ITEM_TWO":{"order":1,"prop_one":"789","prop_two":"321"},"ITEM_THREE":{"order":3,"prop_one":"654","prop_two":"987"}}

const result = fn(root_object)
  
console.log(result)
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

En vanilla JS convirtiendo el objeto en entradas, asigne las entradas a la forma de [order, key], convierta las entradas en objeto con Object.fromEntries() (no es compatible con IE / Edge), y luego obtenga los valores:

const fn = o => Object.values(Object.fromEntries(
  Object.entries(o).map(([k, { order }]) => [order, k])
))

const root_object = {"ITEM_ONE":{"order":2,"prop_one":"123","prop_two":"456"},"ITEM_TWO":{"order":1,"prop_one":"789","prop_two":"321"},"ITEM_THREE":{"order":3,"prop_one":"654","prop_two":"987"}}

const result = fn(root_object)
  
console.log(result)
1
Ori Drori 9 may. 2019 a las 18:38

Simplemente use sort con una función de devolución de llamada, así:

var root = {ITEM_ONE:{order:2,prop_one:'123',prop_two:'456'},ITEM_TWO:{order:1,prop_one:'789',prop_two:'321'},ITEM_THREE:{order:3,prop_one:'654',prop_two:'987'}};

var keys = Object.keys(root).sort((a, b) => root[a].order - root[b].order);
console.log(...keys);

Para una solución lodash, use toPairs, sortBy, luego map para obtener las claves:

var root = {ITEM_ONE:{order:2,prop_one:'123',prop_two:'456'},ITEM_TWO:{order:1,prop_one:'789',prop_two:'321'},ITEM_THREE:{order:3,prop_one:'654',prop_two:'987'}};

console.log(..._.map(_.sortBy(_.toPairs(root), '1.order'), 0));
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>
2
p.s.w.g 9 may. 2019 a las 18:22

Simplemente use Array.prototype.sort() en la matriz de Object.keys(root_object):

const root_object = {
    ITEM_ONE: {
        order: 2,
        prop_one: '123',
        prop_two: '456',
    },
    ITEM_TWO: {
        order: 1,
        prop_one: '789',
        prop_two: '321',
    },
    ITEM_THREE: {
        order: 3,
        prop_one: '654',
        prop_two: '987',
    },
}

let result = Object.keys(root_object).sort((a,b) => root_object[a].order - root_object[b].order);

console.log(result);
1
connexo 9 may. 2019 a las 18:16

Puede usar Object.keys junto con Array.map y Array.sort

const root_object = {
    ITEM_ONE: {
        order: 2,
        prop_one: '123',
        prop_two: '456',
    },
    ITEM_TWO: {
        order: 1,
        prop_one: '789',
        prop_two: '321',
    },
    ITEM_THREE: {
        order: 3,
        prop_one: '654',
        prop_two: '987',
    },
}

let rootArr = [];

let sortedRootObject = Object.keys(root_object).map(key => rootArr.push(root_object[key])).sort((a, b) => rootArr[b.order] - rootArr[a.order])

console.log(sortedRootObject)
0
Mark 9 may. 2019 a las 18:27