Easiest method:

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

Transformed into a pure function:

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

The answer provided by Nurbol earlier may be a popular choice, but I have my own approach implemented in the utils-min program.

This solution involves utilizing TypeScript's built-in Omit feature and is specifically tailored to only handle string key names. (Although there is still room for improvement with regards to handling Set to Set conversions, everything else seems to be functioning smoothly)

export function omit<T extends object, K extends Extract<keyof T, string>>(obj: T, ...keys: K[]): Omit<T, K> {
  let result: any = {};
  const exclusionSet: Set<string> = new Set(keys); 
  // Note: Setting type as Set<K> causes issues with checking obj[key]'s type.

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

Object.keys and for in methods retrieve keys as strings, excluding symbols. Numeric keys are automatically converted to strings.

If you have numeric string keys in an object, you must convert them to numbers to avoid returning 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;
}


// omit({1:1,2:'2'}, 1) will return {'1':1, '2':'2'} if convertToNumbers function is not used.
// Using a numeric string instead of a number will result in failure within Typescript

To include symbols in your object manipulation code, you can utilize the following snippet:

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];
    };
}

While facing a similar issue where I needed to make sure there were no typos when omitting properties, I found a solution that worked for me:

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">;

By using this approach, TypeScript will prevent you from omitting a property that is not present in the Person interface.

When we restrict the type of keys to string [], it functions correctly. However, this approach may not be the most optimal. It would be better if keys are allowed to be string | number | symbol[];

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

Regrettably, eliminating as any is an unattainable task.

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

Utilizing the array reduce function to eliminate certain properties.

const filterProperties = <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);
};

Try out this concise one-liner that creates a new object by utilizing the function Object.fromEntries():

const omitProperties = <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>
}