Can an optional parameter be null in TypeScript?

Question

According to this article , when strict null checking is enabled in TypeScript, you cannot assign null or undefined to a variable unless it is explicitly allowed with a union.

// required value
let req: string;
req = "Something";  // OK
req = null;      // Error
req = undefined; // Error

// nullable value
let nbl: string | null;
nbl = "Something";  // OK
nbl = null;      // OK
nbl = undefined; // Error

But is null allowed in an optional value in TypeScript?

// optional value
let opt?: string; // (actually invalid, as optional types cannot be used for variable declarations, but that's not the point, so imagine we are dealing with function parameters or something)
opt = "Something"; // OK
opt = null; // OK? Error?
opt = undefined; // OK

Or is

opt?: string;

equivalent to

opt: string | undefined;

thus not allowing null just like recommended by Microsoft's Coding guidelines ?

Answer 1

EDIT: Important Note As Quentin C pointed out in the below comment, the behavior listed here is only when strict null checking is enabled: "strictNullChecks": true in tsconfig.json .

---

The types null and undefined are handled as separate types. The optional type is special, also allowing arguments to be left out of function calls.

1. Without a union or optional, nothing except the type itself is allowed.

function foo(bar: string) {
    console.info(bar);
}

foo("Hello World!"); // OK
foo(null); // Error
foo(undefined); // Error
foo() // Error

2. To additionally allow null , a union with null can be made.

function foo(bar: string | null) {
    console.info(bar);
}

foo("Hello World!"); // OK
foo(null); // OK
foo(undefined); // Error
foo() // Error

3. Allowing undefined works similarly. Note that the argument cannot be left out or null .

function foo(bar: string | undefined) {
    console.info(bar);
}

foo("Hello World!"); // OK
foo(null); // Error
foo(undefined); // OK
foo() // Error

4. You can also allow both, but the argument MUST still be given.

function foo(bar: string | null | undefined) {
    console.info(bar);
}

foo("Hello World!"); // OK
foo(null); // OK
foo(undefined); // OK
foo() // Error

5. With optional you can leave the argument out, or pass undefined , BUT NOT null .

function foo(bar?: string) {
    console.info(bar);
}

foo("Hello World!"); // OK
foo(null); // Error
foo(undefined); // OK
foo() // OK

6. To allow all three special cases, optional and null can be combined.

function foo(bar?: string | null) {
    console.info(bar);
}

foo("Hello World!"); // OK
foo(null); // OK
foo(undefined); // OK
foo() // OK

---

Also, optional is only usable in parameter or other type declarations, such as interfaces, not on regular variables. As it would make no sense to leave out the value of a variable when assigning to it.

Thus,

let d?: string;

would make no sense and results in a compilation error.

Answer 2

let d?: string; declares the type as string | undefined string | undefined .

This is because undefined is the default value for JS variables.