文章/答案/技术大牛

发布

社区首页 >专栏 >Dart 学习之开发语言概览，带思维导图（二）

Dart 学习之开发语言概览，带思维导图（二）

siberiawolf

发布于 2020-03-24 09:16:06

1.8K00

代码可运行

文章被收录于专栏：前端修炼之路前端修炼之路

运行总次数：0

代码可运行

库和可见性

使用import关键字导入
dart内置库，使用dart:xxxx
其他库，package:xxxx
以下划线（_）开头的成员仅在代码库中可见
每个 Dart 程序都是一个库，即便没有使用关键字 library 指定

库前缀

如果两个库代码有冲突，可以指定库前缀

import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

// 使用 lib1 的 Element 类。
Element element1 = Element();

// 使用 lib2 的 Element 类。
lib2.Element element2 = lib2.Element();

导入库的一部分

只想使用代码库中的一部分，你可以有选择地导入代码库

// 只导入 lib1 中的 foo。(Import only foo).
import 'package:lib1/lib1.dart' show foo;

// 导入 lib2 中除了 foo 外的所有。
import 'package:lib2/lib2.dart' hide foo;

注释

单行注释

单行注释以 // 开始。所有在 // 和该行结尾之间的内容被编译器忽略。

// 单行注释

多行注释

不会忽略文档注释
多行注释可以嵌套
多行注释以 /` 开始，以 `/ 结尾。所有在 /` 和 `/ 之间的内容被编译器忽略

void main() {
  /*
   * This is a lot of work. Consider raising chickens.

  Llama larry = Llama();
  larry.feed();
  larry.exercise();
  larry.clean();
   */
}

文档注释

在文档注释中，除非用中括号括起来，否则 Dart 编译器会忽略所有文本。

/// A domesticated South American camelid (Lama glama).
///
/// Andean cultures have used llamas as meat and pack
/// animals since pre-Hispanic times.
class Llama {
  String name;

  /// Feeds your llama [Food].
  ///
  /// The typical llama eats one bale of hay per week.
  void feed(Food food) {
    // ...
  }

  /// Exercises your llama with an [activity] for
  /// [timeLimit] minutes.
  void exercise(Activity activity, int timeLimit) {
    // ...
  }
}

在生成的文档中，[Food] 会成为一个链接，指向 Food 类的 API 文档。

也就是说，在生成的文档中[Food]这个标识符就可以显示一个链接。

类型定义

使用typedef显示保留类型信息
目前类型定义只能在函数上

// 自定义一个类型
typedef Compare = int Function(Object a, Object b);

/// 使用类型定义的情况
class SortedCollection {
  Compare compare;  // 自定义类型

  SortedCollection(this.compare);
}

// 简单的不完整实现。
int sort(Object a, Object b) => 0;

void main() {
  SortedCollection coll = SortedCollection(sort);
  print(coll.compare is Function); // true
  print(coll.compare is Compare); // true
}

类

声明类

使用class声明
使用new创建一个对象，new可以省略
所有对象都是一个类的实例
所有的类都继承自 Object 类

使用类成员

类的成员包括函数和数据
使用(.)来访问变量和方法
使用(?.)避免表达式为null

void main(List<String> args) {
  Person p = Person();
  p.name = 'tom';
  p.age = 12;
  print(p.name); // tom

  /// ?. 
  // 因为p2是null，所以无法设置并且打印
  // 但是使用了?.以后就不会报错了。
  Person p2;
  p2?.name = 'jack';
  p2?.age = 13;
  print(p2?.name);  // null
}

class Person{
  String name;
  int age;
}

使用构造函数

使用类名
使用类名.标识符
使用identical函数判断两个类的实例是否相等

void main(List<String> args) {
  // 通过 类 创建实例
  Person p = Person('tom', 12);
  print(p.name);  // tom
  print(p.age); // 12

  // 通过 类名.标识符 创建实例
  Person p2 = Person.fromJson({'name': 'jack', 'age': 13})  ;
  print(p2.name); // jack
  print(p2.age); // 13

  Animal a = const Animal('titi', 2);
  Animal b  = const Animal('titi', 2);
  print(a.name);
  print(a.age);

  print(b.name);

  // 两个实例相等
  print(identical(a,b));  // true


}

class Person{
  String name;
  int age;

  Person(this.name, this.age);

  Person.fromJson(Map<String, dynamic> json){
    name = json['name'];
    age = json['age'];
  }
}

// 常量构造函数
class Animal{
  final String name;
  final int age;

  const Animal(this.name, this.age);
}

实例变量

