Enhancing Flexibility with Optional Properties in TypeScript

1. Using the Optional Property Modifier (?):

   • You can mark individual properties as optional by adding a question mark (?) after the property name.
   • This syntax tells TypeScript that the property might not be present on objects adhering to the interface.

   Here's an example:

   interface User {
       name: string;
       age?: number; // Optional property
       location?: string; // Optional property
   }
   

   In this example, name is required, but age and location can be omitted when creating a User object.

2. Using the Partial<T> Utility Type:

   • TypeScript offers a built-in utility type called Partial<T>.
   • This type takes another type (T) and creates a new type where all the properties of T are made optional.

   Here's how to use it:

   interface Product {
       id: number;
       name: string;
       price: number;
   }
   
   type PartialProduct = Partial<Product>; // All properties become optional
   
   let partialProduct: PartialProduct = {
       id: 123,
       name: "Widget"
   };
   

   In this example, the PartialProduct type makes all properties of the Product interface optional. The partialProduct object only defines id and name, which is allowed because both are now optional.

Choosing the Right Approach:

• Use the optional property modifier (?) when you want to define optional properties within a single interface.
• Use the Partial<T> utility type when you need to create a new type with all properties from another type being optional. This is helpful for scenarios where you want to represent a subset of properties from an existing interface.

interface User {
  name: string;
  age?: number; // Optional property
  location?: string; // Optional property
}

function greetUser(user: User) {
  console.log("Hello, " + user.name);
  if (user.age) {
    console.log("You are " + user.age + " years old.");
  }
  if (user.location) {
    console.log("You are from " + user.location + ".");
  }
}

const user1: User = {
  name: "Alice",
  age: 30,
  location: "Wonderland",
};

const user2: User = {
  name: "Bob",
};

greetUser(user1); // Prints all details
greetUser(user2); // Prints only the name

interface Product {
  id: number;
  name: string;
  price: number;
}

type PartialProduct = Partial<Product>; // All properties become optional

function displayProduct(product: PartialProduct) {
  console.log("Product ID:", product.id || "Not provided"); // Use default value for missing properties
  console.log("Product Name:", product.name || "Not provided");
  console.log("Product Price:", product.price || "Not provided");
}

const fullProduct: Product = {
  id: 123,
  name: "Widget",
  price: 19.99,
};

const partialProduct: PartialProduct = {
  id: 456,
  name: "Gizmo",
};

displayProduct(fullProduct);
displayProduct(partialProduct);

1. Union Types:

   • You can define a union type that combines the original interface with another interface containing only optional properties.

   interface User {
       name: string;
   }
   
   interface OptionalUser {
       age?: number;
       location?: string;
   }
   
   type UserWithOptional = User & OptionalUser; // Intersection combines required and optional
   
   const user1: UserWithOptional = {
       name: "Alice",
       age: 30,
       location: "Wonderland",
   };
   
   const user2: UserWithOptional = {
       name: "Bob",
   };
   

   This approach offers more control over which properties are truly optional. However, it can become cumbersome for interfaces with many optional properties.

2. Default Parameter Values:

   • While not directly applicable to interfaces, you can utilize default parameter values in functions that accept objects adhering to the interface.

   function greetUser(user: User = { age: 0, location: "" }) {
       console.log("Hello, " + user.name);
       console.log("You are " + user.age + " years old.");
       console.log("You are from " + user.location + ".");
   }
   
   greetUser({ name: "Alice" }); // Uses default values for missing properties
   

   This approach provides a way to handle missing properties without explicitly making them optional in the interface. However, it only works for function parameters and not for the interface definition itself.