Functions

Every parameter in a TypeScript function should carry an explicit type — the compiler will not infer one for you from thin air, so an unannotated parameter is flagged as an implicit any under standard settings. The same rule applies to arrow functions assigned to a const, whether they are declared with a block body or as a single expression.

A parameter marked with ? is optional — callers may omit it, and inside the function its type is unioned with undefined. A default parameter (greeting: string = "Hello") is also optional to callers, but instead of becoming undefined when omitted, it falls back to the given value. A rest parameter (...args: number[]) gathers any number of trailing arguments into a single typed array, and must be the last parameter in the list.

An overload lets one function name accept genuinely different call shapes, each with its own precise parameter and return types, backed by a single implementation. You write one or more overload signatures — declarations with no body — followed by an implementation signature whose body actually runs. The implementation signature is usually looser (often using any) because it has to satisfy every overload above it; crucially, callers never see the implementation signature — only the overload list is used to check a call.

function combine(a: string, b: string): string
function combine(a: number, b: number): number
function combine(a: any, b: any): any {
  return a + b
}

const text = combine("Type", "Script")   // typed as string
const total = combine(2, 3)              // typed as number

The two lines with no body are overload signatures — pure type declarations, erased at compile time. Only the third, with a body, is the real implementation, and it is the only one that produces any JavaScript.

JavaScript's this is famously dynamic — it depends on how a function is called, not where it is defined, which is a common source of runtime bugs when a method is passed around and loses its intended receiver. TypeScript lets you pin down what this should be with a special fake first parameter named this: function onClick(this: Button) { ... }. It is checked at compile time and, like every other type annotation, completely erased — it never shows up as a real parameter in the compiled JavaScript.

interface Button {
  label: string
}

function sayLabel(this: Button) {
  console.log(this.label)
}

const button: Button = { label: "Save" }
const detached = sayLabel
detached()

app.ts:9:7 - error TS2684: The 'this' context of type 'void' is not assignable to method's 'this' of type 'Button'.
  Property 'label' is missing in type 'void' but required in type 'Button'.

9 const detached = sayLabel
        ~~~~~~~~

sayLabel.call(button)

this parameter

A fake first parameter named this in a function declaration that types what this must be inside the function body. Erased at compile time — never a real runtime argument.

void and never both describe functions with no useful return value, but they mean very different things. A function typed void does return — normally, to its caller — it just returns nothing meaningful (undefined, effectively). A function typed never never returns at all: it always throws an exception, or never terminates. The distinction matters for control flow analysis — code placed right after a call to a never-returning function is unreachable, which TypeScript can use to your advantage in exhaustiveness checks.

A function type describes the shape of a function — its parameter types and return type — independent of any particular implementation, written as (a: number, b: number) => number. Naming one with a type alias, like type Adder = (a: number, b: number) => number, lets you store functions in variables, pass them as arguments, and put them in arrays, all with the compiler checking every one against the same contract.

Function type

A type describing a function's parameters and return type, e.g. (a: number, b: number) => number, independent of any implementation.

First-class function

A function that can be stored in a variable, passed as an argument, and returned from another function — true of every JavaScript (and therefore TypeScript) function.

• Callback parameters: function onDone(cb: () => void)
• A strategy/lookup table: const handlers: Record<string, (e: Event) => void>
• Higher-order functions: a function that takes or returns another function, typed end to end