所有未初始化的变量均会被设置为null
所有实例变量均会隐式地声明一个 Getter 方法
所有非 final 变量均会隐式声明一个 Setter方法

void main(List<String> args) {
  Point p = Point();
  print(p.x); // 调用x的 Getter

  p.y = 1; // 调用y的 Setter
  print(p.y); // 调用y的 Getter
}
class Point{
  int x,y;
}

命名式构造函数

void main(List<String> args) {
  Point p = Point.origin();

  print(p.x); // 0
  print(p.y); // 1
}
class Point{
  int x,y;
  Point(this.x, this.y);

  // 命名式构造函数
  Point.origin(){
    x = 0;
    y = 1;
  }
}

调用父类非默认构造函数

调用顺序

1.初始化列表
2.父类的无参数构造函数
3.当前类的构造函数

传递给父类构造函数的参数不能使用 this 关键字。

使用(:)为子类的构造函数指定一个父类的构造函数。

class Person {
  String firstName;

  Person.fromJson(Map data) {
    print('in Person');
  }
}

class Employee extends Person {.
  // Person没有默认构造函数
  // 需要通过 super.fromJson 来显示调用
  Employee.fromJson(Map data) : super.fromJson(data) {
    print('in Employee');
  }
}

main() {
  var emp = new Employee.fromJson({});

  // 打印:
  // in Person  先执行父类的构造
  // in Employee
  if (emp is Person) {  // emp类继承了Person
    emp.firstName = 'Bob';
  }
  print(emp.firstName); // Bob
  (emp as Person).firstName = 'Jack';
  print(emp.firstName);   // Jack
}

初始化列表

在构造函数体执行前初始化变量
初始化列表用来设置 final 字段是非常好用的

class Person {
  String firstName;

  // 初始化列表 会比 构造函数优先执行
  Person.fromJson(Map data): firstName = data['firstName'] {
    print(firstName);
  }
}

main() {
  Person p = Person.fromJson({ 'firstName': 'zhangsan'});

}

设置final 字段

import 'dart:math';

class Point {
  final num x;
  final num y;
  final num distanceFromOrigin;

  // 初始化列表设置final属性，非常好用
  Point(x, y)
      : x = x,
        y = y,
        distanceFromOrigin = sqrt(x * x + y * y);
}

main() {
  var p = new Point(2, 3);
  print(p.distanceFromOrigin);  // 3.605551275463989
}

重定向构造函数

调用自己类中其它的构造函数
没有函数体

void main(List<String> args) {}

class Point {
  int x, y;
  Point(this.x, this.y);

  // 重定向构造函数
  // 在函数中调用另一个构造函数的形式
  Point.origin(int num) : this(num, 0);
}

常量构造函数

属性用final定义为常量属性
构造函数用const定义为常量构造函数

void main(List<String> args) {
  Point p = const Point(0, 0);
  Point p2 = const Point(0, 0);

  Point p3 = Point(0, 0);

  // 这两个实例对象是相同的
  print(identical(p, p2)); // true

  // 如果不使用const声明实例，则不会相等
  print(identical(p, p3)); // false
}

class Point {
  // 变量必须用final 定义
  final num x, y;
  const Point(this.x, this.y); // 构造函数也是常量
}

工厂构造函数

void main(List<String> args) {
  Person p = Person('tom');
  p.say();    // tom

}
 class Person{
   String name;

  // 必须static 定义
  static final Map<String, dynamic> _cach = Map<String, dynamic>();

   factory Person(String name){
     return _cach.putIfAbsent(name, () => Person._init(name));
   } 

   Person._init(this.name);

   void say(){
     print(name);
   }

 }

方法

实例方法

对象的实例方法可以访问实例变量和this 。

void main(List<String> args) {
  Person p = Person('tom', 'hello title');
  p.say();
}

class Person{
  String name;
  String title;

  Person(this.name, this.title);

  void say(){
    // 可以访问变量
    print('name is $name');
    // 也可以访问this
    print(this.name);
  }
}

Getter和Setter

你可以使用 get 和 set 关键字为额外的属性添加 Getter 和 Setter 方法

void main(List<String> args) {
  Point p = Point(1, 2, 3);
  print(p.point); // 6

  p.point = 0;
  print(p.point);
  print(p.z);
}

class Point {
  int x, y, z;

  Point(this.x, this.y, this.z);

  get point => x + y + z;
  // TODO： 这里为啥设置point 却返回z的值？
  set point(int num) => z = num + x;
}

抽象方法

void main(List<String> args) {

}
// 定义抽象类
abstract class Person{
  // 定义抽象方法
  void doSomething();
}

