Typescript tilldela null till interface

Det här kanske är en dum fråga, men jag kan inte lista ut hur man tilldelar värdet null till en variabel som deklarerats som en gränssnittyp.

Nedan är ett exempel på vad jag menar:

interface IMyInterface {
    field: any;
}

let test:IMyInterface = null; // <-- Compiler error: Type 'null' is not assignable to type 'IMyInterface'

Svar #1

Antingen definiera det som en unionstyp, eller ställ in flaggan strictNullChecks till false i din ts-konfiguration under compilerOptions.

av @Guy Incognito:

let test:IMyInterface | null = null;

Svar #2

Att aktivera kompilatorinställningen strictNullChecks (som också ingår i strict-inställningen) tar bort null och undefined från varje typ och kräver därmed att dessa uttryckligen deklareras. TypeScript-handbok om nullbara typer.

Utan strictNullChecks:

declare let implicitlyNullable: number;

implicitlyNullable = 42;        //OK
implicitlyNullable = null;      //OK
implicitlyNullable = undefined; //OK

Lekplatslänk

Med strictNullChecks:

declare let implicitlyNullable: number;

implicitlyNullable = 42;        //OK
implicitlyNullable = null;      //error
implicitlyNullable = undefined; //error

///////////////////////////////////////

declare let explicitlyNullable: number | null;

explicitlyNullable = 42;        //OK
explicitlyNullable = null;      //OK
explicitlyNullable = undefined; //error

///////////////////////////////////////

declare let explicitlyUndefinable: number | undefined;

explicitlyUndefinable = 42;        //OK
explicitlyUndefinable = null;      //error
explicitlyUndefinable = undefined; //OK

///////////////////////////////////////

//nilable = can be both undefined and null
declare let explicitlyNilable: number | undefined | null;

explicitlyNilable = 42;        //OK
explicitlyNilable = null;      //OK
explicitlyNilable = undefined; //OK

Lekplatslänk

I huvudsak är kompilatoralternativet mycket likt att automatiskt tillämpa NonNullable-verktygstypen på varje typ som finns. Så utan strictNullChecks accepterar du inte "tomma" värden som ett val du kan aktivera.

För min del föredrar jag mycket noggrannheten hos strictNullChecks. Det gör det mycket lättare att skriva och resonera om kod utan att behöva strö if(someVar) överallt eftersom du inte vet vad någon kan skicka in. Även en enkel funktion kan vara ett problem utan strikta nullkontroller:

function add(a: number, b: number): number {
    return a + b;
}

console.log(add(2, 3));         //strictNullChecks: false -> 5
                                //strictNullChecks: true  -> 5
console.log(add(2, null));      //strictNullChecks: false -> 2
                                //strictNullChecks: true  -> compiler error
console.log(add(2, undefined)); //strictNullChecks: false -> NaN
                                //strictNullChecks: true  -> compiler error

Playground-länk - strictNullChecks: false

Playground-länk - strictNullChecks: true

För bekvämlighetens skull kan du skapa några generiska typer som hanterar olika typer av nullbarhet:

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

declare let implicitlyNullable: number;
declare let explicitlyNullable: Nullable<number>;
declare let explicitlyUndefinable: Undefinable<number>;
declare let explicitlyNilable: Nilable<number>;

Lekplatslänk

Relaterade artiklar