Function Annotations

## What the question mark actually declares In a TypeScript parameter list, `?` after the parameter name declares that **callers may omit the argument**. It changes two things: the *minimum arity* the compiler will accept at call sites, and the *type* the parameter has inside the body. ```ts function log(msg: string, level?: string) { // level: string | undefined } log('started'); // ok — one argument log('started', 'info'); // ok — two arguments log('started', undefined); // ok — undefined is an acceptable value ``` With `strictNullChecks` enabled (which `strict` turns on), the declared type of `level` is `string | undefined`. That is the whole point: the compiler refuses to let you treat a possibly-missing argument as if it were always there. ```ts function log(msg: string, level?: string) { console.log(level.toUpperCase(), msg); // error: 'level' is possibly 'undefined' } ``` You fix it by narrowing or by supplying a fallback: ```ts function log(msg: string, level?: string) { const l = level ?? 'info'; // l: string if (level !== undefined) { level.toUpperCase(); // narrowed to string here } } ``` ## Ordering: optional parameters go last A required parameter cannot follow an optional one. The reason is positional: arguments are matched by position, so if an earlier slot could be skipped there would be no way to tell which value landed where. ```ts function bad(a?: string, b: number) {} // error: a required parameter cannot follow an optional parameter function good(a: string, b?: number) {} // fine ``` Several optional parameters may follow each other, and callers then omit them from the right: `function f(a: string, b?: number, c?: boolean)` accepts one, two, or three arguments, but there is no syntax for "skip `b`, pass `c`" other than passing `undefined` explicitly for `b`. ## `?` and a default are mutually exclusive ```ts function f(a?: number = 1) {} // error: parameter cannot have question mark and initializer function f2(a = 1) {} // fine — the initializer already makes it optional ``` An initializer makes the parameter omittable *and* removes `undefined` from its type inside the body, so writing `?` on top of it would be contradictory. ## The arity check is compile-time only This is the erasure rule that organises all of TypeScript: none of this survives to runtime. The emitted JavaScript is ```js function log(msg, level) { /* ... */ } ``` There is no check that a caller supplied the right number of arguments — plain JavaScript has always let you call any function with any number of arguments and binds the missing ones to `undefined`. The `?` is a *promise the compiler enforces on the callers it can see*. Code that reaches the function from untyped JavaScript, a `any`-typed value, or a JSON payload can pass anything at all, so an optional parameter is not a validation mechanism. ## In declaration output and in function types The same `?` syntax appears in function *type* positions and in emitted `.d.ts` files: ```ts type Logger = (msg: string, level?: string) => void; const l: Logger = (m) => console.log(m); // fine — see arity assignability ``` So when you read a signature with a `?`, you are reading the same contract whether it came from your source or from a library's declaration file. ## Optional parameter vs `| undefined` — a real distinction Declaring `level?: string` is *not* the same as declaring `level: string | undefined`. Both permit `undefined` as a value, but only the first lets the caller leave the argument out entirely; the second still requires an argument in the list. That difference is the usual follow-up to this question. ## Common mistakes - Assuming the parameter is still `string` inside the body. Without narrowing, the compiler flags every use. - Writing `?` on a middle parameter and then adding a required one after it. - Believing the arity rule is enforced at runtime, or that omitting an argument produces anything other than `undefined`. - Reaching for `?` when the API really wants an explicit choice from the caller — if forgetting the argument is a bug, make it required.