How to Set Default Values for Object Parameters in TypeScript

By the end of this page, you will understand how default values work for object parameters in TypeScript, why defaults cannot be written inside a type definition, and the best patterns to use instead. You will also learn when to use destructuring defaults, nullish coalescing, and fallback assignment safely.

In TypeScript, types describe shape, but they do not create runtime values.

That is the key idea behind this question.

When you write a type like this:

{ firstName: string; lastName?: string }

TypeScript is only saying:

• firstName must exist and be a string
• lastName is optional
• if lastName exists, it must be a string

It is not saying what value lastName should get if it is missing.

A default value such as 'smith' is a runtime behavior, not a type rule. That is why this does not work:

function sayName(params: { firstName: string; lastName: string = 'smith' }) {

Type annotations cannot contain executable default assignments.

Why this matters

In real programs, object parameters are common for:

Think of a TypeScript type as a form template and a default value as a person filling in a blank space.

• The type says which blanks exist and what kind of values are allowed.
• The default value is the action of filling in a blank if the user leaves it empty.

So:

• Type: "There may be a lastName field. If it exists, it must be a string."
• Default: "If no lastName was provided, use 'smith'."

The template itself does not fill in the value. Your runtime code does.

Another way to think about it:

• TypeScript types are like blueprints
• Defaults are like construction decisions made while building

The blueprint does not install the door. The builder does.

Basic object parameter with an optional property

function sayName(params: { firstName: string; lastName?: string }) {
  const lastName = params.lastName ?? 'smith';
  const name = firstName + lastName;
}

The problem above is that firstName is not defined as a local variable. A corrected version is:

function sayName(params: { firstName: string; lastName?: string }) {
  const lastName = params.lastName ?? 'smith';
  const name = params.firstName + lastName;
  alert(name);
}

Preferred approach: destructuring with a default

function sayName(
  { firstName, lastName = 'smith' }: { firstName: string; lastName?: string }
) {
  const name = firstName + lastName;
  alert(name);
}

({ :  });
({ : , :  });

Consider this version:

type SayNameParams = {
  firstName: string;
  lastName?: string;
};

function sayName({ firstName, lastName = 'smith' }: SayNameParams) {
  const fullName = firstName + ' ' + lastName;
  console.log(fullName);
}

sayName({ firstName: 'bob' });

What happens step by step

1. The function is called

sayName({ firstName: 'bob' });

The argument object contains:

{ firstName: 'bob' }

2. Parameter destructuring runs

This part of the function executes:

{ firstName, lastName = 'smith' }

TypeScript/JavaScript extracts properties from the object:

Object parameter defaults are very common in real software.

1. Function options objects

type RequestOptions = {
  method?: string;
  timeout?: number;
};

function makeRequest(url: string, { method = 'GET', timeout = 5000 }: RequestOptions = {}) {
  console.log(url, method, timeout);
}

Used in:

• HTTP helpers
• database query functions
• file operations

2. UI component props

type ButtonProps = {
  label: string;
  color?: string;
};

function renderButton({ label, color = 'blue' }: ButtonProps) {
  console.log(`Button: ${label}, color: ${color}`);
}

Used in:

In real codebases, developers usually avoid manually mutating incoming parameter objects unless there is a strong reason.

Common pattern: destructure at the function boundary

type Options = {
  retry?: number;
  verbose?: boolean;
};

function runTask({ retry = 3, verbose = false }: Options = {}) {
  if (verbose) {
    console.log(`Retry count: ${retry}`);
  }
}

This is popular because:

• defaults are visible immediately
• local variables are easy to use
• the original object stays unchanged

Pattern: merge defaults with user options

Useful when many options exist.

type Config = {
  host?: string;
  port?: number;
  secure?: boolean;
};

function connect(config: Config) {
   finalConfig = {
    : ,
    : ,
    : ,
    ...config,
  };

  .(finalConfig);
}

1. Trying to put a default inside a type annotation

This is invalid:

function sayName(params: { firstName: string; lastName: string = 'smith' }) {
}

Why it fails:

• type annotations describe types only
• they cannot run code or assign values

2. Using || when ?? is safer

Broken logic:

function greet({ lastName }: { lastName?: string }) {
  const value = lastName || 'smith';
  console.log(value);
}

If lastName is '', the result becomes 'smith'.

Safer:

function greet({ lastName }: { lastName?:  }) {
   value = lastName ?? ;
  .(value);
}

|| vs ??

Defaulting object properties in TypeScript

Type with optional property

type Params = {
  firstName: string;
  lastName?: string;
};

Best pattern: destructuring default

function sayName({ firstName, lastName = 'smith' }: Params) {
  console.log(firstName, lastName);
}

Alternative: ?? inside function

function sayName(params: Params) {
  const lastName = params.lastName ?? 'smith';
  console.log(params.firstName, lastName);
}

Default the whole object too

function sayName() {
  .(firstName, lastName);
}

Can I set a default value directly in a TypeScript type?

No. Types only describe allowed shapes. They do not assign runtime values.

What is the best way to default an optional object property in TypeScript?

Usually, destructuring with a default is the cleanest option:

function f({ name = 'Anonymous' }: { name?: string }) {}

Should I use || or ?? for fallback values?

Use ?? when you only want the fallback for null or undefined. Use || only when all falsy values should trigger the fallback.

Why must lastName be optional if I give it a default?

Because callers may omit it. The type must reflect that by using lastName?: string.

Can I default the whole parameter object too?

Yes:

function f({ name = 'Anonymous' }: { name?:  } = {}) {}

• Optional properties in TypeScript — Needed when object fields may be omitted.
• Function parameters in TypeScript — Helps compare normal parameter defaults with object parameter defaults.
• Destructuring assignment — The main syntax used to apply defaults cleanly.
• Nullish coalescing (??) — Useful for safe fallback values without replacing valid falsy values.
• Logical OR (||) — Often used for fallback logic, but behaves differently from ??.
• Type aliases and interfaces — Helpful for making object parameter types clearer and reusable.
• Object spread syntax — Common for merging defaults with user-provided options.
• Partial types — Useful when building functions that accept partially filled configuration objects.