Write a typesafe 'pick' function in typescript

Question

lodash has the pick function which is used as follows:

var object = { 'a': 1, 'b': '2', 'c': 3 };
 
_.pick(object, ['a', 'c']);
// => { 'a': 1, 'c': 3 }

I would like to write a type-safe version of this in typescript.

Usage of this function should be

pick(object, "a", "b")

The goal is to conserve type safety.

Is this possible to achieve?

Your pick function seem to have a different signature than the lodash example? What are those second and third parameters (particularly the third)? — CRice, Nov 10 '17 at 23:18
I just edited this question to make the accepted answer (and indeed all the answers) apply to it. It was originally written where the second argument was something like a callback that returned property values (although it was syntactically invalid, so not sure if that was the point). Changed it to a list of keys. Hope that's okay. — jcalz, May 19 '23 at 14:26

score 35 · Accepted Answer · answered Nov 10 '17 at 23:54

35

Sounds like you might be looking for the Pick type. Would something like this work for you?

function pick<T, K extends keyof T>(obj: T, ...keys: K[]): Pick<T, K> {
  const ret: any = {};
  keys.forEach(key => {
    ret[key] = obj[key];
  })
  return ret;
}

const o = {a: 1, b: '2', c: 3}
const picked = pick(o, 'b', 'c');

picked.a; // not allowed
picked.b  // string
picked.c  // number

answered Nov 10 '17 at 23:54

ethan.roday

2,485
1
23
27

Do you have suggestion how to get rid of any type here? – Dan Zawadzki Nov 12 '19 at 16:00
1

@DanZawadzki that depends. What would be the goal of doing that? As written, the `any` doesn't "seep" out of the implementation - it's just the easiest way to build up an object from nothing without making Typescript unhappy. – ethan.roday Nov 14 '19 at 17:42
2

In my version I decided to use the partial function. Project configuration often disallow the use of any interface, hence I wonder how to avoid it, with out disabling the rule. `const ret: Partial> = {}` instead of `const ret: any = {};` – Dan Zawadzki Nov 16 '19 at 17:24
The only negative I see with that is that you also need to change the return type to `Partial>`. If that's workable for you, though, sounds like a good solution. – ethan.roday Nov 16 '19 at 20:14
Is there any library with this pick helper method implemented for us? – Ozymandias Aug 21 '20 at 20:15
3

@DanZawadzki Based on the example about `unproxify` [in the typescript handbook](https://www.typescriptlang.org/docs/handbook/advanced-types.html), the response would be `const ret = {} as Pick`. – xanatos Nov 22 '20 at 13:41

bayu · Answer 2 · 2021-05-14T17:23:40.667

4

here's mine, using Object.assign()

function pick<T, K extends keyof T>(object: T, keys: K[]): Pick<T, K> {
  return Object.assign(
    {},
    ...keys.map(key => {
      if (object && Object.prototype.hasOwnProperty.call(object, key)) {
        return { [key]: object[key] };
      }
    })
  );
};

edited May 14 '21 at 17:23

answered May 14 '21 at 17:13

bayu

161
1
5

I like this solution because it avoids the use of `any` – brettinternet Jun 01 '23 at 20:33

score 3 · Answer 3 · answered Feb 14 '20 at 13:10

3

With Object.fromEntries (es2019):

function pick<T extends object, K extends keyof T> (base: T, ...keys: K[]): Pick<T, K> {
  const entries = keys.map(key => ([key, base[key]]));
  return Object.fromEntries(entries);
}

answered Feb 14 '20 at 13:10

Seb D.

5,046
1
28
36

1

This seems to incur a type error because the return type of `Object.fromEntries` is ```ts { [k: string]: T[K]; } ``` – Shahar 'Dawn' Or May 22 '20 at 06:05

score 1 · Answer 4 · answered Jan 17 '20 at 20:29

1

The lodash type definitions use Pick to propagate the props, so you don't have to define it manually. Just install them with npm i --save-dev @types/lodash or yarn add -D @types/lodash.

answered Jan 17 '20 at 20:29

Petr Bela

8,493
2
33
37

score 0 · Answer 5 · answered Jun 28 '21 at 16:42

Here mine, extending @Bayu Karnia answer:

function pick<T extends Record<string | number | symbol, T>, K extends keyof T>(
  object: T,
  keys: K[]
): Pick<T, K> {
  return Object.assign(
    {},
    ...keys.map((key: K) => {
      return { [key]: object[key] };
    })
  );
}

score 0 · Answer 6 · answered Mar 12 '23 at 09:42

Based on Ethan.Roday's answer, I made a few changes. Using Array.reduce and get rid of any type.

export function pick<T, K extends keyof T>(obj: T, keys: K[]) {
    return keys.reduce((acc, val) => {
        return (acc[val] = obj[val]), acc;
    }, {} as Pick<T, K>);
}

score 0 · Answer 7 · answered Apr 15 '23 at 23:45

Looks like I managed to swap arguments + curry and finally types are good enough. Will be grateful if somebody explains it:

const pick = <T, K extends keyof T>(keys: (keyof T)[]) => <R extends T>(obj: R) => keys.reduce<Pick<R, K>>((acc, key) => {
    (acc as T)[key] = obj[key]
    return acc;
}, {} as Pick<R, K>)

Write a typesafe 'pick' function in typescript

7 Answers7

Linked

Related