How to Type Function Parameters in TypeScript

What you’ll build or solve

You’ll define functions with clearly typed parameters, including primitives, objects, and unions.

When this approach works best

Typing function parameters works best when you:

• Build reusable utilities that other parts of your app depend on
• Validate API input before processing it
• Migrate JavaScript functions to TypeScript

It also helps when collaborating with others who rely on clear function contracts.

This is a bad idea only if you leave parameters untyped and rely on implicit any. That weakens type safety.

Prerequisites

• TypeScript installed
• A .ts file
• Basic knowledge of functions and types

Step-by-step instructions

Step 1: Add type annotations to parameters

Use the syntax parameterName: Type.

function greet(name: string) {
  return `Hello, ${name}`;
}

TypeScript now enforces correct usage:

greet("Alex"); // OK
greet(42); // Error

For multiple parameters, type each one:

function add(a: number, b: number) {
  return a + b;
}

Each parameter must include its own type annotation.

Step 2: Type object parameters

You can type object parameters inline or with an interface.

Option A: Inline object type

function createUser(user: { id: number; name: string }) {
  return user.name;
}

Option B: Using an interface

interface User {
  id: number;
  name: string;
}

function createUser(user: User) {
  return user.name;
}

Use interfaces when the object shape is reused or grows over time.

Step 3: Use union types for flexible input

If a parameter can accept more than one type, use a union.

function formatId(id: string | number) {
  return `ID: ${id}`;
}

TypeScript allows either type:

formatId(101);
formatId("A102");

Union types are helpful when inputs vary but remain predictable.

What to look for

• Always use parameterName: Type
• Each parameter must be typed individually
• Optional parameters use ?, for example title?: string, and must come after required ones
• Default values can be added, for example factor: number = 2, and the type is inferred from the default
• Rest parameters use typed arrays, for example ...numbers: number[]
• Enable noImplicitAny in tsconfig.json to prevent untyped parameters
• Use interfaces or type aliases for complex object parameters

Examples you can copy

Example 1: Login function

interface Credentials {
  username: string;
  password: string;
}

function login(credentials: Credentials) {
  return `Logging in ${credentials.username}`;
}

This prevents missing or incorrectly shaped input.

Example 2: Flexible search function

function search(query: string, limit: number) {
  return `Searching for ${query}, limit ${limit}`;
}

Both parameters are explicitly typed.

Example 3: Controlled log levels

function log(level: "info" | "warning" | "error", message: string) {
  return `[${level}] ${message}`;
}

The first parameter only accepts specific string values.

Common mistakes and how to fix them

Mistake 1: Forgetting to type parameters

You might write:

function add(a, b) {
  return a + b;
}

Why it breaks: In strict mode, parameters may become any, which removes type safety.

Correct approach:

function add(a: number, b: number) {
  return a + b;
}

Always add explicit types in TypeScript.

Mistake 2: Mixing optional and required parameters incorrectly

You might write:

function greet(title?: string, name: string) {
  return `${title}${name}`;
}

Why it breaks: Required parameters cannot follow optional ones.

Correct approach:

function greet(name: string, title?: string) {
  return `${title ?? ""}${name}`;
}

Place optional parameters after required ones.

Troubleshooting

• If you see “Parameter implicitly has an any type,” enable strict mode and add explicit annotations.
• If a function call fails type checking, verify that the argument types match the parameter types.
• If unions cause errors inside the function, narrow the type before using type-specific methods.
• If autocomplete does not suggest properties, confirm the parameter is properly typed.

Quick recap

• Add : Type after each parameter name
• Type object parameters inline or with interfaces
• Use unions for flexible input
• Keep optional parameters after required ones
• Enable strict settings to avoid implicit any