class Zhangsan extends Person{
  // 实现具体的方法
  void doSomething(){

  }
}

抽象类

void main(List<String> args) {
  var me = Me();
  me.sayHello();
}

abstract class Person{
  String name;
  int age;

  void sayHello();
}

class Me extends Person{
  void sayHello(){
    print('hello');
  }
}

隐式接口

一个类可以通过关键字 implements 来实现一个或多个接口并实现每个接口定义的 API。

void main(List<String> args) {

  print(saySomething(Person('张三')));

  print(saySomething(Man()));

}

String saySomething(Person person) => person.sayName('李四');

class Person {
  String _name;

  Person(this._name);

  String sayName(String name) => '$_name，你好。我是$name';
}

class Man implements Person {
  get _name => '谁也不是';

  set _name(String name) => ''; // 因为存在隐式的setter，所以这个也要定义

  String sayName(String name) => '$_name，你好。我是$name';
}

扩展一个类

使用extends来扩展一个类
使用super来引用一个父类

void main(List<String> args) {
  Man man = Man();
  man.sayName();
}

class Person{

  void sayName() => print('hello person');
}

class Man extends Person{

  void sayName() => super.sayName();  // 调用父类方法
}

重写类成员

void main(List<String> args) {
  Man man = Man();
  man.sayName();
}

class Person{

  void sayName() => print('hello person');
}

class Man extends Person{

  @override
  void sayName() => print('hello man'); // 重写实例方法
}

重写运算符

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);

  // 运算符 == 和 hashCode 的实现未在这里展示，详情请查看下方说明。
  // ···
}

void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);

  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
}

noSuchMethod

这个地方没有看明白

void main(List<String> args) {
  Man man = Man();
  // man.name;
  // todo 怎么使用？？
}

class Person {
  void sayName() => print('hello person');
}

class Man extends Person {
  void sayName() => super.sayName(); // 调用父类方法

  @override
  void noSuchMethod(Invocation invocation) {
    print('你尝试使用一个不存在的成员：' + '${invocation.memberName}');
  }
}

枚举

使用enmu定义
每个枚举值都有index
使用values获取所有枚举
枚举不能成为子类
枚举不可以mixin
不可以实现一个枚举
不可以显示实例化一个枚举

使用枚举

void main(List<String> args) {

  print(Color.blue);  // 获取枚举

  print(Color.red.index);   // 获取枚举下标

  List<Color> colors = Color.values;  // 获取全部枚举

  print(colors[2]);

}

enum Color{ // 定义枚举
  red, blue, green
}

switch枚举

void main(List<String> args) {
  var aColor = Color.red;
  // 如果使用switch 则枚举中的每一个成员都得用case判断
  // 否则就会发出警告
  switch (aColor) {
    case Color.red:
      print('红色');
      break;
    case Color.blue:
      print('蓝色');
      break;
    case Color.green:
      print('绿色');
      break;
  }
}

enum Color {
  // 定义枚举
  red,
  blue,
  green
}

使用mixin为类添加功能

Mixin 是一种在多重继承中复用某个类中代码的方法模式
使用with关键字
使用mixin定义
使用on规定哪个类可以使用

覆写操作符基本格式：

返回类型 operator 操作符(参数1，参数2...){
    实现体...
    return 返回值
}

void main(List<String> args) {
  Musical musical = Musical();
  musical.doSomethin();
}
mixin Person {
  bool canCook = true;
  bool canSay = false;

  // mixin 模式不可以定义构造函数
  // Person();

  void doSomethin() {
    if (canCook == true) {
      print('可以做饭');
    } else if (canSay == true) {
      print('可以说话');
    }
  }
}
class Musical with Person{
  @override
  void doSomethin() {
    // TODO: implement doSomethin
    super.doSomethin();   // 直接调用父类
    print('我是子类哦');
  }
}

类变量和方法

静态变量

静态变量在其首次被使用的时候才被初始化

void main(List<String> args) {
  print(Person.name); // test static
}
class Person{
  static final String name = 'test static';

}

静态方法

对于一些通用或常用的静态方法，应该将其定义为顶级函数而非静态方法
可以将静态方法作为编译时常量

import 'dart:math';

class Point {
  num x, y;
  Point(this.x, this.y);

  static num distanceBetween(Point a, Point b) {
    var dx = a.x - b.x;
    var dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
  }
}

void main() {
  var a = Point(2, 2);
  var b = Point(4, 4);
  // 对于一些通用或常用的静态方法，应该将其定义为顶级函数而非静态方法。
  var distance = Point.distanceBetween(a, b);
  assert(2.8 < distance && distance < 2.9);
  print(distance);
}

