Filter an array with conditions across multiple attributes

I have an array with parent and child and the expense of the child (There can be more than 3 expenses).
I want to filter the list grouped by parents and show the parents where combination of children has a mix of positive and negative expenses.
Filter out parents if they have only positive or only negative expenses.

Input Array:

let inputArray1 = [
{
'parent':'A',
'child':'RST',
'expense1':1,
'expense2':2,
'expense3':3,
},
{
'parent':'A',
'child':'EST',
'expense1':4,
'expense2':5,
'expense3':6,
},
{
'parent':'A',
'child':'QST',
'expense1':4,
'expense2':2,
'expense3':6,
},
{
'parent':'B',
'child':'EST',
'expense1':1,
'expense2':2,
'expense3':-3,  //. <----Negative Expense
},
{
'parent':'B',
'child':'VST',
'expense1':6,
'expense2':2,
'expense3':3,
},
{
'parent':'B',
'child':'NST',
'expense1':3,
'expense2':8,
'expense3':7,
},
{
'parent':'C',
'child':'UST',
'expense1':-8,
'expense2':-2,
'expense3':3,  //<--- Positive Expense
},
{
'parent':'C',
'child':'PST',
'expense1':-6,
'expense2':-5,
'expense3':-3,
},
{
'parent':'C',
'child':'LST',
'expense1':-3,
'expense2':-8,
'expense3':-7,
},
{
'parent':'D',
'child':'WST',
'expense1':-8,
'expense2':-2,
'expense3':-3,
},
{
'parent':'D',
'child':'CST',
'expense1':-6,
'expense2':-5,
'expense3':-3,
},
{
'parent':'D',
'child':'KST',
'expense1':-3,
'expense2':-8,
'expense3':-7,
}
]

Output Array: It should only have B and C as they have a combination of positive and negative expense among the children expense.

let inputArray1 = [
{
'parent':'B',
'child':'EST',
'expense1':1,
'expense2':2,
'expense3':-3,
},
{
'parent':'B',
'child':'VST',
'expense1':6,
'expense2':2,
'expense3':3,
},
{
'parent':'B',
'child':'NST',
'expense1':3,
'expense2':8,
'expense3':7,
},
{
'parent':'C',
'child':'UST',
'expense1':-8,
'expense2':-2,
'expense3':3,
},
{
'parent':'C',
'child':'PST',
'expense1':-6,
'expense2':-5,
'expense3':-3,
},
{
'parent':'C',
'child':'LST',
'expense1':-3,
'expense2':-8,
'expense3':-7,
},
]

Get a set of unique parents. For each unique parent, locate all children, get all expenses (i.e. where the property name starts with the word 'expense'), extract all the expense values, and check if there is a mix of positive and negative numbers. Then, if the parent meets that test, extract all entries of that parent and include it in the result.

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

const data = [{"parent":"A","child":"RST","expense1":1,"expense2":2,"expense3":3},{"parent":"A","child":"EST","expense1":4,"expense2":5,"expense3":6},{"parent":"A","child":"QST","expense1":4,"expense2":2,"expense3":6},{"parent":"B","child":"EST","expense1":1,"expense2":2,"expense3":-3},{"parent":"B","child":"VST","expense1":6,"expense2":2,"expense3":3},{"parent":"B","child":"NST","expense1":3,"expense2":8,"expense3":7},{"parent":"C","child":"UST","expense1":-8,"expense2":-2,"expense3":3},{"parent":"C","child":"PST","expense1":-6,"expense2":-5,"expense3":-3},{"parent":"C","child":"LST","expense1":-3,"expense2":-8,"expense3":-7},{"parent":"D","child":"WST","expense1":-8,"expense2":-2,"expense3":-3},{"parent":"D","child":"CST","expense1":-6,"expense2":-5,"expense3":-3},{"parent":"B","child":"KST","expense1":-3,"expense2":-8,"expense3":-7}]
console.log([...new Set(data.map(i=>i.parent))]
.filter(parent=>data.filter(i=>i.parent===parent)
.flatMap(i=>Object.entries(i).filter(([k])=>k.startsWith('expense'))
.map(([k,v])=>Math.abs(v)===v))
.reduce((a,c,i,r)=>a || i>0 && c!==r[i-1],false))
.flatMap(parent=>data.filter(i=>i.parent===parent)))

<!-- end snippet -->

Filtering arrays can be a bit tricky when you don't have a grasp on higher order functions (https://eloquentjavascript.net/05_higher_order.html). Basically they abstract away the code that we could do using if loops and elses to remove or add what we want.

I don't quite understand your question, because the output I did is different from what you want, but I stuck to eliminating all that were only positive or only negative.

Fortunately this is not a problem because you can implement your own logic in the part of the function that I left commented out for this.

Basically what was done was to use the native function of arrays, filter and add a logic for each row of it and if this logic is met, return that row to the final array that I want.

Complete code:

// Input
let input = [
{ 'parent': 'A', 'child': 'RST', 'expense1': 1, 'expense2': 2, 'expense3': 3 },
{ 'parent': 'A', 'child': 'EST', 'expense1': 4 4, 'expense2': 5, 'expense3': 6 },
{ 'parent': 'A', 'child': 'QST', 'expense1': 4, 'expense2': 2, 'expense3': 6 },
{ 'parent': 'B', 'child': 'EST', 'expense1': 1, 'expense2': 2, 'expense3': -3 }
{ 'parent': 'B', 'child': 'VST', 'expense1': 6, 'expense2': 2, 'expense3': 3 },
{ 'parent': 'B', 'child': 'NST', 'expense1': 3, 'expense2': 8, 'expense3': 7 },
{ 'parent': 'C', 'child': 'UST', 'expense1': -8, 'expense2': -2, 'expense3': 3 },
{ 'parent': 'C', 'child': 'PST', 'expense1': -6, 'expense2': -5, 'expense3': -3 }
{ 'parent': 'C', 'child': 'LST', 'expense1': -3, 'expense2': -8, 'expense3': -7 }
{ 'parent': 'D', 'child': 'WST', 'expense1': -8, 'expense2': -2, 'expense3': -3 }
{ 'parent': 'D', 'child': 'CST', 'expense1': -6, 'expense2': -5, 'expense3': -3 }
{ 'parent': 'B', 'child': 'KST', 'expense1': -3, 'expense2': -8, 'expense3': -7 }
]
// Output
let output = [
{ 'parent': 'B', 'child': 'EST', 'expense1': 1, 'expense2': 2, 'expense3': -3 }
{ 'parent': 'B', 'child': 'VST', 'expense1': 6, 'expense2': 2, 'expense3': 3 },
{ 'parent': 'B', 'child': 'NST', 'expense1': 3, 'expense2': 8, 'expense3': 7 },
{ 'parent': 'C', 'child': 'UST', 'expense1': -8, 'expense2': -2, 'expense3': 3 },
{ 'parent': 'C', 'child': 'PST', 'expense1': -6, 'expense2': -5, 'expense3': -3 }
{ 'parent': 'C', 'child': 'LST', 'expense1': -3, 'expense2': -8, 'expense3': -7 },
]
const filterLogic = rowOfInput => {
if ( // Add logic to include or exclude line
(rowOfInput.expense1 < 0 && rowOfInput.expense2 < 0 && rowOfInput.expense3 < 0) ||
(rowOfInput.expense1 > 0 && rowOfInput.expense2 > 0 && rowOfInput.expense3 > 0)
) return rowOfInput // if is your desired, return that line
}
let inputFiltered = input.filter(filterLogic)
console.log(output)
console.log(inputFiltered)

Translated with www.DeepL.com/Translator (free version)