If you don't want to modify the original object.

Remove a property without mutating the object

If mutability is a concern, you can create a completely new object by copying all the properties from the old, except the one you want to remove.

let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

let prop = 'regex';
const updatedObject = Object.keys(myObject).reduce((object, key) => {
  if (key !== prop) {
    object[key] = myObject[key]
  }
  return object
}, {})

console.log(updatedObject);

The straight way

As of 2023, you can do it in just one line:

delete myObject.regex;

OR

delete myObject["regex"];

(For instance if you have an object obj with a property called key-one, you cannot do obj.key-one, so here comes obj["key-one"]).

We can easily remove any property of an object by using the delete operator.

const object = {
  prop1: 10,
  prop2: 20,
  prop3: 30,
  "test prop": "This is test props"
}
console.log(object); // will print all 4 props

delete object.prop1;
delete object["test prop"];

console.log(object); // it will print only prop2 and prop3

See docs : MDN

Two ways to delete an object

1. using for ... in

    function deleteUser(key) {
   
        const newUsers = {};
        for (const uid in users) {
            if (uid !== key) {
                newUsers[uid] = users[uid];
            }
   
        return newUsers
    }
   

or

delete users[key]

We can remove using

1. using delete object.property
2. using delete object['property']
3. using rest, remove multiple property

let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*",
  "regex1": "^http://.*",
  "regex2": "^http://.*",
  "regex3": "^http://.*",
  "regex4": "^http://.*"
};

delete myObject.regex; // using delete object.property

// Or 

delete myObject['regex1']; // using delete object['property']

const { regex2, regex3, regex4, ...newMyObject } = myObject;

console.log(newMyObject);

You can delete property from object using Delete property[key]

In JavaScript, there are 2 common ways to remove properties from an object.

The first mutable approach is to use the delete object.property operator.

The second approach, which is immutable since it doesn't modify the original object, is to invoke the object destructuring and spread syntax: const {property, ...rest} = object

Short answer

var obj = {
  data: 1,
  anotherData: 'sample'    
}
delete obj.data //this removes data from the obj

You are left with

var obj = {
  anotherData: 'sample'    
}

This is how I do.

const obj = {
  name: 'John',
  age: 30,
  gender: 'male'
};

delete obj.age;

console.log(obj); // { name: 'John', gender: 'male' }

The following is a simple typescript safe function which returns a clone of a supplied object with an arbitrary number of properties removed:

function removePropertiesFromObject<T, K extends keyof T>(obj: T, ...properties: K[]) {
  const result = { ...obj };
  for (const prop of properties) {
    delete result[prop];
  }
  return result as Omit<T, K>;
}

Usage:

const original = { a: 1, b: 2, c: 3 };
const clone = removePropertiesFromObject(original, "a", "b");
console.log(clone); // { c: 3 }

Explanation:

The function has an object parameter (of type T) and a rest parameter for the properties to be removed (each of type K which is restricted to be a key of type T). When multiple properties are passed then K will be the union type of the properties provided. In the example above K will be of type "a" | "b".

The function then first clones the original object and subsequently removes the properties provided. This clone is still of type T though, so a cast is applied to re-align the type with the created object. In the example above this would lead to Omit<T, "a" | "b"> leaving "c" as the only resulting property of the return type.