Solution 1: julemand101
Dart is a statically typed language so Dart needs to be able to determine the type at some point. But it is also smart enough to automatically determine the type based on the context. E.g. the type of the returned value from a function.
It is really a question about style but personally I think the type should be specified for method signatures and class variables. For all variables inside a method, I will use var/final and use clear variable names.
Another reason I try use var/final as much as possible is this can prevent some nasty issues with e.g. generics (
List list = <String>['test'] makes
list variable the type
dynamic in Dart is really just saying to the compile "just let this pass and check if the program makes sense at runtime". So we really don't want to have much
dynamic in our code base since we are then using the compilers ability to statically check your program makes sense.
Solution 2: Alex Pinilla
var Multiple asignment and Dynamic type. It can be assigned from expressions of different types. Be careful, Dart will infer the correct type, as long as variables are declared and initialized at the same time if you are using var.
final Single assignment. It is often used for when declaring properties inside widget classes.
const Compile time constant.
- Is used to define hard-coded values, such as colors, font sizes and icons.
- Used as a constructor when you're defining widget classes Const as a constructor, the widget is optimised by Flutter, and it isn't rebuilt when the parent changes.
Prefer const over final when possible.
Solution 3: jamesdlin
You never need to use
var; you always can choose to specify an explicit type instead.
var is used if you want to declare a variable and want the type to be inferred from the initializer. (If there is no initializer, the variable will be of type
dynamic. However, since
dynamic disables static type checking for that variable and incurs an extra runtime cost, you should avoid
dynamic when possible and should explicitly variables as
dynamic when it's necessary.
If the variable type is inferrable, whether you use implicit or explicit types is a matter of style.
Advantages of using explicit types:
- Can be more readable without tooling (i.e., without IDE support that can show you variable types).
- Can catch type errors where the inferred type isn't the expected type.
Advantages of using implicit types:
- Less verbose, which arguably makes the rest of the code more readable.
- Can avoid type errors where the explicit type is accidentally less precise than the inferred type. For example:
List someList = [1, 2, 3];actually declares
someListto be of type
List<dynamic>even though the right-hand-side is inferred to be