Flutter学习2-dart学习

简介

Dart 是一种专为客户端优化的语言,用于在任何平台上开发高性能应用程序。它的目标是为多平台开发提供最高效的编程语言,并为应用程序框架提供灵活的执行运行时平台。

优点如下

  • 为基于事件驱动的用户界面提供成熟且完备的 异步-等待 体系,同时配备了 基于 isolate 的并发
  • 为构建用户界面优化的语言,其中包含了 健全的空安全、用于展开集合的展开操作符 以及集合内的条件语句 用于为每个平台定制 UI
  • 语法相近、易于上手的编程语言,类似python的极简风格
  • 在正在运行的应用中使用 热重载,从而快速并持续地应用更改,并且立刻看到更改的效果
  • 在编写代码时享受灵活的类型系统,以及强大且 可配置的静态分析工具
  • 使用您选择的代码编辑器进行 性能分析、 日志记录以及 调试
  • 使用 AOT 编译为机器码, 极速启动 您的应用
  • 使用完整、成熟且快速的 JavaScript 编译器 为 Web 平台编译应用
  • 仅用一种语言即可编写应用的 后端代码

安装

flutter自带dart sdk不用安装

基本语法

运行入口main,每个文件都可以用main做入口,类似python
dart还是相当友好的,毕竟是2011年创建的,十分现代的语言,现代语言的特点,详见https://blog.csdn.net/hn_lgc/article/details/124024197
主要特点就是简单友好,融合多种编程范式,不会想传统语言那么死板

比如,创建变量是,可以使用new 也可以不使用
函数可以声明返回值,也可以不声明

if else
for
while
switch
case
assert
基本语法都与目前的经典语言兼容,简直不要太完美!

变量

变量仅存储对象的引用
支持类型推断,可以只写个var,指定为基类Object或者dynamic类型,不是无类型的比如python
也可以指定类型 String name = ‘Bob’;
建议,通过 var 声明局部变量而非使用指定的类型。

一样的一些皆对象,包括所谓的基本类型,int,所以int也可能为null,和Java不一样了。

综上,变量类型有
一般变量,可空变量,final变量,const变量

常量 概念

注意常量概念在dart中是比较重要的,基于不可变编程思想
final 和 const 的区别
const ==常量,必须声明时赋值,只能作用于静态对象,用于非静态理论上可以,但是没有必要。
final == 不可变变量,意思是只能赋值一次,不用声明时赋值

常量类和常量构造函数:

当我们需要创建不可变对象的时候,就可以使用常量类的常量构造函数

dart这个语法有点反人类,定义常量类不是给类添加修饰符,而是给它的构造函数添加修饰符。。。。
给构造函数添加修饰符之后,这个类就变成了常量类,其成员变量必须是final。

常量类实例化时最好加上const修饰符。

字符串

正则表达式

RegExp 类提供与 JavaScript 正则表达式相同的功能。使用正则表达式可以对字符串进行高效搜索和模式匹配。

