When working with objects in TypeScript, you may need to remove properties from objects dynamically. Whether you're cleaning up data before sending it to an API or modifying an object's structure, understanding how to remove properties is essential.

In this blog post, we will explore different techniques for removing properties from TypeScript objects and provide code samples to illustrate each method. Let's dive in!

1,  Using the delete Operator

The delete operator is the most common way to remove a property from an object in JavaScript and TypeScript. It effectively removes the property from the object and returns true if the operation was successful.

interface Person {
  name: string;
  age: number;
  email?: string;

const person: Person = {
  name: "John Doe",
  age: 30,
  email: "john.doe@example.com"

// Remove the 'email' property
delete person.email;
console.log(person); // Output: { name: 'John Doe', age: 30 }

2,  Using Object Destructuring and Rest Parameters

Another approach to removing properties from an object is to use object destructuring and rest parameters. This method allows you to extract the unwanted property from the object and create a new object without it.

interface Product {
  id: number;
  name: string;
  price: number;
  discount?: number;

const product: Product = {
  id: 1,
  name: "Laptop",
  price: 1200,
  discount: 100

// Remove the 'discount' property
const { discount, ...productWithoutDiscount } = product;
console.log(productWithoutDiscount); // Output: { id: 1, name: 'Laptop', price: 1200 }

3,  Creating a Utility Function

If you need to remove properties from objects frequently, it's a good idea to create a utility function that takes an object and a list of properties to remove. This function can use either the delete operator or object destructuring, depending on your preference.

function removeProperties<T extends object>(obj: T, ...props: (keyof T)[]): Partial<T> {
  const newObj = { ...obj };
  for (const prop of props) {
    delete newObj[prop];
  return newObj;

interface Employee {
  id: number;
  firstName: string;
  lastName: string;
  salary: number;

const employee: Employee = {
  id: 1,
  firstName: "Jane",
  lastName: "Smith",
  salary: 50000

const employeeWithoutSalary = removeProperties(employee, "salary");
console.log(employeeWithoutSalary); // Output: { id: 1, firstName: 'Jane', lastName: 'Smith' }

4,  Using the Omit Type

In some cases, you may want to create a new type based on an existing one but exclude specific properties. The Omit utility type allows you to do just that.

interface User {
  id: number;
  username: string;
  password: string;
  role: string;

type PublicUser = Omit<User, "password">;

const user: User = {
  id: 1,
  username: "johndoe",
  password: "123456",
  role: "admin"

function toPublicUser(user: User): PublicUser {
  const { password, ...publicUser } = user;
  return publicUser;

const publicUser = toPublicUser(user);
console.log(publicUser); // Output: { id: 1, username: 'j


Removing properties from TypeScript objects is a common task that developers face when manipulating data structures or preparing data for external APIs. In this blog post, we explored various techniques to remove properties from TypeScript objects, such as using the delete operator, object destructuring, creating utility functions, and leveraging the Omit type.

When choosing a method, consider your specific use case and the desired outcome. For example, if you need to remove properties from an object and create a new object without mutating the original, object destructuring is a suitable choice. On the other hand, if you need to exclude specific properties while creating new types, the Omit utility type is an excellent option.

By understanding these techniques, you can ensure clean and efficient data manipulation in your TypeScript applications.

If you are interested in similar posts, take a look at my home page to find similar articles.