TypeScript Reference ยท Literal and Object Types
TypeScript method signatures
Learn TypeScript method signatures in interfaces and type literals, how they differ from function-typed properties, and why strictFunctionTypes treats them differently.
A method signature describes a function-valued member of an object type using the shorthand name(params): Return. It looks like a method declaration in a class, but without a body. The alternative is a property signature whose type happens to be a function type: name: (params) => Return.
At the call site the two look identical, and for most code the choice is stylistic. There is one real difference in the type system: parameters of method signatures are compared bivariantly, while parameters of function-typed properties are compared contravariantly under strictFunctionTypes. That makes method syntax more lenient when you assign one object to another.
interface Counter { increment(by: number): number; // method signature reset: () => void; // property signature with a function type }
Try it
Press Run (or Ctrl + Enter) to see the result here.
Program input ยท what you'd type while the program runs
Type the answers before you press Run, one per line. Each time the program reads a line (with node:readline or readFileSync(0)), it gets the next line from this box.
Press Run (or Ctrl + Enter) to see the result here.
Program input ยท what you'd type while the program runs
Type the answers before you press Run, one per line. Each time the program reads a line (with node:readline or readFileSync(0)), it gets the next line from this box.
Syntax
interface Example { name(param: Type): ReturnType; // method signature name?(param: Type): ReturnType; // optional method readonly name: (param: Type) => R; // property signature (can be readonly) name<T>(value: T): T; // generic method name(this: Example): void; // method with a this parameter }
| Part | Description |
|---|---|
name |
The member name. Can be an identifier, a string literal, a number or a computed name such as [Symbol.iterator]. |
param: Type |
Parameter list, same rules as any function type: optional (?), default-free, rest allowed. |
ReturnType |
Return type. If omitted in a declaration, it is implicitly any, which is an error under noImplicitAny. |
Edge cases: a method signature cannot be readonly; only property signatures can be marked that way. Repeating the same method name in one interface creates overloads, whereas repeating a property name is a duplicate identifier error.
Usage notes
- Variance: parameters of method signatures are bivariant even with
stricton. Function-typed properties and standalone function types are checked strictly (contravariant parameters). This is whyArray<T>and many DOM interfaces use method syntax: it keepsArray<Dog>assignable toArray<Animal>. - Overloads: only method signatures can be repeated to declare overloads. For a property you would need an intersection of function types or a type with several call signatures.
readonly: writereadonly handler: () => voidif the member must not be reassigned. Methods declared with shorthand can still be overwritten unless the whole object is readonly.this: methods in an object type conventionally refer to the receiver. See this parameters for declaring it explicitly.- Declaration only:
interfaceand type literals contain signatures without bodies. Class methods and object literal methods have bodies, and the compiler infers a compatible method signature from them. - Style rule of thumb: prefer the property form when you want strict checking of callbacks you store (for example event handlers); prefer method form for natural "behavior" members.
- Lint rule: the
@typescript-eslint/method-signature-stylerule can enforce either style across a project.