// Here’s a regular expression for one or more digits.
var numbers = RegExp(r’\d+');
var allCharacters = ‘llamas live fifteen to twenty years’;
var someDigits = ‘llamas live 15 to 20 years’;

// contains() can use a regular expression.
assert(!allCharacters.contains(numbers));
assert(someDigits.contains(numbers));

// Replace every match with another string.
var exedOut = someDigits.replaceAll(numbers, ‘XX’);

内置类型

数字,默认只有int 和 double,int支持位运算 都是64位,如果需要更低位数的,比如32,8需要使用特殊的对象。
字符串, UTF-16 编码, 在字符串中,请以 ${表达式} 的形式使用表达式。和python比较像,可以使用单引号,可以使用三个引号多行,可以使用字符串前缀 r’xxxx\xxxx’

集合

列表:
可以使用扩展操作符(…)将一个 List 中的所有元素插入到另一个 List 中: [0, …list]; [0, …?list];空安全 这里就是一个解操作吧,*不就行了吗,这个语法不行
类似python
集合中的 if 和 集合中的 for 操作,在构建集合时,可以使用条件判断 (if) 和循环 (for)。
排序
list.sort((a, b) => a.compareTo(b));
set
var halogens = {‘fluorine’, ‘chlorine’, ‘bromine’, ‘iodine’, ‘astatine’};
var names = {};
列表里面的if不加花括号
children: [
picWidget, // 占满整个空间,不加定位
if (is_show_dir)
Positioned(
left: 48,
child: dirWidget,
)
]

map
set就是map的简化版
使用 add() 方法或 addAll() 方法向已存在的 Set 中添加项目:
Set 可以像 List 一样支持使用扩展操作符(… 和 …?)以及 Collection if 和 for 操作
注意!map类型固定,不同于python
如果你向Map 对象中添加不正确的类型值,将导致运行时异常。

Runes
这个类专门用来操作用户感知的字符,比如表情符号,相当于dart给客户端特有的支持

Symbol 字面量是编译时常量。

空安全相关 初始化

类似于Kotlin
空安全,为了防止空指针问题,dart引入空安全机制
启用空安全之后,所有变量必须有初始值,除非指定变量可为空。
int? lineCount;

初始值必须声明变量的时候赋值吗?不是必须的
空安全不必在声明它的地方初始化局部变量,但是您需要在使用它之前为它赋值,编译器会检查使用前是否赋值。

如果编译器无法检查的呢,那么dart又提供了延迟初始化机制 和 惰性初始化
延迟初始化
使用前手动初始化
late String description;
当然,这个是有风险的。
惰性初始化
使用前编译器才调用初始化语句,适用于初始化代价比较大的情形
late String temperature = readThermometer(); // Lazily initialized.

运算符

目前基本上的运算符号都是支持的,没有其它语言的死板

要判断两个对象 x 和 y 是否表示相同的事物使用 == 即可。(在极少数情况下,可能需要使用 identical() 函数来确定两个对象是否完全相同)。下面是 == 运算符的一些规则:
三元运算符特别的点:
如果赋值是根据判定是否为 null 则考虑使用 ??。
a ??= 1;
等价于 if (a ==0) a = 1;

级联运算符 …可以让你在同一个对象上连续调用多个对象的变量或方法。
严格来说 … 级联操作并非一个运算符而是 Dart 的特殊语法。
不用手动返回this了
var paint = Paint()
…color = Colors.black
…strokeCap = StrokeCap.round
…strokeWidth = 5.0;
与下面的代码等效:
var paint = Paint();
paint.color = Colors.black;
paint.strokeCap = StrokeCap.round;
paint.strokeWidth = 5.0;

null-short 判空的级联 ?…

级联运算符可以嵌套,例如:

Cascading operators can be nested, for example:

final addressBook = (AddressBookBuilder()
…name = ‘jenny’
…email = ‘[email protected]
…phone = (PhoneNumberBuilder()
…number = ‘415-555-0100’
…label = ‘home’)
.build())
.build();

?[] 判空访问 List

函数 Function

Dart 是一种真正面向对象的语言,函数也是对象,类似于python
函数可以声明返回值,也可以不声明

参数

函数可以有两种形式的参数:必选参数 和 可选参数 使用[]包裹的参数。必要参数定义在参数列表前面
顾名思义,可选参数就是调用函数时,可以传递值,也可以不传递,
**使用[ ]包裹的参数是一个位置可选参数。**下面是一个例子:

getHttpUrl(String server, String path, [int port=80]) {
// …
}
在上面的代码中,port是可选的,默认值为80。

您可以getHttpUrl使用或不使用第三个参数进行调用。

getHttpUrl(‘example.com’, ‘/index.html’, 8080); // port == 8080
getHttpUrl(‘example.com’, ‘/index.html’); // port == 80

命名可选参数 使用{ }包裹的参数 就是说调用时需要指定名字,如果是一般的可选参数,就不需要指定名字

下面是一个例子:

getHttpUrl(String server, String path, {int port = 80}) {
// …
}
您可以使用或不使用第三个参数调用getHttpUrl。但你使用第三个参数时,你必须使用参数名称调用函数。

getHttpUrl(‘example.com’, ‘/index.html’, port: 8080); // port == 8080
getHttpUrl(‘example.com’, ‘/index.html’); // port == 80

参数默认值,当然是支持的
注意调用方法是: 不是= ,和python不一样

匿名函数或者说闭包

([[类型] 参数[, …]]) {
函数体;
};

下面代码定义了只有一个参数 item 且没有参数类型的匿名方法。 List 中的每个元素都会调用这个函数,打印元素位置和值的字符串:
const list = [‘apples’, ‘bananas’, ‘oranges’];
list.forEach((item) {
print(‘${list.indexOf(item)}: $item’);
});

函数体内只包含一个表达式,你可以使用简写语法:
bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;
=> 有时也称之为 箭头 函数

自然的,可以对函数进行传递
用法
var loudify = (msg) => ‘!!! ${msg.toUpperCase()} !!!’;
assert(loudify(‘hello’) == ‘!!! HELLO !!!’);

词法闭包

这个概念稍微复杂一些,简单的说 就是有状态的函数
也可以简单的理解,类似Java的匿名内部类,函数是对象,我们在外部函数里面再定义内部类或者函数,并创建其对象,此时这个内部类或者函数的对象持有了它的外部函数,就保存了外部函数的状态,并可以访问了

Dart 具有链式作用域,也就是说,子作用域可以访问父(甚至是祖先)作用域中的变量,而反过来不行。

面向对象相关

dart的继承机制和Java基本一致,要稍微的不同

类定义-构造函数

所有实例变量均会隐式地声明一个 Getter 方法。非final 和 late final 声明但未声明初始化的实例变量还会隐式地声明一个 Setter 方法。
构造函数:
独有的形式,
类名.xxx(…){
}
比如
class Person {
String? firstName;

Person.fromJson(Map data) {
print(‘in Person’);
}
}
在构造函数后面可以增加表达式,通过:语法
比如
显示继承父类构造函数
class Employee extends Person {
// Person does not have a default constructor;
// you must call super.fromJson().
Employee.fromJson(super.data) : super.fromJson() {
print(‘in Employee’);
}
}

在构造函数体执行之前初始化实例变量。每个实例变量之间使用逗号分隔。
// Initializer list sets instance variables before
// the constructor body runs.
Point.fromJson(Map json)
: x = json[‘x’]!,
y = json[‘y’]! {
print(‘In Point.fromJson(): ($x, $y)’);
}

使用 assert 来验证输入数据
等等

构造函数可以没有函数体,直接在参数里面编写表达式,或者:后面编写表达式完成构造 这是很常用的一种方式 eg
class Point {
double x, y;

// The main constructor for this class.
Point(this.x, this.y);
注意这里参数类型和名字都省了,参数名字直接和属性名字一样就行

// Delegates to the main constructor.
Point.alongXAxis(double x) : this(x, 0);
}

工厂构造函数 使用 factory 关键字标识类的构造函数并非总是会返回新的实例对象

支持操作符重载

class Vector {
  final int x, y;

  Vector(this.x, this.y);

  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);

  // Operator == and hashCode not shown.
  // ···
}

