Deep functionality for omit

[ssesfahani]

I was wondering if there could be an enhancement to support deep functionality for _.omit or if it has been discussed before?

[jdalton]

We don't support deep omitting but can do deep partial matches of properties to omit because _.omit supports "_.where" callback shorthand, ex: _.omitBy(object, { 'a': { 'b': 2} }).

[megawac]

For pick/omit filtering arbitrary depth levels see this deepPick answer @ssesfahani

[aronwoost]

var o = {
  id: 1,
  value: "test",
  child: {
    id: 2,
    childValue: "test"
  }
}
_.omit(o, "value", "child.childValue");

... would be super awesome.

[bbottema]

We don't support deep omitting

Why is that, @jdalton, it's surely useful.

[jdalton]

Why is that, it's surely useful.

Nothing against it. Just waiting for a bit more user demand for the feature.

[PizzaBrandon]

I needed something like this, too, so I came up with the following:

function omitDeep(collection, excludeKeys) {

  function omitFn(value) {

    if (value && typeof value === 'object') {
      excludeKeys.forEach((key) => {
        delete value[key];
      });
    }
  }

  return _.cloneDeepWith(collection, omitFn);
}

It can certainly be made to be more generic and I'm sure there are optimizations that could be done here, but it worked for me and got rid of my annoying "Maximum call stack size exceeded" error when doing the same thing recursively myself.

[vladimirbuskin]

i've searched for that, vote from me
+1

[jdalton]

Don't forget to vote with reactions as it helps us sort by popularity.

[rebers]

Would love for both, _.omit and _.pick to work with paths.

[renehamburger]

BTW, this one is the most popular issue by now... Would it be worth putting it onto the roadmap?

[mohithg]

surely a good feature to be

[iam-peekay]

agreed! would be awesome and incredibly useful

[jdalton]

Thanks for the show of support for this feature!
This request is now open to PRs if anyone wants to give it a try.

[avivr]

I would love to give it a try

[jdalton]

@avivr The pull request contributing guide is a good place to start.

[doug-numetric]

Any chance for an array syntax for deep omit?

var o = {
  id: 1,
  value: "test",
  child: {
    id: 2,
    childValue: "test"
  }
}
// current way to handle computed key names
// let cv="childValue";
// _.omit(o, `child.${cv}`)
_.omit(o, ["child", "childValue"]);

For same reasons get supports this syntax.

[jdalton]

@doug-numetric

Any chance for an array syntax for deep omit?

The omit methods aren't being carried over to Lodash v5.

[Billy-]

@jdalton how come? Is there a replacement?

[jdalton]

Omit requires grabbing all possible properties (inherited, own, non-enumerable, symbols, etc.) and then filtering out properties. This is overly complicated and gets worse with deep functionality. It's better to pick the properties you want or simply delete the rogue ones.

[antony]

Lodash giveth, lodash taketh away :)

[ZephD]

Lodash giveth, lodash omit.

FTFY.

[bbottema]

Lodash giveth, lodash omit.

(but not deep)

[loopmode]

In my case, hard-source-webpack-plugin creates a hash of my webpack config, which is a fairly complex object, to check whether it can reuse previous results.
In production builds, certain properties of the config object contain dynamic values, like a timestamp in an output path, so the hash of the config object is always a new one. This effectively defeats the caching mechanism.
In such a case, picking/whitelisting is almost impossible whereas omitting/blacklisting a few well-known keys would be perfect.

I guess I'll have to clone the object, then somehow delete the rogue keys as mentioned above, then get it's hash.

[clodal]

Recursively omit keys from an object by defining an array of keys to exclude in ES6 + Typescript.

omitDeep(myObject, [omitKey1, omitKey2, ...omitKeyN])

// omitDeep.ts

