CODEWITHSUNDEEP
javascripttypescriptunderscore.jslodashecmascript-2016
Salami
Salami

Reputation: 3117

TypeScript Type-safe Omit Function

I want to replicate lodash's _.omit function in plain typescript. omit should return an object with certain properties removed specified via parameters after the object parameter which comes first.

Here is my best attempt:

function omit<T extends object, K extends keyof T>(obj: T, ...keys: K[]): {[k in Exclude<keyof T, K>]: T[k]} {
    let ret: any = {};
    let key: keyof T;
    for (key in obj) {
        if (!(keys.includes(key))) {
            ret[key] = obj[key];
        }
    }
    return ret;
}

Which gives me this error:

Argument of type 'keyof T' is not assignable to parameter of type 'K'.
  Type 'string | number | symbol' is not assignable to type 'K'.
    Type 'string' is not assignable to type 'K'.ts(2345)
let key: keyof T

My interpretation of the error is that:

  1. Since key is a keyof T and T is an object, key can be a symbol, number or string.

  2. Since I use the for in loop, key can only be a string but includes might take a number if I pass in an array, for example? I think. So that means there's a type error here?

Any insights as to why this doesn't work and how to make it work are appreciated!

Upvotes: 17

Views: 24372

Answers (9)

ronen
ronen

Reputation: 2598

Here's a one-liner that returns a new object, using Object.fromEntries():

function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> {
  return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key as K))) as Omit<T, K>
}

Upvotes: 0

Manish Kumar
Manish Kumar

Reputation: 1176

Using the array reduce method to omit the props.

const omitProps = <T extends object, K extends keyof T>(
  data: T,
  props: Array<K>
): Omit<T, K> => {
  if (!data || !Array.isArray(props) || !props.length) {
    return data;
  }
  return props.reduce((acc, prop) => {
    const { [prop as keyof object]: prop1, ...rest } = acc;
    return rest;
  }, data);
};

Upvotes: 0

Jacek Plesnar
Jacek Plesnar

Reputation: 505

Not sure if I get a point but I came across similar issue that I wanted be sure that I make no typo when omitting properties so I came to solution like this:

export interface Person {
  id: string;
  firstName: string;
  lastName: string;
  password: string;
}

type LimitedDTO<K extends keyof Person> = Omit<Person, K>;

export type PersonDTO = LimitedDTO<"password" | "lastName">;

And tsc will not allow you omit property which is not present on Person interface

Upvotes: 1

captain-yossarian from Ukraine
captain-yossarian from Ukraine

Reputation: 33061

Unfortunately, it is impossible to get rid of as any

const removeProperty = <Obj, Prop extends keyof Obj>(
  obj: Obj,
  prop: Prop
): Omit<Obj, Prop> => {
  const { [prop]: _, ...rest } = obj;

  return rest;
};

export default removeProperty;


const omit = <Obj, Prop extends keyof Obj, Props extends ReadonlyArray<Prop>>(
  obj: Obj,
  props: readonly [...Props]
): Omit<Obj, Props[number]> =>
  props.reduce(removeProperty, obj as any);

Playground

Upvotes: 0

90dy
90dy

Reputation: 131

Simplest way:

export const omit = <T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> => {
  keys.forEach((key) => delete obj[key])
  return obj
}

As a pure function:

export const omit = <T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> => {
  const _ = { ...obj }
  keys.forEach((key) => delete _[key])
  return _
}

Upvotes: 13

Nurbol Alpysbayev
Nurbol Alpysbayev

Reputation: 21891

interface Omit {
    <T extends object, K extends [...(keyof T)[]]>
    (obj: T, ...keys: K): {
        [K2 in Exclude<keyof T, K[number]>]: T[K2]
    }
}

const omit: Omit = (obj, ...keys) => {
    const ret = {} as {
        [K in keyof typeof obj]: (typeof obj)[K]
    };
    let key: keyof typeof obj;
    for (key in obj) {
        if (!(keys.includes(key))) {
            ret[key] = obj[key];
        }
    }
    return ret;
};

