TypeScript Academy · Lesson

Optional and Default Parameters

Handle missing arguments with ? and default values.

Lesson 2 of 413 steps

Optional and Default Parameters is a free TypeScript Academy lesson on CoddyKit. This is lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the TypeScript Academy learning path, and your progress syncs across the web and the CoddyKit app. The TypeScript Academy course includes 4 lessons in total.

Welcome

TypeScript lets you mark function parameters as optional with `?` or give them default values. This makes APIs flexible while staying type-safe.

Optional Parameters with ?

Add `?` after a parameter name to make it optional. The parameter type becomes T | undefined inside the function.

function greet(name: string, greeting?: string): string {
  return (greeting ?? 'Hello') + ', ' + name;
}

Default Parameter Values

Assign a default value with `=`. TypeScript infers the type from the default and the parameter becomes optional at the call site.

function greet(name: string, greeting: string = 'Hello'): string {
  return greeting + ', ' + name;
}
greet('Alice');         // 'Hello, Alice'
greet('Bob', 'Hi');    // 'Hi, Bob'

Optional vs Default

Optional `?` gives undefined when omitted. Default values replace undefined with a fallback. Both make the parameter not required at the call site.

function opt(x?: number) { return x; }     // x: number | undefined
function def(x: number = 0) { return x; }  // x: number

Placement Rules

Optional and default parameters must come after required parameters in the function signature.

// Correct order
function create(name: string, role: string = 'user', active?: boolean) {}

// Error: required after optional
// function bad(x?: string, y: string) {}

Calling with undefined Explicitly

You can pass `undefined` to a parameter with a default to trigger the default value.

function log(msg: string, level: string = 'info') { console.log(level, msg); }
log('test', undefined); // level is 'info'

Optional Parameters and Overloads

Sometimes it is clearer to use overloads rather than optional parameters, especially when the function behavior changes significantly based on presence.

Default Object Parameters

You can destructure an object parameter with defaults for each property.

function connect({ host = 'localhost', port = 5432 } = {}) {
  return `${host}:${port}`;
}

Default Array Parameters

Default array parameters work the same way. Provide a default empty array to avoid undefined checks.

function joinAll(parts: string[], sep: string = ', '): string {
  return parts.join(sep);
}

Optional Chaining at Call Sites

If a function reference itself is optional, use optional chaining `?.()` to call it only when it exists.

interface Config { onReady?: () => void; }
function init(config: Config) {
  config.onReady?.();
}

Type of Optional Parameters Inside the Function

Inside the function, an optional parameter `x?: T` has type `T | undefined`. You must narrow it before using it as T.

function process(id?: number) {
  if (id === undefined) return;
  console.log(id * 2); // id is number here
}

Quick Check

What is the type of a parameter declared as `count?: number` inside the function body?

Answer it in the interactive lesson

Recap

Use `?` for optional parameters and `= value` for defaults. Optional parameters are T | undefined inside the function. Defaults replace undefined automatically. Both must come after required parameters.

Free to start

Learn TypeScript with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 101
Lessons: 352

Start learning free View the full course

Frequently Asked Questions

Is the “Optional and Default Parameters” lesson free?

Yes — the full text of “Optional and Default Parameters” is free to read here on the web. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the TypeScript Academy course, upgrade to CoddyKit PRO. The TypeScript Academy course includes 4 lessons in total.

What will I learn in “Optional and Default Parameters”?

Handle missing arguments with ? and default values. You practise TypeScript Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start TypeScript Academy?

No prior experience is required. TypeScript Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 2 of 4.

How long does the “Optional and Default Parameters” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this TypeScript Academy lesson?

Yes. Every TypeScript Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to TypeScript Academy