Explicar el concepto de nulo y sus usos en TypeScript

Null se refiere a un valor que está vacío o que no existe. Es a propósito que no hay valor aquí. TypeScript no hace que una variable sea nula de forma predeterminada. Por defecto, las variables no asignadas o las variables que se declaran sin inicializarse son ‘indefinidas’. Para hacer que una variable sea nula, debemos asignarle Nulo. Typescript usa nulo para representar variables que tienen una ausencia de valores o ningún valor asignado a ellos en resumen. A veces, al escribir códigos enormes, uno puede cometer tales errores y pueden conducir a errores no deseados.

Ejemplo 1: asignación de valores nulos

let str: string;
 
// Prints undefined
console.log(str);
 
// Assigning 'null' to variable
str = null;
console.log(str);

Producción:

undefined
null

Ejemplo 2: No podemos asignar valores de otros tipos a variables de tipo nulo (excepto nulo e indefinido). 

No podemos asignar valores de otros tipos a una variable que se declara como de tipo nulo. solo se pueden asignar valores nulos e indefinidos.

let num1: null;
num1 = null;
 
// Displays null
console.log(num1);
 
num1 = undefined;
 
// Displays undefined
console.log(num1);
 
num1 = 20;
// Raises error in timescript compiler
console.log(num1);

Salida: Salida en compilador TypeScript:

error TS2322: Type '20' is not assignable to type 'null'.
    num1 = 20;
    ~~~~

Salida después de ejecutar el archivo js:

null
undefined
20

El nulo no se puede asignar a variables de tipo indefinido:

let var1: undefined;
 
// Assigning null to undefined type variable
var1 = null;
console.log(var1);

Producción:

Type 'null' is not assignable to type 'undefined'.ts(2322)

Ejemplo 3: Comprobar si una variable es nula

Dado que el operador typeof devuelve un objeto, uno no puede usarlo para verificar si hay un valor nulo. Como resultado, puede utilizar los operadores == (operador igual) o === (operador igual) (operador igual estricto). 

En el siguiente código podemos ver que el operador typeof devuelve un objeto. cuando se marca con ‘==’ (operador igual), devuelve verdadero cuando variable == nulo pero también devuelve verdadero cuando nulo == indefinido. pero cuando usamos el operador de igualdad estricta, se devuelve ‘falso’ cuando se compara nulo con indefinido. 

let variable: null;
variable = null;
 
// Returns object
console.log(typeof variable);
 
// True
console.log(variable == null);
 
// True
console.log(variable == undefined);
 
// True
console.log(null == undefined);
 
// False
console.log(variable === undefined);
 
// False
console.log(null === undefined);

Producción:

object
true
true
true
false
false

Si queremos evitar valores nulos en nuestro código, podemos usar if loop para verificar.

if (variable !=null){}

Referencia: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-0.html#null–and-undefined-aware-types