Suggestion: treat null and undefined as the same in strictNullChecks mode

[k8w]

TypeScript Version: 2.1.1 / nightly (2.2.0-dev.201xxxxx)
2.1.4

Suggestion

Sometimes we want to enable strictNullChecks, because null will always with exception, which would interupt our program.

But always people just want to make sure if a variable have been assigned.

For example:

let a:{
  b:{
    c: string;
  }
};
console.log(a.b.c);  //Exception, can be found with strictNullChecks

In another hands, we may really don't care whether a variable without value is null or undefined.
While strictNullChecks treat null and undefined differently.

It bring some inconvenience, like:

interface A{
    b?: {
        c: {
            d: string;
        }
    }
}

let a:A = {}
a.b = null; //error TS2322: Type 'null' is not assignable to type '{ c: { d: string; }; } | undefined'.

or

interface A{
    b: {
        c: {
            d: string
        }
    } | null
}

let a:A = {} //error TS2322: Type '{}' is not assignable to type 'A'. Property 'b' is missing in type '{}'

So if we want to use strictNullChecks to check value have been assigned a value, we may have to:

• Type a long type def: XXX | null | undefined
• Remember it is | null or | undefined

Maybe at most time we want to treat null and undefined as the same.
So maybe better if there would be an option to achieve that.

[DanielRosenwasser]

I don't think we're willing to make undefined and null each an alias for null | undefined. Having worked with languages that make them out to be the same, it is a little frustrating and can force people into specific coding styles which they may not be fans of.

There's always the option of defining a custom type alias:

type Nullable<T> = T | null | undefined;

[k8w]

Agree, we should not make undefined and null each an alias for null | undefined.

But what if make T? as an alias for null | undefined?

People always make optional field by T?, most time null is a proper value to them.

May null | undefined is more suitable for optional field?

It also seems Nullable<T> is equals to T? in C#.

[RyanCavanaugh]

@twoeo see #7426