For convenience I've pulled most of the typings to an interface.

The problem was that K had been being inferred as a tuple, not as a union of keys. Hence, I changed it's type constraint accordingly:

[...(keyof T)[]] // which can be broke down to:
keyof T // a union of keys of T
(keyof T)[] // an array containing keys of T
[...X] // a tuple that contains X (zero or more arrays like the  described one above)

Then, we need to transform the tuple K to a union (in order to Exclude it from keyof T). It is done with K[number], which is I guess is self-explaining, it's the same as T[keyof T] creating a union of values of T.

Playground

Upvotes: 35

Jonas Tomanga
Jonas Tomanga

Reputation: 1108

Object.keys or for in returns keys as string and excludes symbols. Numeric keys are also converted to strings.

You need to convert numeric string keys to numbers otherwise it will return the object with string keys.

function omit<T extends Record<string | number, T['']>,
 K extends [...(keyof T)[]]>(
    obj: T,
    ...keys: K
): { [P in Exclude<keyof T, K[number]>]: T[P] } {
    return (Object.keys(obj)
         .map((key) => convertToNumbers(keys, key)) as Array<keyof T>)
        .filter((key) => !keys.includes(key))
        .reduce((agg, key) => ({ ...agg, [key]: obj[key] }), {}) as {
        [P in Exclude<keyof T, K[number]>]: T[P];
    };
}

function convertToNumbers(
    keys: Array<string | number | symbol>,
    value: string | number
): number | string {
    if (!isNaN(Number(value)) && keys.some((v) => v === Number(value))) {
        return Number(value);
    }

    return value;
}


// without converToNumbers omit({1:1,2:'2'}, 1) will return {'1':1, '2':'2'}
// Specifying a numeric string instead of a number will fail in Typescript

To include symbols you can use the code below.

function omit<T, K extends [...(keyof T)[]]>(
    obj: T,
    ...keys: K
): { [P in Exclude<keyof T, K[number]>]: T[P] } {
    return (Object.getOwnPropertySymbols(obj) as Array<keyof T>)
        .concat(Object.keys(obj)
        .map((key) => convertToNumbers(keys, key)) as Array<keyof T>)
        .filter((key) => !keys.includes(key))
        .reduce((agg, key) => ({ ...agg, [key]: obj[key] }), {}) as {
        [P in Exclude<keyof T, K[number]>]: T[P];
    };
}

Upvotes: 1

Jeremy Chone
Jeremy Chone

Reputation: 3157

The accepted answer from Nurbol above is probably the more typed version, but here is what I am doing in my utils-min.

It uses the typescript built-in Omit and is designed to only support string key names. (still need to loosen up the Set to Set, but everything else seems to work nicely)

export function omit<T extends object, K extends Extract<keyof T, string>>(obj: T, ...keys: K[]): Omit<T, K> {
  let ret: any = {};
  const excludeSet: Set<string> = new Set(keys); 
  // TS-NOTE: Set<K> makes the obj[key] type check fail. So, loosing typing here. 

  for (let key in obj) {
    if (!excludeSet.has(key)) {
      ret[key] = obj[key];
    }
  }
  return ret;
}

Upvotes: 2

郭一凡
郭一凡

Reputation: 36

If we limit the type of keys to string [],It works. But it does not seem to be a good idea.Keys should be string | number | symbol[];

function omit<T, K extends string>(
  obj: T,
  ...keys: K[]
): { [k in Exclude<keyof T, K>]: T[k] } {
  let ret: any = {};
  Object.keys(obj)
    .filter((key: K) => !keys.includes(key))
    .forEach(key => {
      ret[key] = obj[key];
    });
  return ret;
}
const result = omit({ a: 1, b: 2, c: 3 }, 'a', 'c');
// The compiler inferred result as 
// {
//   b: number;
// }

Upvotes: 0

Related Questions