How to do projection in TypeScript?

Question

I want to populate orders which is an array of type Order. The expected result is orders=[{id:1,qt:4},{id:2, qt:2},{id:3,qt:2}]. How to do so in TypeScript? I am new to it.

export class Product {
  constructor(public id: number, public name: string, public price: number) {}
}
export interface Order {
  id: number;
  qt: number;
}

export const products: Product[] = [
  new Product(1, 'Apple', 2.1),
  new Product(2, 'Banana', 2.2),
  new Product(3, 'Chocolate', 2.3),
  new Product(4, 'Dessert', 2.4),
];

export const cart: Product[] = [
  products[0],
  products[0],
  products[2],
  products[1],
  products[2],
  products[0],
  products[1],
  products[0],
];

export const orders: Order[] = [];

Edit

For those who want to know how orders=[{id:1,qt:4},{id:2, qt:2},{id:3,qt:2}] is obtained.

In the cart:

the quantity of apples (id:1) is qt:4
the quantity of bananas (id:2) is qt:2
the quantity of chocolates (id:3) is qt:2

So by using cart, I have to obtain orders=[{id:1,qt:4},{id:2, qt:2},{id:3,qt:2}]. It should be clear.

`id` is a field on product, sure. But how is `qt` determined? There's no `qt` field on the `Product` class you've shown. — Silvio Mayolo, Nov 07 '21 at 05:51
@SilvioMayolo: `qt` represents the frequency of a certain product id in the cart. — Second Person Shooter, Nov 07 '21 at 05:52
Are you looking for something more clever than a `for` loop? Because my first instinct is the simple approach. — Silvio Mayolo, Nov 07 '21 at 05:53
In that case, you may find yourself disappointed. There are surely libraries out there that will LINQ-type queries, but Typescript on its own isn't going to help you too much in that department. — Silvio Mayolo, Nov 07 '21 at 05:55
So how the cart is represented currently. It is not clear from where `qt` should be taken from. What data structure should be transformed to `Order[]`? — Aleksey L., Nov 07 '21 at 06:33
@AlekseyL. OP commented "`qt` represents the frequency of a certain product id in the cart". So it's supposed to be counted from the `cart`. The question ought to include that comment though. — Chase, Nov 07 '21 at 06:39
The cart is represented by object like `{ 1: 4, 2: 2, 3: 2}`? — Aleksey L., Nov 07 '21 at 06:41

Chase · Accepted Answer · 2021-11-07T06:37:16.833

Since you're looking for a "LINQ-like" solution, you probably want to use the higher order functions like map/filter/reduce.

Strictly, your problem cannot be solved purely with LINQ projections. Those merely represent map (Select), concatMap/flatMap (SelectMany), and zip (Zip). Your problem involves counting the occurences of each id throughout the entire array.

Pretty much every data manipulation problem can be solved with higher order folds, i.e reduce in javascript land, Aggregate in C# land. This one is no exception. The first thing to do, is to count the occurrences of each id, and build a counter object.

cart.reduce((acc, { id }) => {
    acc[id] = (acc[id] ?? 0) + 1;
    return acc;
}, {} as Record<number, number>);

Essentially, you start the fold operation with an empty object, then add each id and its occurrence count. Every time an id is encountered in the cart array, you increment its count in the object. If the id doesn't already exist in the accumulating object, nullish coalescing (acc[id] ?? 0) uses 0 and increments that instead.

This will give you-

{ '1': 4, '2': 2, '3': 2 }

Now, you need to turn this into-

[ { id: 1, qt: 4 }, { id: 2, qt: 2 }, { id: 3, qt: 2 } ]

For that, use Object.entries on the fold result to get-

> Object.entries({ '1': 4, '2': 2, '3': 2 })
[ [ '1', 4 ], [ '2', 2 ], [ '3', 2 ] ]

Finally, a simple map is all you need-

Object.entries(...).map(([id, qt]) => ({ id: Number(id), qt }))

Combining all that, you have-

export const orders: Order[] = Object.entries(
    cart.reduce((acc, { id }) => {
        acc[id] = (acc[id] ?? 0) + 1;
        return acc;
    }, {} as Record<number, number>)
).map(([id, qt]) => ({ id: Number(id), qt }));

One thing to note here is that Object.entries is pretty inefficient since it builds up an array instead of an iterator. If you're into efficiency, roll an iterator version of Object.entries and use that instead, using generator functions-

function* objEntries<T>(x: Record<string, T>): IterableIterator<[string, T]> {
  for (const k in x) {
    yield [k, x[k]];
  }
}

How to do projection in TypeScript?

Edit

1 Answers1