抽象类 和接口

抽象方法不用写关键字,自动判断
// This class is declared abstract and thus
// can’t be instantiated.
abstract class AbstractContainer {
// Define constructors, fields, methods…

void updateChildren(); // Abstract method.
}

接口似乎就是一个类

mixin语法

简单的说,就是多重继承的作用,
具体的说,dart中类就是接口,使用implement关键字继承多个接口,但是implement的类的方法必须被实现,即使基类接口已经实现了,这时候我们就使用mixin语法,继承接口而不必实现其方法
关于重复,后一个混入的 mixins会覆盖前面一个 mixins的特性

属性 成员相关

get set

set xxx 相当于同时定义了xxx变量,不用再次定义了,极简风格

重写类成员

Overrides a class member
子类可以重写父类的实例方法(包括 操作符)、 Getter 以及 Setter 方法。你可以使用 @override 注解来表示你重写了一个成员

扩展方法-重点

扩展方法,直接在api提供的类上面增加方法,而不用自己写一个工具类
例子

extension StringExtension1 on String {
//字符转换成Color对象
toColor() {
var hexColor = this.replaceAll(“#”, “”);
if (hexColor.length == 6) {
hexColor = “FF” + hexColor;
}
if (hexColor.length == 8) {
return Color(int.parse(“0x$hexColor”));
}
}

//字符转int
parseInt() {
return int.parse(this);
}
}

extension DateTimeExtension on DateTime {
toFormatString() {
DateFormat dateFormat = new DateFormat(“yyyy-MM-dd HH:mm:ss”);
return dateFormat.format(this);
}
}

类型相关

判断类型
xx is A
xx is ! A
类型转换
xx as A
获取类型
Type type = xx.runtimeType 或者 type = CLASSXXX
然后用 == 判断

单例的实现,就是使用 常量构造函数。

可调用类

通过实现类的 call() 方法,允许使用类似函数调用的方式来使用该类的实例。
class WannabeFunction {
String call(String a, String b, String c) => ‘$a $b $c!’;
}

var wf = WannabeFunction();
var out = wf(‘Hi’, ‘there,’, ‘gang’);

void main() => print(out);

Typedefs 这个不常用 增加复杂度,收效也不大

类型别名是引用某一类型的简便方法,因为其使用关键字 typedef,因此通常被称作 typedef。下面是一个使用 IntList 来声明和使用类型别名的例子:
typedef ListMapper = Map;
Map m1 = {}; // Verbose.
ListMapper m2 = {}; // Same thing but shorter and clearer.

异常处理

throw FormatException(‘Expected at least 1 section’);
你也可以抛出任意的对象:throw ‘Out of llamas!’;
优秀的代码通常会抛出 Error 或 Exception 类型的异常。

捕获异常
语法也是
try {
} catch (e) {
}
由于类型不明确?需要用on 来指定异常类型,具体用法
try {
breedMoreLlamas();
} on OutOfLlamasException {
// A specific exception
buyMoreLlamas();
} on Exception catch (e) {
// Anything else that is an exception
print(‘Unknown exception: $e’);
} catch (e) {
// No specified type, handles all
print(‘Something really unknown: $e’);
}

你可以为 catch 方法指定两个参数,第一个参数为抛出的异常对象,第二个参数为栈信息 StackTrace 对象

try {
// ···
} on Exception catch (e) {
print(‘Exception details:\n $e’);
} catch (e, s) {
print(‘Exception details:\n $e’);
print(‘Stack trace:\n $s’);
}

泛型

因为动态语言的特性,实际上dart中泛型的作用主要是用来限制类型实现类型安全,而不是表达多种类型,是相反的功能
比如var names = []; 限定string的列表
泛型一样支持extend
class Foo {
// Implementation goes here…
String toString() => “Instance of ‘Foo<$T>’”;
}

依赖 库 包 导入 和可见性

添加依赖库

dart的包不像Java需要打包成jar,直接导入文件夹就行,所以更加简单,灵活,可以从多种位置添加依赖
如包仓库 git 本地等

包仓库

dependencies:
transmogrify: ^1.4.0
**如果希望使用自己的包存储库,**可以使用托管服务器指定其 URL。下面的 YAML 代码使用托管源创建对 transmogrify 包的依赖项:
dependencies:
transmogrify:
hosted: https://some-package-server.com
version: ^1.4.0
dart中,任意一个文件都会被认为是一个库,尽管其中可能并没有library标签
以下划线(_)开头的成员仅在代码库中可见。

Git 软件包

dependencies:
kittens:
git: https://github.com/munificent/kittens.git
git 还可以指定分支

本地包

dependencies:
kittens:
path: xxxx 根目录即可

依赖重写

如果出现依赖冲突,就是依赖树中两个节点依赖另一个节点,但是要求的版本不同
这时候使用依赖重写指定使用同一个版本
dependency_overrides:
json_serializable: ^6.2.0

import 的唯一参数是用于指定代码库的 URI
引入dart语言的内置库:
import ‘dart:math’;
引入pub包管理器提供库:
import ‘package:flutter/material.dart’;
在引用包管理器提供的库时,uri中以package开头

引入本地文件:
import ‘./tools/network.dart’;
引用本地文件时,uri字符串中直接填写文件的相对路径。

import 支持as 指定库前缀,然后通过前缀访问
import ‘package:lib1/lib1.dart’;
import ‘package:lib2/lib2.dart’ as lib2;

// Uses Element from lib1.
Element element1 = Element();

// Uses Element from lib2.
lib2.Element element2 = lib2.Element();

export关键字的使用

就是将多个库文件一起导入的,类似于python的init文件,

在这个入口文件中,使用export关键字将这些dart文件集中导出。然后其他地方使用的使用只需要import这个入口文件就可以了。

延迟加载库

为了减少应用的初始化时间。

处理 A/B 测试,比如测试各种算法的不同实现。

加载很少会使用到的功能,比如可选的屏幕和对话框。

使用 deferred as 关键字来标识需要延时加载的代码库:
import ‘package:greetings/hello.dart’ deferred as hello;
// 当实际需要使用到库中 API 时先调用 loadLibrary 函数加载库:
Future greet() async {
await hello.loadLibrary();
hello.printGreeting();
}

loadLibrary 函数可以调用多次也没关系,代码库只会被加载一次。

并发 异步 多线程

Dart 通过 async-await、isolate 以及一些异步类型概念(例如 Future 和 Stream)支持了并发代码编程。

首先,dart的基本线程模型

dart趋向于淡化线程的概念,用隔离区isolate和任务的概念来完成并发功能,让上层开发者不必关心线程的调度,把线程调度交给语言自身,(某种角度的理解,传统的多线程以线程为中心,让线程分配资源,dart反过来,以资源为中心,分配线程)
Flutter学习2-dart学习_第1张图片
系统线程和isolate之间的关系是有一点模糊的,高度取决于DartVM在一个应用中是如何被嵌入的,仅有以下两点可以确保:

同一时间一个系统线程只能进入到一个isolate中,如果要进入到另外一个,那么它必须先离开当前的isolate
同一时间有且仅有一个执行Dart代码的系统线程(Mutator线程)和一个isolate有关联。

简单的说,同一时间点,isolate和系统线程是一一对应的。
默认的Dart 应用只会使用一个 isolate(即 主 isolate),同时你也可以创建更多的 isolate,从而在多个处理器内核上达成并行执行代码的目的。 **isolate 仅针对 原生平台的使用 进行实现。**使用 Dart 构建的网页应用可以 使用 Web Workers 实现相似的功能。
isolate运行事件循环的独立线程,类似于Android的handler loop机制。

创建新的isolate

官网文档地址 https://dart.cn/guides/language/concurrency
isolate大致相当于线程,那么我们需要创建多个线程,同时运行到机器的多核CPU上,怎么操作?
自然的,就像创建新线程一样,创建一个新的isolate,不同的是isolate不共享内存,通过消息管道来传递数据,正如那句话,通过传递消息共享内存,而不是通过共享内存传递消息。
创建isolate并运行和通信的基本流程如下:
Flutter 开发提示: 如果你在非 Web 平台上使用 Flutter 进行开发,那么与其直接使用 Isolate API,可以考虑使用 Flutter 提供的 compute() 方法。 compute() 方法能以简单的方式将一个函数的调用封装至 isolate 工作对象内。
下面的示例将使用到这些与 isolate 相关的 API:
Isolate.spawn() 和 Isolate.exit()
ReceivePort 和 SendPort

Isolate 工作对象会执行一个函数,完成后结束对象,并将函数结果发送至主 isolate。(Flutter 提供的 compute() 方法 也是以类似的方式工作的。)

主 isolate 的代码如下:

void main() async {
// Read some data.
final jsonData = await _parseInBackground();
// Use that data
print(‘Number of JSON keys: ${jsonData.length}’);
}

Future> _parseInBackground() async {
final p = ReceivePort(); // 代码创建了一个 ReceivePort,让 isolate 工作对象可以传递信息至主 isolate。
await Isolate.spawn(_readAndParseJson, p.sendPort); // 创建,传入运行函数和通信接口
return await p.first as Map;
}
_parseInBackground() 方法包含了 生成 后台 isolate 工作对象的代码,并返回结果:
在生成 isolate 之前,

Isolate 初始化完成后,主 isolate 即开始等待它的结果。由于 ReceivePort 实现了 Stream,你可以很方便地使用 first 属性获得 isolate 工作对象返回的单个消息。

在 isolate 之间发送多次消息内容
如果你想在 isolate 之间建立更多的通信,那么你需要使用 SendPort 的 send() 方法。下图展示了一种常见的场景,主 isolate 会发送请求消息至 isolate 工作对象,然后它们之间会继续进行多次通信,进行请求和回复。

Future和Stream(异步数据流)

Dart 语言和库通过 Future 和 Stream 对象,来提供能在当前调用未来返回某些值的功能
在 Dart 中一个最终会返回 int 类型值的 ,应当声明为 Future;一个会持续返回一系列 int 类型值的应当声明为 Stream。
异步场景包括调用系统 API,例如非阻塞的 I/O 操作、HTTP 请求或与浏览器交互。还有一些场景是利用 Dart 的 isolate 进行计算,或等待一个计时器的触发。这些场景要么是在不同的线程运行,要么是被系统或 Dart 处理,而让 Dart 代码可以同时运行其它代码。

async-await 语法

async 用来声明来定义异步函数
await 用来异步获取它们的结果的方式
下面是一段同步代码调用文件 I/O 时阻塞的例子:

void main() {
// Read some data.
final fileData = _readFileSync();
final jsonData = jsonDecode(fileData);

// Use that data.
print(‘Number of JSON keys: ${jsonData.length}’);
}

String _readFileSync() {
final file = File(filename);
final contents = file.readAsStringSync();
return contents.trim();
}
下面是类似的代码,但是变成了 异步调用:

void main() async {
// Read some data.
final fileData = await _readFileAsync();
final jsonData = jsonDecode(fileData);

// Use that data.
print(‘Number of JSON keys: ${jsonData.length}’);
}

Future _readFileAsync() async {
final file = File(filename);
final contents = await file.readAsString();
return contents.trim();
}
main() 函数在调用 _readFileAsync() 前使用了 await 关键字,让原生代码(文件 I/O)执行的同时,其他的 Dart 代码(例如事件处理器)能继续执行。使用 await 后,_readFileAsync() 调用返回的 Future 类型也转换为了 String。从而在将结果 content 赋予变量时,隐式转换为 String 类型。

备注:await 关键字仅在函数体前定义了 async 的函数中有效。
asyn await 的执行流程应该是,await之后事件循环终止循环体后面代码的执行,相当于一个continue,然后后面等结果返回了,再从这里开始运行。

元数据 注解

元数据注解以 @ 开头,其后紧跟一个编译时常量(比如 deprecated)或者调用一个常量构造函数,就像调用函数一样,可以往里面传递参数。

library todo;

class Todo {
final String who;
final String what;

const Todo(this.who, this.what);
}

import ‘todo.dart’;

@Todo(‘seth’, ‘make this do something’)
void doSomething() {
print(‘do something’);
}

注释

注释里面可以加图,语法和Markdown一样!!! Java也支持,语法是html还是什么的
目前Android Studio 插件不支持类跳转
文档注释以 /// 或者 /** 开始

dart的运行架构和原理

Dart 的编译器技术有两种方式运行代码:
原生平台: 对于针对移动和桌面设备的应用程序,Dart 包括一个具有即时(JIT)编译的 Dart 虚拟机 和一个用于生成机器码的提前(AOT)编译器。AOT就是在开发者点击编译之前,提前将代码编译成机器码(是真的机器码?能直接在cpu运行的那个机器码?),加快编译速度和程序运行时对机器想性能效果。

Web 平台: 对于面向 Web 的应用程序,Dart 包括开发时编译器(dartdevc)和生产时编译器(dart2js)。两个编译器都将 Dart 翻译成 JavaScript。

在开发过程中,快速的开发周期对于迭代是至关重要的。Dart VM 提供了一个即时编译器(JIT) ,具有增量重新编译(启用热重载)、实时度量收集(支持 DevTools)和丰富的调试支持。
经过 AOT 编译的代码会在高效的 Dart 运行环境中运行,该运行环境拥有健全的 Dart 类型系统,并使用快速对象分配和 分代垃圾收集器 来管理内存。

Dart 的 Web 支持让你可以在 JavaScript 驱动的网页平台上运行 Dart 代码。使用 Web 环境下的 Dart 时,你可以将 Dart 编译为在浏览器中运行的 JavaScript 代码,例如: Chrome 中的 V8。

Dart Web 包含了可以实现快速开发周期的增量开发编译器,同时还有用于针对生产环境优化的编译器 dart2js。后者使用了类似移除不可访问代码的技术,将 Dart 代码编译为快速、紧凑、随时随地可部署的 JavaScript。

Dart 运行时环境

不论你在哪个平台上使用、选择如何构建你的代码,执行代码时都需要一个 Dart 运行时环境。这个运行时环境负责下面的关键任务:

内存管理: Dart 使用一个受管理的内存模型,未被使用的内存会由垃圾收集器 (GC) 回收。

执行 Dart 语言的类型体系: Dart 语言里大多数类型检查都是静态的(编译时),但仍有部分检查是动态的(运行时)。比如,Dart 运行时环境会在遇到 类型判断运算符 时执行动态检查。

管理 isolates: Dart 运行时环境会负责控制主 isolate(代码通常在这里运行)以及其他应用创建的 isolate。

在原生平台上,Dart 运行时环境被自动包含在独立的可执行文件中,是 dart run 命令提供的 Dart VM 的一部分

注意:运行时,虚拟机两个东西差不多,就是进行内存管理,代码执行管理,线程进程管理等管理工作的。

热重载概念

注意dart热重载时会重新构建代码,即使代码没有改动(2022.7 目前是这样)。

Flutter 框架

是一款流行的多平台 UI 工具包,由 Dart 语言强力驱动,提供一套工具和 UI 库,帮助开发者们在 iOS、Android、macOS、Windows、Linux 和 Web 平台构建优秀的 UI 体验。

你可能感兴趣的:(Flutter,flutter,学习,android)