Functions

In this lesson we’ll explore TypeScript functions by helping Elmo make his ducks quack. You’ll learn how to declare parameters (optional vs default), when to use nullish coalescing (??), and how to express the same behavior with arrow functions. Keywords: TypeScript functions, optional parameters, default parameters, nullish coalescing, arrow functions First, define a simple Duck type and a daffy instance:

type Duck = {
  name: string;
  age: number;
  type: string;
  color: string;
  favoriteFood?: string;
};

const daffy: Duck = { name: 'Daffy', age: 3, type: 'Mallard', color: 'Black' };

Basic function with an optional parameter

Here is a function that accepts a duck and an optional times argument. If times is not provided, the function defaults to 1 quack using nullish coalescing (??), which only treats null or undefined as “no value”.

function makeDuckQuack(duck: Duck, times?: number): void {
  // Use nullish coalescing to default only when `times` is null or undefined.
  const quackCount = times ?? 1;
  for (let i = 0; i < quackCount; i++) {
    console.log(`${duck.name} says: Quack!`);
  }
}

makeDuckQuack(daffy, 2);

Console output:

Daffy says: Quack!
Daffy says: Quack!

Prefer times ?? 1 over times || 1 when you want to treat only null or undefined as “no value” and still allow 0.

Avoid using times || 1 if 0 is a meaningful value for times — || treats 0 as falsy and will wrongly fall back to 1.

Using a default parameter

You can also declare a default value directly in the parameter list. TypeScript infers the parameter type from the default, so an explicit : number is not required.

function makeDuckQuack(duck: Duck, times = 1): void {
  for (let i = 0; i < times; i++) {
    console.log(`${duck.name} says: Quack!`);
  }
}

makeDuckQuack(daffy); // uses the default

Console output:

Daffy says: Quack!

Notes:

With a default parameter (times = 1), callers may omit times and it will default to 1.
If you explicitly want times to possibly be undefined inside the function, use an optional parameter (times?: number) instead of a default.

Arrow function equivalent

You can write the same function as an arrow function. For most use cases arrow functions behave the same as regular function expressions, but be aware of differences in this binding and hoisting.

const makeDuckQuack = (duck: Duck, times = 1): void => {
  for (let i = 0; i < times; i++) {
    console.log(`${duck.name} says: Quack!`);
  }
};

makeDuckQuack(daffy, 2);

Quick comparison

Feature	Syntax example	Behavior
Optional parameter	`times?: number`	Parameter may be `undefined`; you can handle fallback inside the function (e.g., `times ?? 1`).
Default parameter	`times = 1`	Parameter defaults to `1` if omitted by the caller—inside the function it’s never `undefined`.
Nullish coalescing	`times ?? 1`	Fallback only when `times` is `null` or `undefined` (keeps `0` intact).
Logical OR fallback	`times		1`	Fallback when `times` is any falsy value (`0`, `''`, `null`, `undefined`, `false`).

Summary

Optional parameters are declared with ? (e.g., times?: number) and may be undefined.
Default parameters are declared with = (e.g., times = 1) and supply an automatic fallback.
Prefer ?? over || for fallbacks when 0 is a meaningful value.
Arrow functions provide a concise alternative; they differ from regular functions in this behavior and hoisting.

Course Introduction

Introduction to TypeScript

Introduction to CDKTF

AWS With CDKTF

Conclusion

Basic function with an optional parameter

Using a default parameter

Arrow function equivalent

Quick comparison

Summary

Watch Video

​Basic function with an optional parameter

​Using a default parameter

​Arrow function equivalent

​Quick comparison

​Summary

Watch Video

Basic function with an optional parameter

Using a default parameter

Arrow function equivalent

Quick comparison

Summary