具有空值和实值的 lodash orderby 未正确排序

Question

I have an Angular 2 typescript application that is using lodash for various things.

I have an array of objects that I am ordering using a property in the object...

_.orderBy(this.myArray, ['propertyName'], ['desc']);

This works well however my problem is that sometimes 'propertyName' can have a null value. These are ordered as the first item in a descending list, the highest real values then follow.

I want to make these null values appear last in the descending ordering.

I understand why the nulls come first.

Does anyone know how to approach this?

Answer 1

The _.orderBy() function's iteratees can use a method instead of a string. Check the value, and if it's null return an empty string.

 const myArray = [{ propertyName: 'cats' }, { propertyName: null }, { propertyName: 'dogs' }, { propertyName: 'rats' }, { propertyName: null }]; const result = _.orderBy(myArray, ({ propertyName }) => propertyName || '', ['desc']); console.log(result);

 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.2/lodash.min.js"></script>

The check can be simple (like the one I've used), which converts all falsy values to an empty string:

propertyName || ''

If you need a stricter check, you can use the ternary operator, and handle just null values:

propertyName === null ? '' : propertyName

---

Edit: Example with multiple ordering:

const result = _.orderBy(myArray, (item) => [get(item, 'propertyName', 0), get(item, 'propertyName2')], ['desc', 'asc']);

This will order by propertyName then propertyName2 .

If propertyName is undefined/null then its default order will be set to 0 . (and therefore will be displayed at last because of desc ordering on the propertyName field). In such case, propertyName2 will therefore determine the ordering.

Answer 2

我需要的代码看起来像这样......

_.orderBy(this.myArray, [( o ) => { return o.myProperty || ''}], ['desc']); 

Answer 3

Just for future reference to others you can do this to sort ascending with falsey values at the end.

items =>
  orderBy(
    items,
    [
      i => !!i.attributeToCheck,
      i => {
        return i.attributeToCheck ? i.attributeToCheck.toLowerCase() : ''
      }
    ],
    ['desc', 'asc']
  )

Answer 4

This will put bad values at the bottom, and it differentiates between numbers and strings.

const items = [] // some list

const goodValues = isAscending => ({ value }) => {
    if (typeof value !== 'string' && isNaN(value)) {
        return isAscending ? Infinity : -Infinity
    }

    return value || ''
}

const sortedItems = orderBy(
    items,
    [goodValues(isAscending), 'value'],
    [isAscending ? 'asc' : 'desc']
)

Answer 5

This worked for me

orders = [{id : "1", name : "test"}, {id : "1"}];
sortBy = ["id", "name"];
orderby(
            orders,
            sortBy.map(s => {
                return (r: any) => {
                    return r[s] ? r[s] : "";
                };
            })),
        );

Answer 6

mine looks like this. PropName and sort are both variables in my solution

return _.orderBy( myarray, [
  ( data ) => {
    if ( data[propName] === null ) {
        data[propName] = "";
    }
    return data[propName].toLowerCase();
    }
 ], [sort] );

I wanted tolowercase because otherwise the sorting is not correct if different casings

Answer 7

I created a function for this (ts code):

const orderByFix = (array: any[], orderKeys: string[], orderDirs: ('asc' | 'desc')[]) => {
  const ordered = orderBy(array, orderKeys, orderDirs);
  const withProp = ordered.filter((o) => orderKeys.every(k => o[k]));
  const withoutProp = ordered.filter((o) => !orderKeys.every(k => o[k]));
  return [...withProp, ...withoutProp];
};

Answer 8

I've extended gwendall's answer to also handle case when "order keys" are functions ( _.orderBy allows that)

const orderByFix = (
  array: any[],
  orderKeys: (string | ((o: any) => any))[],
  orderDirs: ('asc' | 'desc')[]
) => {
  const ordered = orderBy(array, orderKeys, orderDirs)
  const withProp = ordered.filter((o) =>
    orderKeys.every((k) => {
      if (typeof k === 'string') {
        return o[k]
      } else if (typeof k === 'function') {
        return k(o)
      } else {
        throw Error(`Order key must be string or function not ${typeof k}`)
      }
    })
  )
  const withoutProp = ordered.filter(
    (o) =>
      !orderKeys.every((k) => {
        if (typeof k === 'string') {
          return o[k]
        } else if (typeof k === 'function') {
          return k(o)
        } else {
          throw Error(`Order key must be string or function not ${typeof k}`)
        }
      })
  )
  return [...withProp, ...withoutProp]
}

Answer 9

We can split the array into two: one - with empty values, the other one - without. Then sort the array without nulls and append the array with nulls at the end [...rows] creates copy of the array to avoid messing up original array that my still be used somewhere else in the aplication

 static doSort(rows, fieldName, sortDirection, nullslast) { if (!nullslast) { return _.orderBy([...rows], [fieldName], [sortDirection]); } const withoutNulls = []; const withNulls = []; for (let row of rows) { (row[fieldName] === null ? withNulls : withoutNulls).push(row); } return _.orderBy([...withoutNulls], [fieldName], [sortDirection]).concat(withNulls); }