Destructuring in combination with array functions [duplicate]

Question

Just wondering if it's possible to use an array function (like filter) to return both the negative and the positive outcomes of the statement at the same time using destructuring.

Something like the following:

let {truthys, falsys} = arr.filter(a => {
   return //magical statement that returns truthy's and falsy's?
});

instead of:

let truthys = arr.filter(item => item.isTruthy);
let falsys = arr.filter(item => !item.isTruthy);

So something of a shorthand-way of doing the latter. Can't seem to find anything about this anywhere so it might not be possible at all. Thanks!

You could use .reduce() to create an object with two arrays. — Pointy
– Pointy, Commented Jun 11, 2021 at 15:04
.filter() returns one array of values. Doesn't make much sense to destructure it, if you pass a predicate. What you can do is group by the predicate result and return an object with { "true" : /* items that passed the predicate test */, "false": /* items that did not pass the predicate test */ } and then destructure as const {true: truthys, false: falsys} = groupedValues — VLAZ
– VLAZ, Commented Jun 11, 2021 at 15:07
See georg's partition implementation here it's essentially what you need. You'd call it like parition(arr, x => !!x) (or parition(arr, Boolean) if you wish). That's partitioning into an array with indexes 1 and 0 but the approach is the same if you want to partition into an object with keys true and false. I personally prefer the latter because it's a bit clearer that result.true is the result of everything where the condition returned true but ultimately doesn't matter much. — VLAZ
– VLAZ, Commented Jun 11, 2021 at 15:22
const [thruthys, falsys] = partition(arr, item => item.isTruthy) with an appropriate helper function (see the duplicates) is the standard approach. If you already have a groupBy helper, such as lodash's one, you can also use const {true: truthys, false: falsys} = _.groupBy(arr, item => !!item.isTruthy). — Bergi
– Bergi, Commented Jun 11, 2021 at 16:11

BaseZen · Accepted Answer · 2021-08-26 02:56:37Z

0

Your idea can never work as written because the return from filter is necessarily an array, not a structure. If you don't mind just finding one value, this variation works:

{ a, b } = [ { a: 'yyy', b: 'yzz' }, { a: 'aww', b: 'azz' } ].find(e => e.a.startsWith('y'))

> a
'yyy'
> b
'yzz'

But looking more closely I see What You Actually Wanted, so perhaps the most straightforward is:

const a = [ '', ' hello ', ' ', false, [], [0], [''], [' '], null, undefined, new Array(), 0, 1, -1 ]
const { truthies, falsies } = { truthies: a.filter(e => !!e), falsies: a.filter(e => !e) }
console.log(`truthies: ${JSON.stringify(truthies)}\nfalsies: ${JSON.stringify(falsies)}`)

With the result:

{
  truthies: [ ' hello ', ' ', [], [ 0 ], [ '' ], [ ' ' ], [], 1, -1 ],
  falsies: [ '', false, null, undefined, 0 ]
}

EDIT

Inspired by keeping just one filter pass, it's not so pretty, but one can do:

const a = [ '', ' hello ', ' ', false, [], [0], [''], [' '], null, undefined, new Array(), 0, 1, -1 ]
const false_temp = []
const { truthies, falsies } = { truthies: a.filter(e => !!e || (false_temp.push(e) && false)), falsies: false_temp }
console.log(`truthies: ${JSON.stringify(truthies)}\nfalsies: ${JSON.stringify(falsies)}`)

edited Aug 26, 2021 at 2:56

answered Jun 11, 2021 at 15:11

BaseZen

8,7083 gold badges37 silver badges49 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

BaseZen Over a year ago

Just some fun: 0 is falsish but new Number(0) is truthish but Number(0) is falsish.

Nolleto · Accepted Answer · 2021-06-11 15:22:05Z

You can use .reduce for it:

const getTruthysAndFalsys = (array) => {
  return array.reduce(
    ({ truthys, falsys }, item) => {
      const isTruthy = item.isTruthy

      return {
        truthys: [
          ...truthys,
          ...(isTruthy ? [item] : []),
        ],
        falsys: [
          ...falsys,
          ...(!isTruthy ? [item] : []),
        ],
      }
    },
    { truthys: [], falsys: [] }
  )
}

const array = [
  { name: 'Item 1', isTruthy: true },
  { name: 'Item 2', isTruthy: true },
  { name: 'Item 3', isTruthy: false },
  { name: 'Item 4', isTruthy: true },
  { name: 'Item 4', isTruthy: false },
]


getTruthysAndFalsys(array)
// { 
//   truthys: [ 
//     { name: 'Item 1', isTruthy: true }, 
//     { name: 'Item 2', isTruthy: true }, 
//     { name: 'Item 4', isTruthy: true }, 
//   ], 
//   falsys: [ 
//     { name: 'Item 3', isTruthy: false }, 
//     { name: 'Item 4', isTruthy: false },
//   ],
// }

Guerric P · Accepted Answer · 2021-06-11 15:58:55Z

-1

As @Pointy suggested you can avoid filtering two times by dividing the elements into two arrays with Array.prototype.reduce() like this:

const input = [1, 0, true, false, "", "foo"];

const [truthies, falsies] = input.reduce(
  ([truthies, falsies], cur) =>
    !cur ? [truthies, [...falsies, cur]] : [[...truthies, cur], falsies],
  [[], []]
);

console.log(truthies, falsies);

edited Jun 11, 2021 at 15:58

answered Jun 11, 2021 at 15:22

Guerric P

32k6 gold badges61 silver badges109 bronze badges

Collectives™ on Stack Overflow

Destructuring in combination with array functions [duplicate]

3 Answers 3

1 Comment

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

Comments

Comments

Linked

Related