Alternative Methods for Setting Default Values in TypeScript Objects

Understanding the Concept:

• When passing objects as arguments to functions in TypeScript, you can provide default values for their properties.
• This ensures that the function has well-defined behavior even if the object passed to it lacks certain properties or if those properties are undefined.
• Default values are especially useful when working with optional arguments or when you want to provide fallback values.

Methods for Setting Default Values:

1. Object Destructuring and Default Values:

   • This method is concise and readable.
   • You destructure the object argument and assign default values to properties that might be missing or undefined.
   • Example:

   function greet(user: { name: string; age?: number }) {
       const { name, age = 30 } = user;
       console.log(`Hello, ${name}! You are ${age} years old.`);
   }
   
   greet({ name: "Alice" }); // Output: Hello, Alice! You are 30 years old.
   

2. Optional Chaining and Default Values:

   • This method is useful when you need to access nested properties that might be undefined or null.
   • You use the optional chaining operator (?.) to safely access properties, and provide a default value if the property is missing.

   function getFullName(user: { name: string; address?: { street: string } }) {
       const fullName = user?.name || "Unknown";
       const street = user?.address?.street || "N/A";
       return `${fullName} from ${street}`;
   }
   
   getFullName({ name: "Bob" }); // Output: Bob from N/A
   

3. Default Parameters:

   • This method is similar to optional arguments in JavaScript.
   • You assign default values directly to the function parameters.
   • However, it's less common for objects in TypeScript since object destructuring is often preferred.

   function greet(user: { name: string; age: number = 30 }) {
       console.log(`Hello, ${user.name}! You are ${user.age} years old.`);
   }
   
   greet({ name: "Charlie" }); // Output: Hello, Charlie! You are 30 years old.
   

Key Considerations:

• Choose the method that best suits your specific use case and coding style.
• Be mindful of potential type narrowing when using optional chaining or default values.
• Consider using type guards or type assertions to ensure correct type handling.

Setting Default Values for TypeScript Objects Passed as Arguments

Understanding the Concept: When passing objects as arguments to TypeScript functions, you can provide default values for their properties. This ensures that the function has well-defined behavior even if the object passed to it lacks certain properties or if those properties are undefined.

function greet(user: { name: string; age?: number }) {
    const { name, age = 30 } = user;
    console.log(`Hello, ${name}! You are ${age} years old.`);
}

greet({ name: "Alice" }); // Output: Hello, Alice! You are 30 years old.

• Breakdown:
  • We define a function greet that takes an object user with properties name and optionally age.
  • Inside the function, we destructure the user object, assigning name to the name variable and age to the age variable.
  • If age is not provided, it defaults to 30.

function getFullName(user: { name: string; address?: { street: string } }) {
    const fullName = user?.name || "Unknown";
    const street = user?.address?.street || "N/A";
    return `${fullName} from ${street}`;
}

getFullName({ name: "Bob" }); // Output: Bob from N/A

• Breakdown:
  • We define a function getFullName that takes an object user with properties name and optionally address (which itself has a property street).
  • We use optional chaining (?.) to safely access nested properties. If a property is undefined or null, the expression evaluates to undefined.
  • We use the logical OR operator (||) to provide default values for fullName and street if they are undefined.

Method 3: Default Parameters

function greet(user: { name: string; age: number = 30 }) {
    console.log(`Hello, ${user.name}! You are ${user.age} years old.`);
}

greet({ name: "Charlie" }); // Output: Hello, Charlie! You are 30 years old.

• Breakdown:
  • We assign a default value of 30 to the age property directly in the function parameter declaration.

Alternative Methods for Setting Default Values in TypeScript Objects

While the methods described previously are common and effective, here are some additional approaches you can consider:

Using a Factory Function

• Purpose: Create objects with predefined default values.

function createUser(name: string, age: number = 30): { name: string; age: number } {
    return { name, age };
}

const user = createUser("Alice");
console.log(user); // Output: { name: 'Alice', age: 30 }

Leveraging the Partial Utility Type

• Purpose: Make object properties optional.

type User = { name: string; age?: number };

function greet(user: Partial<User>) {
    const { name, age = 30 } = user;
    console.log(`Hello, ${name}! You are ${age} years old.`);
}

greet({ name: "Bob" });

Conditional Type Checks

• Purpose: Provide different default values based on conditions.

type User = { name: string; age?: number; isAdult?: boolean };

function greet(user: User) {
    const defaultAge = user.isAdult ? 18 : 10;
    const { name, age = defaultAge } = user;
    console.log(`Hello, ${name}! You are ${age} years old.`);
}

greet({ name: "Charlie", isAdult: true });

Using a Default Object

• Purpose: Create a default object and merge it with the provided object.

const defaultUser: User = { name: "Unknown", age: 30 };

function greet(user: Partial<User>) {
    const mergedUser = { ...defaultUser, ...user };
    const { name, age } = mergedUser;
    console.log(`Hello, ${name}! You are ${age} years old.`);
}

greet({ name: "David" });