omit

Copies an object without a selected set of properties.

Code

omit.ts

type KnownNonPlainObject =
  | readonly unknown[]
  | ((...args: never[]) => unknown)
  | (abstract new (...args: never[]) => unknown)
  | Date
  | RegExp
  | Error
  | PromiseLike<unknown>
  | ReadonlyMap<unknown, unknown>
  | ReadonlySet<unknown>
  | WeakMap<object, unknown>
  | WeakSet<object>
  | ArrayBuffer
  | SharedArrayBuffer
  | ArrayBufferView;

type PlainObjectInput<T extends object> =
  T extends KnownNonPlainObject ? never : T;

const assertDense = (values: readonly unknown[], name: string): void => {
  for (let index = 0; index < values.length; index += 1) {
    if (!Object.hasOwn(values, index)) {
      throw new TypeError(`${name} must not contain empty slots`);
    }
  }
};

const readDescriptorValue = (
  descriptor: PropertyDescriptor,
  receiver: object
): unknown => {
  if (Object.hasOwn(descriptor, "value")) return descriptor.value;
  return descriptor.get
    ? Reflect.apply(descriptor.get, receiver, [])
    : undefined;
};

/** Copies a plain object's own properties except for the selected keys. */
export const omit = <T extends object, K extends keyof T>(
  object: PlainObjectInput<T>,
  keys: readonly K[]
): Omit<T, K> => {
  const prototype = Object.getPrototypeOf(object) as object | null;
  if (
    Array.isArray(object) ||
    (prototype !== null && prototype !== Object.prototype)
  ) {
    throw new TypeError("object must be a plain object");
  }
  assertDense(keys, "keys");

  const result = Object.create(prototype) as Omit<T, K>;
  const properties = Reflect.ownKeys(object).flatMap((key) => {
    const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
    return descriptor ? [{ key, descriptor }] : [];
  });
  const entries = properties.map(({ key, descriptor }) => ({
    key,
    enumerable: descriptor.enumerable === true,
    value: readDescriptorValue(descriptor, object),
  }));
  for (const { key, value, enumerable } of entries) {
    Object.defineProperty(result, key, {
      value,
      enumerable,
      configurable: true,
      writable: true,
    });
  }
  for (const key of keys) Reflect.deleteProperty(result, key);
  return result;
};

Download

wget

Terminal

wget -O src/lib/omit.ts https://raw.githubusercontent.com/jrTilak/lazykit/HEAD/registry/functions/omit.ts

degit

Terminal

temp_dir="$(mktemp -d)" && bunx degit jrTilak/lazykit/registry/functions "$temp_dir" && mv "$temp_dir/omit.ts" src/lib/omit.ts && rm -r "$temp_dir"

Examples

omit.example.ts

import { omit } from "./omit";

const originalObject = {
  name: "Alice",
  age: 28,
  city: "Paris",
  occupation: "Engineer",
};

const omittedObject = omit(originalObject, ["age", "occupation"]);

console.log(omittedObject);
// Output: { name: "Alice", city: "Paris" }

omit.2.example.ts

import { omit } from "./omit";

const settings = {
  theme: "dark",
  notifications: true,
  language: "en",
  fontSize: 16,
  preferredColor: {
    primary: "blue",
    secondary: "green",
  }
};

const updatedSettings = omit(settings, ["theme", "fontSize", ]);

console.log(updatedSettings);
// Output: { notifications: true, language: "en" }

Props

• object (T) — Plain object to copy.
• keys (readonly K[]) — Dense list of string, number, or symbol keys to leave out.

Returns

Omit<T, K> — A shallow copy without the selected properties. All own string and symbol properties are preserved, including non-enumerable properties. The result preserves the source’s ordinary or null prototype. Arrays and class instances are rejected with TypeError.