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

To answer my own question after trying...

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.