/**
 * Recursively remove keys from an object
 * @usage
 *
 * const input = {
 *   id: 1,
 *   __typename: '123',
 *   createdAt: '1020209',
 *   address: {
 *     id: 1,
 *     __typename: '123',
 *   },
 *   variants: [
 *     20,
 *     {
 *       id: 22,
 *       title: 'hello world',
 *       __typename: '123',
 *       createdAt: '1020209',
 *       variantOption: {
 *         id: 1,
 *         __typename: '123',
 *       },
 *     },
 *     {
 *       id: 32,
 *       __typename: '123',
 *       createdAt: '1020209',
 *     },
 *   ],
 * }
 *
 * const output = {
 *   id: 1,
 *   address: {
 *     id: 1,
 *   },
 *   variants: [
 *     20,
 *     {
 *       id: 22,
 *       title: 'hello world',
 *       variantOption: {
 *         id: 1,
 *       },
 *     },
 *     {
 *       id: 32,
 *     },
 *   ],
 * }
 *
 * expect(omitDeep(input, ['createdAt, 'updatedAt', __typename']).to.deep.equal(output) // true
 *
 * @param {object} input
 * @param {Array<number | string>>} excludes
 * @return {object}
 */
const omitDeep = (input: object, excludes: Array<number | string>): object => {
  return Object.entries(input).reduce((nextInput, [key, value]) => {
    const shouldExclude = excludes.includes(key)
    if (shouldExclude) return nextInput

    if (Array.isArray(value)) {
      const arrValue = value
      const nextValue = arrValue.map((arrItem) => {
        if (typeof arrItem === 'object') {
          return omitDeep(arrItem, excludes)
        }
        return arrItem
      })
      nextInput[key] = nextValue
      return nextInput
    } else if (typeof value === 'object') {
      nextInput[key] = omitDeep(value, excludes)
      return nextInput
    }

    nextInput[key] = value

    return nextInput
  }, {})
}

export default omitDeep

[Billy-]

FWIW: here's my version

[mxmzb]

_.omit(o, "value", "child.childValue"); works right now, so no need to do it yourself ;)

[Billy-]

@mxmzb the main use-case that isn't supported is arrays (iterate over all items in an array)

[mxmzb]

@Billy- If you have explicit values and care about data structure, which I believe you should do, this is a very elegant approach:

const myNewObjectWithOmittedParams = Object.assign(
  {},
  {
    ...omit(myOldObject, ["bar", "foo.bar"])
  },
  {
    someChildArrayProp: myOldObject.someChildArrayProp.map(obj => omit(obj, ["bar", "foo.bar"]))
  }
}

[bdelmas]

@mxmzb Unless I have the wrong version but _.omit(o, "value", "child.childValue"); doesn't work for "child.childValue".

Edit:

It doensn't work with the lastest "lodash.omit": "^4.5.0",
But it does work with the full package "lodash": "^4.17.11",

lodash.omit has not being updated for too long.

[rwoody]

@clodal That works (I also had the same use case with __typename). I tweaked it a little bit to safely handle null/undefined values

[blikblum]

I tweaked it a little bit to safely handle null/undefined values

Can you post your version?

[dgsunesen]

@PizzaBrandon - Awesomesauce solution!

[jeshio]

@clodal thank you
This is with null fields handle version:

const omitDeep = (input: object, excludes: Array<number | string>): object => {
  return Object.entries(input).reduce((nextInput, [key, value]) => {
    const shouldExclude = excludes.includes(key)
    if (shouldExclude) return nextInput

    if (Array.isArray(value)) {
      const arrValue = value
      const nextValue = arrValue.map((arrItem) => {
        if (typeof arrItem === 'object' && arrItem !== null) {
          return omitDeep(arrItem, excludes)
        }
        return arrItem
      })
      nextInput[key] = nextValue
      return nextInput
    } else if (typeof value === 'object' && arrItem !== null) {
      nextInput[key] = omitDeep(value, excludes)
      return nextInput
    }

    nextInput[key] = value

    return nextInput
  }, {})
}

export default omitDeep

[cSweetMaj7]

