最近打算要入坑 Flutter,所以在此进行记录,随用随查;
不要怂,就是干,
一个简单的 Dart 程序
//🐷函数,应用从这里开始执行
main(){
var number = "Hello World";
printInteger(number);
}
//定义一个函数
printInteger(int aNumber){
print('The number is $aNumber');
}
重要的概念
在学习 Dart 语言时,应该基于以下事实和概念
- 任何保存在变量中的都是一个对象;所有的对象都对应一个类的实例,函数 和 null 都是对象,所有对象基于 Object 类
- 虽然 Dart 是强类型的,但是 Dart 可以进行类型推断,如上面代码变量 number 被推断为 int 类型;如果要明确说明不需要任何类型, 需要使用特殊类型
dynamic
- Dart 支持泛型,如 List , List(任何类型的对象列表)
- Dart 支持顶级函数 main() ,同样函数绑定在类或对象上(分别是 静态函数 和 实例函数 )。 以及支持函数内创建函数 ( 嵌套 或 局部函数 ) 。
- Dart 支持顶级变量
- dart 没有关键字 public ,protected 和 private,如果以 _ 开头,则相对于库是私有的
- 三目运算符:条件 condition ? Expr1 : expr2
- 类型问题:警告和错误,警告表示代码可能无法正常工作,但不会阻挡程序的执行,错误可能是编译或者运行时的错误,编译时错误会阻止代码的执行,运行时错误会导致代码在执行中引发异常(#exception)
关键字
应该避免这些单词作为标识符
- 带有 1 的单词为 上下文关键字,仅在特定位置具有含义,他们在任何地方都是有效标识符
- 带有 2 的为 内置标识符,这些关键字大多数地方都是有效的标识符,不能用于类型名称 和 import 前缀
- 带有 3 的是 Dart 1.0 发布后添加的异步支持相关的更新,作为限制类保留字。
变量
var name = "345"; //创建一个变量并初始化
dynamic name = "345"; // name 被推断为 String类型
String name = "345";//显式声明
dynamic:该类型具有所有可能的属性和方法,一个变量被 dynamic 修饰,相当于告诉系统,我知道这个类型到底是什么。使用后再编译时不会推断数据的类型,但是运行时会推断。
默认值
未初始化的变量默认值是 null,即使是数字类型也是 null。Dart 中一切皆是对象
Final 和 Const
使用过程中从来都不会被修改的变量,可用 final 或者 const。final 变量的值只能被设置一次,const 变量在编译时就已经固定。
内建类型
-
Number:有两种类型1,int,整数值不大于 64位;double 双精度浮点数
-
String::Dart 字符串是一组 UTF-16 单元序列,字符串通过单引号 或者 双引号创建
可使用 + 将字符串连接为一个;使用三个或三个双引号可实现多行字符串对象的创建
使用 r"" 前缀,可以创建“原始 raw 字符串”
-
Boolean: true and false
-
List:(也被称为 Array)
var list = [1, 2, 3]; var list = [1, 2, 3]; assert(list.length == 3); assert(list[1] == 2);
list[1] = 1; assert(list[1] == 1);
在 list 之前添加 const 关键字,可定义 List 类型的编译时常量
var constantList = const [1, 2, 3];
-
Map:用来关联 key 和 value,同一个 map 中 key 只能出现一次
var gifts = { // Key: Value 'first': 'partridge', 'second': 'turtledoves', 'fifth': 'golden rings' };
-
Set:set 是一个元素唯一的集合
var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'}; var names = <String>{}; // Set<String> names = {}; // 这样也是可以的。 // var names = {}; // 这样会创建一个 Map ,而不是 Set 。 var elements = <String>{}; elements.add('fluorine'); elements.addAll(halogens); var gifts = Map(); gifts['first'] = 'partridge'; gifts['second'] = 'turtledoves'; gifts['fifth'] = 'golden rings'; var nobleGases = Map(); nobleGases[2] = 'helium'; nobleGases[10] = 'neon'; nobleGases[18] = 'argon';
-
Rune: (用于在字符串中表示 Unicode 字符)
在 Dart 中, Rune 用来表示字符串中的 UTF-32 编码字符
表示 Unicode 编码的常用方法是,
\uXXXX
, 这里 XXXX 是一个4位的16进制数。 例如,心形符号 (♥) 是\u2665
。 对于特殊的非 4 个数值的情况, 把编码值放到大括号中即可。 例如,emoji 的笑脸 (�) 是\u{1f600}
。 -
Symbol
Symbol 对象表示 Dart 程序中声明的运算符或者标识符,你一般不会使用到他
Null-aware
Dart的Null-aware来自于Dart 1.12
正式版本 , 存在即是合理,既然有这样运算符,说明他在一定程度上节省了我们的代码
整个运算符是专门用来处理 null 值得,他会提供空指针的相关操作
// b 不为 null,则吧 b 赋值给 a,否则 将 c 赋值给 a
a = b ?? c;
//若 a 为 null,则将 b 赋值给 a
a ?? = b;
//当 x 不为 nul 时,调用 fun 函数
a?.fun();
函数
Dart 是一门真正的面对对象语言,甚至其中的函数也是对象,并且有他的类型 Function。意味着函数可以被赋值给变量,或者作为参数传递给其他函数,也可以把 Dart 类的实例当做方法来调用
//省略类型声明,函数可以正常使用
isNoble(atomicNumber) {
return _nobleGases[atomicNumber] != null;
}
//如果只有一句话,可简洁写法
bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;
=> *expr*
语法是 { return *expr*; }
的简写。 =>
符号 有时也被称为 箭头 语法 ,箭头后面只能是一个表达式;
-
调用时可选参数
定义函数时,使用{param1,param2,...},放在参数列表的最后面,用于指定可选参数,例如
const Scrollbar({Key key, @required Widget child,bool bold})
使用 @required 表示参数是 required 性质的命名参数。
-
位置可选参数
String say(String from, String msg, [String device]) { var result = '$from says $msg'; if (device != null) { result = '$result with a $device'; } return result; }
将参数放在 [] 中,来标记参数是可选的。表示该参数可以不传
-
默认参数值
// bold 值为 true; hidden 值为 false. void abc(bool bold = false);
void doStuff( {List<int> list = const [1, 2, 3], Map<String, String> gifts = const { 'first': 'paper', 'second': 'cotton', 'third': 'leather' }}) { }
接受一个 list 和 map,并指定参数的默认值
-
main() 函数
void main(){ } // 这样运行应用: dart args.dart 1 test void main(List<String> arguments) { print(arguments); }
main 函数返回值为 空,参数为一个可选的 List
-
匿名函数
多数函数是有名字的,比如 main() 等,dart 可以创建没有名字的函数,这种函数被称为匿名函数,**有时候也被称为 lambda 或者 closure。**匿名函数可以赋值到一个变量中,例如:在一个集合中可以添加或者删除一个匿名函数
main(){ var list = []; list.add(1); list.add(2); list.add(3); list.add(4); list.forEach((num){ print('位置:${list.indexOf(num)} ;值:$num'); }); }
上面定义了一个 无类型参数num 的匿名函数,list 遍历时,每次都会调用这个函数,并将值传递给到匿名函数中。
如果只有一句话,可使用如下写法:
list.forEach((num)=>print('位置:${list.indexOf(num)} ;值:$num'));
-
函数的赋值与传递
main(){ //将匿名函数赋值给变量 var one = (num)=>print(' 值:$num'); one(10); //将普通函数赋值给变量 var two = abc; two(20); //将匿名函数传递给普通函数 abc2((str) => print("abc $str")); } void abc2(fun(String str)){ fun("输出-------》"); } void abc(num){ print("哈哈哈:$num"); }
-
词法作用域
dart 是一门词法作用域的编程语言。
简单的说变量的作用域在编写代码的时候就已经确定了,花括号内就是变量的可见作用域
bool topLevel = true; void main() { var insideMain = true; void myFunction() { var insideFunction = true; void nestedFunction() { var insideNestedFunction = true; assert(topLevel); assert(insideMain); assert(insideFunction); assert(insideNestedFunction); } } }
内部可以访问所有的变量,一直到顶级作用域内的变量。
-
词法闭包
闭包即一个函数对象。即使函数的调用在他原始的作用域之外,依然能访问他在词法作用域内的变量
/// 返回一个函数,返回的函数参数与 [addBy] 相加。 Function makeAdder(num addBy) { return (num i) => addBy + i; } void main() { // 创建一个加 2 的函数。 var add2 = makeAdder(2); // 创建一个加 4 的函数。 var add4 = makeAdder(4); assert(add2(3) == 5); assert(add4(3) == 7); }
-
测试函数是否相等
void foo() {} // 顶级函数 class A { static void bar() {} // 静态方法 void baz() {} // 示例方法 } void main() { var x; // 比较顶级函数。 x = foo; assert(foo == x); // 比较静态方法。 x = A.bar; assert(A.bar == x); // 比较实例方法。 var v = A(); // A的1号实例 var w = A(); // A的2号实例 var y = w; x = w.baz; // 两个闭包引用的同一实例(2号), // 所以它们相等。 assert(y.baz == x); // 两个闭包引用的非同一个实例, // 所以它们不相等。 assert(v.baz != w.baz); }
-
返回值
所有函数都会有返回值,如果没有明确返回值,函数体会被隐式的添加 return null;语句
扩展函数,属性
String扩展:
extension StringExt on String {
double toDouble() {
return double.parse(this);
}
int toInt() {
return int.parse(this);
}
}
Object扩展:
extension ObjectExt on Object {
bool isNullOrEmpty() {
if (this is String)
return (this as String).isEmpty;
else if (this is Iterable) return (this as Iterable).isEmpty;
return this == null;
}
}
泛型扩展:
extension AllExt<T> on T {
T apply(f(T e)) {
f(this);
return this;
}
R let<R>(R f(T e)) {
return f(this);
}
}
//扩展属性
extension SizeExtension on num {
double get w => 10.0;
double get h => 10.0;
}
运算符
-
Dart 定义的运算符如下:
Description Operator 一元后缀 *expr*++
*expr*--
()
[]
.
?.
一元前缀 -*expr*
!*expr*
~*expr*
++*expr*
--*expr*
multiplicative *
/
%
~/
additive +
-
shift <<
>>
>>>
bitwise AND &
bitwise XOR ^
bitwise OR ` ` relational and type test >=
>
<=
<
as
is
is!
equality ==
!=
logical AND &&
logical OR ` ` if null ??
conditional *expr1* ? *expr2* : *expr3*
cascade ..
assignment =
*=
/=
+=
-=
&=
^=
etc.上表中,多数运算符可被重载
-
条件表达式
*condition* ? *expr1* : *expr2*
如果条件为 true, 执行 expr1 (并返回它的值): 否则, 执行并返回 expr2 的值。
*expr1* ?? *expr2*
如果 expr1 是 non-null, 返回 expr1 的值; 否则, 执行并返回 expr2 的值。
-
级联运算符
级联运算符可以对一个对象进行一些了操作,除了调用函数,还可以访问同一对象上的字段属性,
void main() { new A() ..a1() ..a2(); } class A{ void a1(){ print('a1'); } void a2(){ print('a2'); } } //a1 a2
级联运算符可进行嵌套
final addressBook = (AddressBookBuilder() ..name = 'jenny' ..email = 'jenny@example.com' ..phone = (PhoneNumberBuilder() ..number = '415-555-0100' ..label = 'home') .build()) .build();
控制流程语句
-
if
andelse
-
for
loopsfor (var i = 0; i < 5; i++) { message.write('!'); }
也可使用 forEach,或者 for-in
candidates.forEach((candidate) => candidate.interview());
var collection = [0, 1, 2]; for (var x in collection) { print(x); // 0 1 2 }
-
while
anddo
-while
loops -
break
andcontinue
-
switch
andcase
和 java 基本类似,可以比较整数,字符串,或者编译时常量,比较的对象都是同一个实例(并且不能是子类),枚举也可以使用 switch 语句
-
assert
如果 assert 中的布尔条件为 false,那么正常的程序执行流程会被中断
assert 语句只在开发环境中有效,在生产环境是无效的
异常
Dart 可以抛出和捕获异常,如果没有被捕获,则会抛出,最终导致程序终止运行
和 Java 不同,Dart 中的所有异常时非检查异常,方法不会声明它们抛出的异常,也不要求捕获任何异常
Dart 提供了 Exception 和 Error 类型,以及一些子类型。也可以自定义异常类型。此外,Dart 程序可以抛出任何 非null 对象,不仅限 Exception 和 Error 对象。
-
throw
throw FormatException('Expected at least 1 section');
-
抛出任意的对象
throw 'Out of llamas!';
-
在使用表达式的地方抛出异常
void distanceTo(Point other) => throw UnimplementedError();
-
Catch
捕获异常
try { breedMoreLlamas(); } on OutOfLlamasException { // 一个特殊的异常 buyMoreLlamas(); } on Exception catch (e) { // 其他任何异常 print('Unknown exception: $e'); } catch (e) { // 没有指定的类型,处理所有异常 print('Something really unknown: $e'); }
catch 函数可以指定 1到2个参数,第一个为异常对象,第二个为堆栈信息(StackTrace对象)
try { // ··· } on Exception catch (e) { print('Exception details:\n $e'); } catch (e, s) { print('Exception details:\n $e'); print('Stack trace:\n $s'); }
如果部分异常需要处理,可使用 rethrow 将异常重新抛出
void misbehave() { try { dynamic foo = true; print(foo++); // Runtime error } catch (e) { print('misbehave() partially handled ${e.runtimeType}.'); rethrow; // Allow callers to see the exception. } } void main() { try { misbehave(); } catch (e) { print('main() finished handling ${e.runtimeType}.'); } }
-
finally
无论是否 try 住异常,finally 都会执行。如果 try 住异常,会先执行对应的 catch,最后执行 finally
类
Dart 是一种基于类和 mixin 继承机制的面向对象的语言,每个对象都是一个类的实例,所有的类都继承于 Object. 。 基于 * Mixin 继承* 意味着每个类(除 Object 外) 都只有一个超类, 一个类中的代码可以在其他多个继承类中重复使用。
-
创建对象
var p = Point(2, 2); // 为实例的变量 y 设置值。 p.y = 3; // 获取变量 y 的值。 assert(p.y == 3); //如果 p 非空,则设置y=8 p?.y = 8 // 调用 p 的 distanceTo() 方法。 num distance = p.distanceTo(Point(4, 4));
使用
?.
来代替.
, 可以避免因为左边对象可能为 null , 导致的异常 -
获取对象类型
使用对象的
runtimeType
属性, 可以在运行时获取对象的类型,runtimeType
属性回返回一个 Type 对象。 -
实例变量
class Point { num x; // 声明示例变量 x,初始值为 null 。 num y; // 声明示例变量 y,初始值为 null 。 num z = 0; // 声明示例变量 z,初始值为 0 。 }
未初始化的变量为 null
所有实例变量都隐式生成 getter 方法,非 final 的变量会生成 setter 方法
-
默认构造
没有声明构造时,Dart 会提供一个默认的构造
-
构造函数不被继承
子类不会继承父类的构造函数。 子类不声明构造函数,那么它就只有默认构造函数 (匿名,没有参数) 。
-
命名构造函数
使用命名构造函数可以为一个类实现多个构造函数,也可以使用命名构造函数来更清晰的表明函数意图:
class Point { num x, y; Point(this.x, this.y); // 命名构造函数 Point.origin() { x = 0; y = 0; } }
切记,构造函数不能够被继承, 这意味着父类的命名构造函数不会被子类继承。 如果希望使用父类中定义的命名构造函数创建子类, 就必须在子类中实现该构造函数。
-
调用父类field默认构造函数
执行顺序如下:
- initializer list (初始化参数列表)
- superclass’s no-arg constructor (父类的无名构造函数)
- main class’s no-arg constructor (主类的无名构造函数)
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(data). Employee.fromJson(Map data) : super.fromJson(data) { print('in Employee'); } } main() { var emp = new Employee.fromJson({}); // Prints: // in Person // in Employee if (emp is Person) { // Type check emp.firstName = 'Bob'; } (emp as Person).firstName = 'Bob'; }
-
常量构造函数
如果你的类,创建的对象永远也不会改变,你可以在编译期就创建这个常量实例,并定义常量构造函数,并且确保所有的成员变量都是 final 的。
var p = const ImmutablePoint(2, 2);
在构造函数名之前加 const 关机字,来创建编译时常量
注意:构造两个相同编译时常量会产生一个相同的实例
在常量上下文中,const 可以被省略:
// 这里有很多的 const 关键字。 const pointAndLine = const { 'point': const [const ImmutablePoint(0, 0)], 'line': const [const ImmutablePoint(1, 10), const ImmutablePoint(-2, 11)], };
// 仅有一个 const ,由该 const 建立常量上下文。 const pointAndLine = { 'point': [ImmutablePoint(0, 0)], 'line': [ImmutablePoint(1, 10), ImmutablePoint(-2, 11)], };
在 Dart2中,一个常量上下文中的 const 关键字可以被省略
class ImmutablePoint { static final ImmutablePoint origin = const ImmutablePoint(0, 0); final num x, y; const ImmutablePoint(this.x, this.y); }
-
工厂构造函数
class Logger { final String name; bool mute = false; // 从命名的 _ 可以知, // _cache 是私有属性。 static final Map<String, Logger> _cache = <String, Logger>{}; factory Logger(String name) { if (_cache.containsKey(name)) { return _cache[name]; } else { final logger = Logger._internal(name); _cache[name] = logger; return logger; } } Logger._internal(this.name); void log(String msg) { if (!mute) print(msg); } }
其实就是一个工厂模式,传如对于的 name,然后获取到对应的实例
-
关于其他的
抽象类,枚举,这些就不详细的说了,都是基本操作,和java差不多。如果不懂,可自行到官网查看
异步操作
-
Future
void main() { print("start ----------->"); print(getNetData()); print("end -------------->"); } String getNetData() { //耗时 3 秒 sleep(Duration(seconds: 3)); return "网络数据"; }
start ----------->F //耗时三秒,打印如下 网络数据 end -------------->
可以看到,main 方法直接被阻塞了,导致接下来的代码无法继续执行,这种肯定是由问题的
异步网络请求
Future<String> getNetData() { return Future(() { sleep(Duration(seconds: 3)); return "网络数据"; }); }
start -----------> Instance of 'Future<String>' end -------------->
使用 future 对象将耗时操作放在了传入参数的函数中
可以看到没有发生阻塞,但是返回的结果却是 future 的实例。通过 future 就可以将耗时操作隔离,不会影响的主线程的执行。
获取 future 的结果
//getNetData 返回的 future 有返回结果时,就会自动调用 then 中传入的函数 //该函数会被放在事件循环中,被执行 getNetData().then((value) { print(value); });
start -----------> end --------------> 网络数据
执行过程中的异常
getNetData().then((value) { //支持成功到此处 print(value); }).catchError((error) { //执行失败到此处 print(error); });
常用的方法
-
Future.whenComplete
无论执行成功或者失败都会走到这里
getNetData().then((value) { //支持成功到此处 print(value); }).catchError((error) { //执行失败到此处 print(error); }).whenComplete(() => print("完成"));
可以用来做一些关闭对话框等操作
-
Future.them 链式调用
//在 them 中可以接继续返回值,该值会在下一个链式的 then 调用中拿到返回的结果 getNetData().then((value) { //支持成功到此处 print(value); return "data1"; }).then((value) { print(value); return "data2"; }).then((value) { print(value); }).catchError((error) { //执行失败到此处 print(error); }).whenComplete(() => print("完成"));
网络数据 data1 data2 完成
-
Future.wait
如果要等到多个异步任务都结束之后再进行一些操作,可以使用 Future.wait
Future.wait([getNetData(), getNetData(), getNetData()]).then((value) { value.forEach((element) { print(element); }); });
wait 接受一个 future 类型的数组,当 数组的 future 都执行成功后才会执行 then
-
Future.delayed
延时一定的时间后在执行函数
Future.delayed(Duration(seconds: 3), () { return "3秒后的信息"; }).then((value) { print(value); });
-
-
async,await
async:用来表示函数时异步的,定义的函数会返回一个 Future 对象,可以使用 then 添加回调函数
await :后面是一个 Future,表示等待改异步任务的完成,异步完成之后才会继续往下走,await 必须出现在 async 的内部
void main() { print("start ------ ----->"); getNetData().then((value) => print(value)); print("end -------------->"); } Future<String> getNetData() async { var result1 = await Future.delayed(Duration(seconds: 3), () { return "网络数据1"; }); var result2 = await Future.delayed(Duration(seconds: 3), () { return "网络数据2"; }); return result1 + "-----" + result2; }
在 getNetData 中,拿到两个结果进行拼接,然后一起返回
返回值会被包装在一个 Futter 中,在调用处就可以使用 them 直接拿到结果
---
> 参考文献:官方文档,Flutter实战,[Dart 异步](https://juejin.cn/post/6844903942795558919#heading-11)
## 下面让我们一起
> happy codeing