Monday, October 17, 2016

TypeScript 2.0–Fixing the million dollar mistake

With the introduction of TypeScript 2.0 one of the biggest root causes of bugs in software development finally got a solution. TypeScript 2.0 adds the ability to treat every type as non-nullable.

Let’s see how this works!

Installing TypeScript 2.0

Before we can check out the new language feature, we first have to install TypeScript 2.0. At the moment of writing it didn’t appear yet as part of my Tools and Extensions Updates inside Visual Studio, so let’s go to the TypeScript website and download the code from there.

Take the editor of your choice and install the required package.


Enable Strict null checking in Visual Studio

After installing TypeScript 2.0, strict null checking is not enabled out of the box. An extra compiler flag (—strictNullChecks) is required to switch to strict null check mode. To enable it in Visual Studio, you should unload your csproj file, edit it and add the following line to a propertygroup:


Strict null checking; what does it mean?

From the release notes:

TypeScript has two special types, Null and Undefined, that have the values null and undefined respectively. Previously it was not possible to explicitly name these types, but null and undefined may now be used as type names regardless of type checking mode.

The type checker previously considered null and undefined assignable to anything. Effectively, null andundefined were valid values of every type and it wasn’t possible to specifically exclude them (and therefore not possible to detect erroneous use of them).

In strict null checking mode, the null and undefined values are not in the domain of every type and are only assignable to themselves and any (the one exception being that undefined is also assignable to void).

Ahum? Yes, OK. Let’s try to rephrase this, before null and undefined were always valid values applicable everywhere. Problem was that the compiler couldn’t make any intelligent suggestions the moment null or undefined came into the picture. By switching to strict null checking mode, null and undefined can only be assigned to types that are explicitly flagged as nullable.

An example:

Without strict null checking the following code will compile:

With strict null checking we get a compiler error instead:


More information:

No comments: