ES5/ES6/ES2017/ES2019 omit & pick

ES5-ES6-ES2017-ES2019 omit & pick

​

omit-es2015.js

Object.keys(obj)
.filter((key) => ['blacklisted', 'keys'].indexOf(key) < 0)
.reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {})

omit-es2017.js

Object.entries(obj)
.filter(([key]) => !['blacklisted', 'keys'].includes(key))
.reduce((obj, [key, val]) => Object.assign(obj, { [key]: val }), {});

omit-es2019.js

Object.fromEntries(
  Object.entries(obj)
  .filter(([key]) => !['blacklisted', 'keys'].includes(key))
);

pick-es2015.js

Object.keys(obj)
.filter((key) => ['whitelisted', 'keys'].indexOf(key) >= 0)
.reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {})

pick-es2017.js

Object.entries(obj)
.filter(([key]) => ['whitelisted', 'keys'].includes(key))
.reduce((obj, [key, val]) => Object.assign(obj, { [key]: val }), {});

pick-es2019.js

Object.fromEntries(
  Object.entries(obj)
  .filter(([key]) => ['whitelisted', 'keys'].includes(key))
);

const buildAnObjectFromAQuery = query => ({
  ...query.foo && { foo: query.foo },
  ...query.bar && { bar: query.bar },
});

https://medium.com/@mikeh91/conditionally-adding-keys-to-javascript-objects-using-spread-operators-and-short-circuit-evaluation-acf157488ede

@kgstew It's good only for cases where only truthy values are useful, e.g. foo and bar are objects. Even better with destructuring:

const buildAnObjectFromAQuery = ({ foo, bar }) => ({
  ...foo && { foo },
  ...bar && { bar }
});

Another solution to omit on a line can be:

const omit = (props, obj) => props.reduce((acc, key) => ((key, {[key]: _, ...rest}) => rest)(key, acc), obj)

Object.assign({}, ...['whitelisted', 'keys'].map(key => ({ [key]: obj[key] })))

This will not work if obj is an empty object.

Typesafe omit:

export function omit<T extends object, K extends keyof T>(obj: T, paths: K[]): Omit<T, K> {
  return {
    ...paths.reduce((mem, key) => ((k: K, { [k]: ignored, ...rest }) => rest)(key, mem), obj as object),
  } as Omit<T, K>;
}

Another solution to pick

const pick = <T extends object, K extends keyof T>(
    whitelisted: K[],
    target: T,
    defaultValue?: any
) =>
    Object.fromEntries(
        whitelisted.map((key) =>
            [ key, key in target ? target[key] : defaultValue ]
        )
    );