Возврат отформатированного объекта только с положительными значениями

Question

У меня есть объект объектов. Каждый из моих вложенных объектов имеет цену как вложенный массив, который может содержать отрицательные значения. Мне нужно отформатировать объект и вернуть новый с дочерними объектами, содержащими только положительные значения.

Например, в приведенном ниже коде, в идеале, он должен возвращать только объект с объектом TypeB, поскольку только тот, который имеет цена с неотрицательными значениями.

Я пробовал это, но я думаю, что-то упустил. Кроме того, можно ли оптимизировать это, используя метод «уменьшить» вместо этого?

Входной объект:

{
  "TypeA": [
    {
      "price": [
        [
          {
            "amount": -45,
            "currency": "USD"
          }
        ]
      ],
      "name": "ABC",
      "priceDetails": [
        {
          "name": "BASE",
          "price": [
            [
              {
                "amount": -40.00,
                "currency": "USD"
              }
            ]
          ]
        },
        {
          "name": "TAX",
          "price": [
            [
              {
                "amount": -5.00,
                "currency": "USD"
              }
            ]
          ]
        }
      ]
    }
  ],
  "TypeB": [
    {
      "price": [
        [
          {
            "amount": 0,
            "currency": "USD"
          }
        ]
      ],
      "name": "ABC",
      "priceDetails": [
        {
          "name": "BASE",
          "price": [
            [
              {
                "amount": 0,
                "currency": "USD"
              }
            ]
          ]
        }
      ]
    }
  ]
}

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

{
  "TypeB": [
    {
      "price": [
        [
          {
            "amount": 0,
            "currency": "USD"
          }
        ]
      ],
      "name": "ABC",
      "priceDetails": [
        {
          "name": "BASE",
          "price": [
            [
              {
                "amount": 0,
                "currency": "USD"
              }
            ]
          ]
        }
      ]
    }
  ]
}

Код:

const data = {
  "TypeA": [{
    "price": [
      [{
        "amount": -45,
        "currency": "USD"
      }]
    ],
    "name": "ABC",
    "priceDetails": [{
        "name": "BASE",
        "price": [
          [{
            "amount": -40.00,
            "currency": "USD"
          }]
        ]
      },
      {
        "name": "TAX",
        "price": [
          [{
            "amount": -5.00,
            "currency": "USD"
          }]
        ]
      }
    ]
  }],
  "TypeB": [{
    "price": [
      [{
        "amount": 0,
        "currency": "USD"
      }]
    ],
    "name": "ABC",
    "priceDetails": [{
      "name": "BASE",
      "price": [
        [{
          "amount": 0,
          "currency": "USD"
        }]
      ]
    }]
  }]
};

const formattedData = Object.values(data).filter(item => {
  return item.map(elem => {
    const itemPrice = elem.price;
    const isPositive = itemPrice[0][0].amount >= 0;
    return isPositive ? elem : false;
  });
});
console.log(formattedData);

Answer 1

Вы можете отфильтровать данные с помощью различных проверок и построить новый объект, если найден требуемый конечный объект.

function filter(object) {
    if (!object || typeof object !== 'object') return;

    if ('amount' in object) return object.amount >= 0 ? object : undefined;

    if (Array.isArray(object)) {
        var items = object.reduce((r, v) => {
            var temp = filter(v);
            if (temp) r.push(temp);
            return r;
        }, []);
        return items.length ? items : undefined;
    } else {
        var entries = Object.entries(object).reduce((r, [k, v]) => {
            var temp = filter(v);
            if (temp) r.push([k, temp]);
            return r;
        }, []);
        return entries.length ? Object.fromEntries(entries) : undefined;
    }
}

var data = { TypeA: [{ price: [[{ amount: -45, currency: "USD" }]], name: "ABC", priceDetails: [{ name: "BASE", price: [[{ amount: -40, currency: "USD" }]] }, { name: "TAX", price: [[{ amount: -5, currency: "USD" }]] }] }], TypeB: [{ price: [[{ amount: 0, currency: "USD" }]], name: "ABC", priceDetails: [{ name: "BASE", price: [[{ amount: 0, currency: "USD" }]] }] }] },
    result = filter(data);

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

Можно использовать Object.entries, чтобы сделать ваш объект массивом, а затем просто filter, проверив, что every сумма больше 0:

const filtered = Object.entries(data).filter(([k, v]) =>
    v.every(s=> s.price.every(s1 => s1.every(s2 => s2.amount >= 0 )))
    && v.every(pd => pd.priceDetails.every(pdp => 
        pdp.price.every(pr => pr.every(prr => prr.amount >= 0))))
);

Пример:

const data = {
    "TypeA": [{
        "price": [ [{ "amount": -45, "currency": "USD"  }]
        ],
        "name": "ABC",
        "priceDetails": [{
            "name": "BASE",
            "price": [[{  "amount": -40.00, "currency": "USD" }]]
        },
        {
            "name": "TAX",
            "price": [ [{ "amount": -5.00, "currency": "USD" }]]
        }
        ]
    }],
    "TypeB": [{
        "price": [ [{"amount": 0, "currency": "USD" }]],
        "name": "ABC",
        "priceDetails": [{
            "name": "BASE",
            "price": [[{"amount": 0, "currency": "USD"}]]
        }]
    }]
};

const filtered = Object.entries(data).filter(([k, v]) =>
    v.every(s=> s.price.every(s1 => s1.every(s2 => s2.amount >= 0 )))
    && v.every(pd => pd.priceDetails.every(pdp => pdp.price.every(pr => pr.every(prr => prr.amount >= 0))))
);

const result = Object.fromEntries(filtered);
console.log(result);

Answer 3

cc = {
  "TypeA": [
    {
      "price": [
        [
          {
            "amount": -45,
            "currency": "USD"
          }
        ]
      ],
      "name": "ABC",
      "priceDetails": [
        {
          "name": "BASE",
          "price": [
            [
              {
                "amount": -40.00,
                "currency": "USD"
              }
            ]
          ]
        },
        {
          "name": "TAX",
          "price": [
            [
              {
                "amount": -5.00,
                "currency": "USD"
              }
            ]
          ]
        }
      ]
    }
  ],
  "TypeB": [
    {
      "price": [
        [
          {
            "amount": 0,
            "currency": "USD"
          }
        ]
      ],
      "name": "ABC",
      "priceDetails": [
        {
          "name": "BASE",
          "price": [
            [
              {
                "amount": 0,
                "currency": "USD"
              }
            ]
          ]
        }
      ]
    }
  ]
}

const dd = Object.keys(cc).reduce((acc, item) => {
  if (cc[item][0].price[0][0].amount >= 0) {
    acc[item] = cc[item];
   }
return acc;
}, {});
console.log(dd)

Попробуйте это

const result = Object.keys(data).filter(i => data[i][0].price[0][0].amount >= 0).map(y => data[y])
console.log(result) // positive amount array

Изменения : с редуктором

const dd = Object.keys(data).reduce((acc, item) => {
  if (data[item][0].price[0][0].amount >= 0) {
    acc[item] = data[item];
   }
return acc;
}, {});