@jeshio This is an NPE

} else if (typeof value === 'object' && arrItem !== null) {

arrItem only exists in the scope of the above arrValue.map.

[alfasin]

Why is that, it's surely useful.

Nothing against it. Just waiting for a bit more user demand for the feature.

Per all the responses here, it looks like there's a demand IMO.
Can we reopen?

[ulisesbocchio]

you can use cloneDeepWith:

function omitDeep(input, excludes) {
    const omit = [];
    const clone = _.cloneDeepWith(input, (value, key, object, stack) => {
        if(!_.isUndefined(key) && excludes.includes(key)) {
            omit.push({ key, from: stack.get(object) });
            return null;
        }
    });
    omit.forEach(({ key, from }) => _.unset(from, key));
    return clone;
}

I've been using something a bit more involved to omit anything past a given depth or have exclusion rules be regexes on full paths from the root of the input:

function deepCustomizer(customizer) {
    const depthMap = new WeakMap();
    return (value, key, object, stack) => {
        let depth = 0;
        let path = [];
        if (!_.isUndefined(key)) {
            const { depth: parentDepth, path: parentPath } = depthMap.get(object);
            depth = parentDepth + 1;
            path = [...parentPath, key];
        }
        if (_.isObject(value) && !_.isBuffer(value)) {
            depthMap.set(value, { depth, path });
        }
        return customizer(value, key, object, stack, depth, path);
    };
}

function omitDeep(input, excludes, maxDepth = Infinity) {
    const omit = [];
    const isExcluded = pathString => _.some(excludes, exclude => _.isRegExp(exclude) ? exclude.test(pathString) : exclude === pathString);
    const clone = _.cloneDeepWith(input, deepCustomizer((value, key, object, stack, depth, path) => {
        const pathString = _.join(path, '.');
        if(depth > maxDepth || isExcluded(pathString)) {
            omit.push({ key, from: stack.get(object) });
            return null;
        }
    }));
    omit.forEach(({ key, from }) => _.unset(from, key));
    return clone;
}

but it would be nice if at least lodash's customizer provides depth/path and a way to instruct omissions, maybe with a Symbol.

[lveillard]

Recursively omit keys from an object by defining an array of keys to exclude in ES6 + Typescript.

omitDeep(myObject, [omitKey1, omitKey2, ...omitKeyN])

// omitDeep.ts

/**
 * Recursively remove keys from an object
 * @usage
 *
 * const input = {
 *   id: 1,
 *   __typename: '123',
 *   createdAt: '1020209',
 *   address: {
 *     id: 1,
 *     __typename: '123',
 *   },
 *   variants: [
 *     20,
 *     {
 *       id: 22,
 *       title: 'hello world',
 *       __typename: '123',
 *       createdAt: '1020209',
 *       variantOption: {
 *         id: 1,
 *         __typename: '123',
 *       },
 *     },
 *     {
 *       id: 32,
 *       __typename: '123',
 *       createdAt: '1020209',
 *     },
 *   ],
 * }
 *
 * const output = {
 *   id: 1,
 *   address: {
 *     id: 1,
 *   },
 *   variants: [
 *     20,
 *     {
 *       id: 22,
 *       title: 'hello world',
 *       variantOption: {
 *         id: 1,
 *       },
 *     },
 *     {
 *       id: 32,
 *     },
 *   ],
 * }
 *
 * expect(omitDeep(input, ['createdAt, 'updatedAt', __typename']).to.deep.equal(output) // true
 *
 * @param {object} input
 * @param {Array<number | string>>} excludes
 * @return {object}
 */
const omitDeep = (input: object, excludes: Array<number | string>): object => {
  return Object.entries(input).reduce((nextInput, [key, value]) => {
    const shouldExclude = excludes.includes(key)
    if (shouldExclude) return nextInput

    if (Array.isArray(value)) {
      const arrValue = value
      const nextValue = arrValue.map((arrItem) => {
        if (typeof arrItem === 'object') {
          return omitDeep(arrItem, excludes)
        }
        return arrItem
      })
      nextInput[key] = nextValue
      return nextInput
    } else if (typeof value === 'object') {
      nextInput[key] = omitDeep(value, excludes)
      return nextInput
    }

    nextInput[key] = value

    return nextInput
  }, {})
}

export default omitDeep

This one breaks when having null values, you can filter them like this:

[...]
return Object.entries(input)
    .filter((x) => x[1] !== null) /newline
    .reduce [...]

[lsaadeh]

For my use case I just needed to remove undefined variables.. here my attempt.

const omitDeep = (input: any, omitValue = undefined): any => {
    if (Array.isArray(input)) {
      const arrValue = input.filter((e) => e !== omitValue);
      const nextValue = arrValue.map((arrItem) => {
        return this.omitDeep(arrItem, omitValue);
      });
      return nextValue;
    } else if (typeof input === 'object') {
      return Object.entries(input).reduce((nextInput: any, [key, value]) => {
        const shouldExclude = value === omitValue;
        if (shouldExclude) {
          return nextInput;
        }
        nextInput[key] = this.omitDeep(value, omitValue);
        return nextInput;
      }, {});
    } else {
      return input;
    }
  }

const object = {
    a: '',
    b: undefined,
  };

  const input = {
    a: '',
    b: undefined,
    c: [
      {
        a: '',
        b: undefined,
      },
      [
        {
          a: '',
          b: undefined,
        },
        [
          {
            a: '',
            b: undefined,
          },
          object,
          ['a', 'b', 'c', undefined, 1, 2, 3, ['a', 'b', 'c', undefined, 1, 2, 3, ['a', 'b', 'c', undefined, 1, 2, 3]]],
        ],
      ],
    ],
    d: {
      a: 'abc',
      b: undefined,
      c: {
        a: undefined,
        b: '',
      },
      d: 123,
    },
    e: object,
    f: ['a', 'b', 'c', undefined, 1, 2, 3, ['a', 'b', 'c', undefined, 1, 2, 3, ['a', 'b', 'c', undefined, 1, 2, 3]]],
  };

  const output = {
    a: '',
    c: [
      {
        a: '',
      },
      [
        {
          a: '',
        },
        [
          {
            a: '',
          },
          {
            a: '',
          },
          ['a', 'b', 'c', 1, 2, 3, ['a', 'b', 'c', 1, 2, 3, ['a', 'b', 'c', 1, 2, 3]]],
        ],
      ],
    ],
    d: {
      a: 'abc',
      c: {
        b: '',
      },
      d: 123,
    },
    e: {
      a: '',
    },
    f: ['a', 'b', 'c', 1, 2, 3, ['a', 'b', 'c', 1, 2, 3, ['a', 'b', 'c', 1, 2, 3]]],
  };

  [
    {
      description: 'should remove all values specified by omitDeep in an object',
      input: input,
      output: output,
    },
    {
      description: 'should remove all values specified by omitDeep in an array',
      input: [input],
      output: [output],
    },
  ].forEach((test) => {
    it(test.description, async () => {
      const json = omitDeep(test.input);
      expect(json).to.eql(test.output);
    });
  });

[teja123r]

I just had to deep omit certain keys given an object that might contain Arrays. Here's my attempt

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export const omitDeep = (obj: any, omitKeys: string[]): any => {
  if (Array.isArray(obj)) {
    return obj.map((v) => omitDeep(v, omitKeys));
  } else if (obj != null && obj.constructor === Object) {
    for (const key in obj) {
      const value = obj[key];
      if (value != null && value.constructor === Object) {
        omitDeep(value, omitKeys);
      } else if (omitKeys.includes(key)) {
        delete obj[key];
      }
    }
  }
  return obj;
};

[esistgut]

Typescript version of #723 (comment):

export function omitDeep<T>(collection: T, excludeKeys: string[]): T {
  function omitFn(value: any) {
    if (value && typeof value === 'object') {
      excludeKeys.forEach((key) => {
        delete value[key];
      });
    }
  }

  return cloneDeepWith(collection, omitFn);
}

[azerum]

Here's a TypeScript types-aware version (doesn't work with Map and Set, but those can be added):

export type OmitDeep<T, K extends string> = 
  T extends (infer U)[]
    ? OmitDeep<U, K>[]
    : T extends Record<any, any>
      ? { [P in keyof T as P extends K ? never : P]: OmitDeep<T[P], K> }
      : T;

export function omitDeep<
  T extends object,
  K extends string,
>(obj: T, key: K): OmitDeep<T, K> {
  const clone: any = {};

  for (const property in obj) {
    const value = obj[property];

    //@ts-expect-error The types of those values can overlap
    if (property === key) {
      continue;
    }

    if (Array.isArray(value)) {
      clone[property] = value.map((item) => omitDeep(item, key));
      continue;
    }

    if (value !== null && typeof value === "object") {
      clone[property] = omitDeep(value, key);
      continue;
    }

    clone[property] = value;
  }

  return clone;
}