泛型

为什么使用泛型

通常使用一个字母来代表类型参数，比如E、T、S、K 和 V 等等
适当地指定泛型可以更好地帮助代码生成
使用泛型可以减少代码重复

代码错误提示

void main(List<String> args) {
  var names = List<String>(); // 声明为字符串数组，一旦不是则报错
  names.addAll(['Seth', 'Kathy', 'Lars']);
  // 提示报错
  // names.add(42); // Error
}

减少重复代码 使用泛型声明一个类，让不同类型的缓存实现该类做出不同的具体实现。

void main(List<String> args) {}

abstract class Cache<T> {
  T getByKey(String key);
  void setByKey(String key, T value);
}

class Acache extends Cache<String> {
  String getByKey(String key) {
    // 具体实现时指定
    return 'hello';
  }

  void setByKey(String key, String value) {
    // 具体实现时指定
    print(11);
  }
}

使用集合字面量

void main(List<String> args) {
  List list = <String>['1', '2', '3'];  // 字符串集合
  Set set = <String>{'1','2','3'}; // 字符串集合
  Map map = <String, int>{'age': 1, 'size':12}; // Map
}

使用类型参数化的构造函数

void main(List<String> args) {
  // 与字面量相对应，也可以通过构造函数的方式使用泛型
  Map map = Map<String, int>();
}

泛型集合以及他们所包含的类型

void main(List<String> args) {
  List list = List<String>();
  // list.addAll(['1','2']); 
  // 如果此时使用addAll则会报错
  list.add('1');
  list.add('2');
  print(list is List<String>); // true

  var names = List<String>();
  names.addAll(['小芸', '小芳', '小民']);
  print(names is List<String>); // true
}

限制参数化类型

指定参数类型
不指定参数类型，使用默认类型
错误参数类型，编译报错

void main(List<String> args) {
  var someBaseClassFoo = Foo<SomeBaseClass>();
  var extenderFoo = Foo<Extender>();

  print(someBaseClassFoo.toString()); // 'Foo<SomeBaseClass>' 的实例
  print(extenderFoo.toString()); // 'Foo<Extender>' 的实例

  // 如果不指定泛型，默认是SomeBaseClass
  var foo = Foo();
  print(foo);
  // 将非 SomeBaseClass 的类型作为泛型参数则会导致编译错误
  // var foo = Foo<Object>(); 
}

class SomeBaseClass {}

// 这里的T，其实可以随意指定。一般是T、E、S、K等
class Foo<T extends SomeBaseClass> {
  // 具体实现……
  String toString() => "'Foo<$T>' 的实例";
}

class Extender extends SomeBaseClass {}

使用泛型方法

函数的返回类型
参数的类型List
局部变量的类型

void main(List<String> args) {
  var list = List<String>();
  list.addAll(['1','2']);

  var firstValue = first(list);
  print(firstValue);  // 1
}
T first<T>(List<T> ts) {
  // 处理一些初始化工作或错误检测……
  T tmp = ts[0];
  // 处理一些额外的检查……
  return tmp;
}

异步支持

处理Future

使用 async 和 await 的代码是异步的，但是看起来有点像同步代码
必须在带有 async 关键字的异步函数中使用 await
使用 try、catch 以及 finally 来处理使用 await 导致的异常
await 表达式的返回值是一个 Future 对象
Future 对象代表一个“承诺”，await 表达式会阻塞直到需要的对象返回

void main(List<String> args) {}
// async 与 await同时使用
Future checkVersion() async {
  // 通过 try-catch 捕获异常
  try {
    var version = await lookUpVersion();
  } catch (e) {
    // 无法找到版本时做出的反应
  }
}

void lookUpVersion() {}

异步函数

void main(List<String> args) {

}
// 普通函数直接添加async关键字即可
Future<String> lookUpVersion() async => '1.0.0';

处理Stream

使用async和await for循环
使用Stream API
表达式的类型必须是 Stream
使用 break 和 return 语句停止接收 Stream 数据，跳出循环
1.等待直到 Stream 返回一个数据
2.使用 1 中 Stream 返回的数据执行循环体
3.重复 1、2 过程直到 Stream 数据返回完毕

可调用类

通过实现类的 call() 方法，允许使用类似函数调用的方式来使用该类的实例。

// WannabeFunction 类定义了一个 call() 函数，函数接受三个字符串参数，函数体将三个字符串拼接，字符串间用空格分割，并在结尾附加了一个感叹号

class WannabeFunction {
  String call(String a, String b, String c) => '$a $b $c!';
}

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

main() => print(out);