Typescript 中的类型推断与显式类型声明

Question

I've come across several different instances of code where variables are declared with an explicit type even though the inferred type is obvious:

Example: loading: boolean = false or name: string = "John" or count: number = 0 etc.

TSLint favors the inferred type over the explicit type, so I'm wondering is this just a stylistic issue? Do these explicit types even matter during runtime?

Answer 1

Declared types do not matter at all at runtime. When the Javascript is generated all types will be removed since Javascript does not support specifying variable types.

As to why TSLint prefers type inference ove explicit typing I would say it is probably to keep things DRY (don't repeat yourself). Since the compiler can do the typing for you there is no reason to add more noise to the code.

Answer 2

In your example it is just about style, hence, it has not impact to your code from compilation perspective. Be aware this is for the cases where the variable value explicitly defines its type, which might make your code complicated to read in cases of resigning values from other variables.

In other words it might be better you do:

name: string = "John"
bday: Date = "1980/01/10" //the compiler says there is an error

And avoid:

name = "John"
bday = "1980/01/10" //no compiling error, but it should be new Date("1980/01/10")

Note: Undefined types will always be considered as any.

Answer 3

Most of today's javascript community people would support inference motivating their choice that type inference is somehow easier to read, but ease of reading is not something measurable, it's just a matter of personal taste. And think twice before working with people who would motivate their position based solely on their taste.

Be open try both approaches pick one that suits you best or go with team's decision.

I personally prefer explicit types, my measurable observations tell me that explicit types improve code metric related to code simplicity or verbosity, you don't have to put effort into figuring out what type are you working with, plus you are less probable to make a mistake.

Answer 4

From Should you annotate or let TypeScript infer the types?

The best general guideline for whether to annotate code or not is whether the expression/variable you're annotating is a "boundary" or not. Boundaries usually refer to the exported functions/classes/etc. of your various modules. For these, you likely want to be explicit as to what you're expecting to make your APIs more clear.

However, functions and variables internal to a specific module likely don't need to be annotated

From When to add types and when to infer in TypeScript

Add types to all function declarations.

not add explicit types to variables