Summary of language features of fluent dart

Preface

Recently, with flutter Made a project and successfully put it on the shelves , Always feel right flutter The compilation principle of 、 The basic knowledge of grammar is not enough , The next step is to flutter Sum it up , Share some of your own project experience .

One 、Dart Introduction to language

1、 Study dart Official documents
2、 Is a strong type of language
3、 It's a single thread language
4、 Type annotations are optional ,Dart You can infer the type
5、 Supports generic types
6、 All programs must have a top level main() function , This function serves as the entry point for the application
7、 Interfaces can have functions , Classes and interfaces are unified , It's all interfaces

Two 、Dart Language variables and constants

1、 Variable

 //  Official recommended use var
var aa = 'hello word' ;
dynamic aa = 'hello word' ;
String aa = 'hello word' ;

Be careful ：
1、 The initial value of an uninitialized variable is null
2、 No keywords public,protected and private
3、 Private methods use （_） start , Other identity disclosure methods .

2、 Constant

final aa = 'Bob' ;//

const aa = 'Bob' ;//

const At the class level , To add static const

const Constructing two identical compile time constants will produce the same instance 

var a = const ImmutablePoint(1, 1);
var b = const ImmutablePoint(1, 1);

assert(identical(a, b)); // They are the same instance!

Be careful ：
1、 Use static Keywords implement class wide variables and methods （ For commonly used or widely used utilities and functions , Consider using top-level functions instead of static methods ）.
2、final The variable is required to be initialized only once , It is not required that the assigned value must be a compile time constant , It can be constant or not . and const Requires initialization at declaration time , And the assignment must be a compile time constant ,（ Compile time constants : Literal （ Like numbers 、bool、 character string 、List The literal form of ）、 Other constants perhaps Constant arithmetic operation , It can also be a combination of these （ Recursive requirements ）, Simply put, constants are values that can be determined at compile time .）
3、final It's lazy initialization , That is, it is initialized before the first use at runtime . and const The value is determined at compile time .
4、const You can modify variables , You can also decorate values （value）. and final Only used to decorate variables .

3、late keyword

late The role of ：
1、 Migrate your project to zero security .

 When declaring an initialized non nullable variable, you can use late  Modifier .
late String title;
void getTitle(){
title = 'Default';
print('Title is $title');
}
 Be careful ： Make sure that the variable must be initialized later before using it . Otherwise, you may encounter runtime errors when using variables .

2、 Delay initializing a variable .

 This variable may not require , And the cost of initializing it is very high .
 You are initializing an instance variable , Its initializer needs to access it .
// This is the program's only call to _getResult().
late String result = _getResult(); // Lazily initialized.
 In the example above , If you've never used variables , Will never call more expensive  _getResult()  function .

 hypothesis _getResult() Is a very important function to calculate the result .  however , If we assign it to any variable without delaying , that _getResult() Even if we don't use it , Every time I do .

 No,  late keyword 
String result = _getResult();
 In the code above ,result Never used , but _getResult() Will still be executed .

 Use  late keyword 
late String result = _getResult();
 In the code above _getResult() Not implemented , Because of the variable result Never used, found it , It's using late The modifier declares .

3、 You can delete many initState/constructor call ！

 before , If we want to create AnimationController, Must be in initState Constructor , because this,  The required vsync Can only be accessed from methods .

AnimationController anim1;
 
@override
void initState() {
  super.initState();
  anim1 = AnimationController(vsync: this, duration: Duration(seconds: 1))..forward();
}
 Now? , We can write this way ：

late AnimationController anim = AnimationController(vsync: ``this``, duration: Duration(seconds: 1))..forward();
 This saves you  6  Line code 

 You can use it to get the initial value from the calculation method , Or set any default value depending on the dynamic value .

 You can also create builder methods , And call them ：

late AnimationController anim1 = createAnim(seconds: 1, play: true);
late AnimationController anim2 = createAnim(seconds: 2);
late AnimationController anim3 = createAnim(seconds: 3);
 
AnimationController createAnim({required int seconds, bool play = false}) {
  final c = AnimationController(vsync: this, duration: Duration(seconds: seconds));
  if(play) c.forward();
  c.addListener(() => setState((){}));
  return c;
}
 Unwanted initState, either @override Make every line meaningful .

Other summaries will be updated continuously ！

END.