Typescript-konvention för typer i variabeldefinitioner

I Typescript kan du definiera en boolean-variabel på flera sätt, t.ex.:

let a = true;

let b: boolean = true;

Eftersom true redan är en boolean, är det fortfarande vanligt att definiera det som variabeltyp (som visas för b)?

Om så är fallet, gäller detsamma för alla primitiva typer?

Svar #1

TypeScript typifierar implicit variabler baserat på den initiala tilldelningen (Läs mer). Så de två variablerna här är båda typade som boolean:

let a = true;          // implicitly typed as boolean
let b: boolean = true; // explicitly typed as boolean

Båda kommer att ge fel när man tilldelar en annan typ:

a = "a string";        // error, type 'string' is not assignable to type 'boolean'
b = "a string";        // error, type 'string' is not assignable to type 'boolean'

Det finns ingen konvention för om du bör vara explicit eller implicit, men jag skulle starkt rekommendera att minska ordrikedomen i let a: boolean=true;. Det är kortare att skriva let a=true; istället. Tilldelningen visar tydligt typen redan, så det finns verkligen inget behov av att vara explicit och ange det två gånger.

Implicit Any

Du bör se upp för "implicit any-typer". Detta inträffar när det inte finns någon tilldelning i det första uttalandet och ingen typ anges:

let a; // implicitly typed as `any`

Denna variabel kan användas på vilket sätt som helst:

a = true;       // ok
a = "a string"; // ok

I det här fallet bör du vara tydlig med typen:

let a: boolean;
a = true;       // ok
a = "a string"; // error, type 'string' is not assignable to type 'boolean' -- good!

Du kan helt undvika att av misstag definiera implicita any-typer genom att slå på kompilatoralternativet --noImplicitAny, vilket kommer att ge ett kompileringsfel när du gör det. Jag rekommenderar att aktivera detta.

let a; // compile error with `--noImplicitAny`

Svar #2

Faktum är att med det första tillvägagångssättet definierar du ingen typ (för TypeScript) så du kan potentiellt lägga vad du vill i a-variabeln som värde. Glöm inte att JavaScript är dynamiskt. Dessutom kan du inte kontrollera vid kompilering att rätt typ anges när du använder variabeln.

Du skulle kunna ha det här:

let a = true;
a = 'test';

Med den andra metoden kan du kontrollera vid kompileringstid att typen av b är exakt vad som förväntas: när den används som parameter för en metod, när den tilldelas en annan egenskap för en variabel, ...

Det är bättre att utnyttja TypeScripts starka typning för statisk kontroll. Detta gör att du enkelt kan upptäcka potentiella problem under implementeringsfasen (och inte vid körning).

Till exempel:

let a:boolean = true;
a = 'test'; // compilation error