Dart的基础语法总结：变量/常量、数据类型、集合、函数、运算符、流程控制、类、枚举、泛型、库的使用

+

相关代码存放于：https://github.com/LinXunFeng/DartStudy

一、变量/常量

明确声明

1
2
3
4
5
// 明确声明
String name = 'lxf';
int age = 18;
double height = 1.8;
print('$name, $age, $height'); // lxf, 18, 1.8

类型推导

var

runtimeType : 用于获取变量当前的类型

1
2
3
var count = 1; // count的类型为int
print(count.runtimeType); // int
// count = "abc"; // 报错，无法为int类型赋值一个字符串

dynamic

dynamic 声明的变量可以赋值为任意类型

在开发中一般不这种做，因为会带来潜在的危险

1
2
3
4
5
6
7
dynamic type = 'lxf';
print(type.runtimeType); // String

type = 18;
print(type.runtimeType); // int

// type.abc(); // 编译期不会报错，运行时找不到方法报错

final & const

final 和 const 都用来定义变量

1
2
3
4
final gender = 'male';
// gender = 'female' // 报错
const country = 'China';
// country = 'USA'; // 报错

区别：

  • const : 必须赋值，接收一个常量值（即编译期间就需要确定的值）
  • final : 可以通过计算/函数动态获取值（即运行时能确定的值）
1
2
3
4
5
6
7
8
String getName() {
  return 'lxf';
}

main(List<String> args) {
	final myName = getName();
  // const myName = getName(); // 报错
}

二、数据类型

  • int: 整数
  • double: 浮点数

注：int 和 double 表示的范围不是固定的，具体取决于运行 Dart 的平台

整型

1
2
3
4
5
// 整型
int age = 18;
int hexAge = 0x12;
print(age); // 18
print(hexAge); // 18

浮点型

1
2
3
// 浮点类型 double
double height = 1.8;
print(height); // 1.8

布尔类型

1
2
var isFlag = true;
print('$isFlag ${isFlag.runtimeType}'); // true bool
  • Dart中没有非0即真或非空即真
1
2
3
4
var msg = 'lxf';
if (msg) { // 报错 Conditions must have a static type of 'bool'.
  print(msg);
}

字符串

1
2
3
// 字符串
var s1 = 'hello lxf';
var s2 = "hello lxf";

多行字符串

1
2
3
4
5
// 多行字符串
var s3 = '''
  hello
  hey
  lxf''';

字符串拼接

  • 字符串和其他变量或表达式拼接: 使用 ${expression}, 如果表达式是一个标识符, 那么 {} 可以省略
1
2
3
4
5
var s4 = s1 + s2;
print(s4); // hello lxfhello lxf

var s5 = 's1 = $s1 and s4 = ${s1 + s2}';
print(s5); // s1 = hello lxf and s4 = hello lxfhello lxf

三、集合

List

  • 使用 [] 字面量
1
2
3
4
5
var letters = ['a', 'b', 'c', 'd'];
print('$letters ${letters.runtimeType}'); // [a, b, c, d] List<String>

List<int> numbers = [1, 2, 3, 4];
print('$numbers ${numbers.runtimeType}'); // [1, 2, 3, 4] List<int>

List 特有的操作

1
2
3
4
// 由于List的元素是有序的，所有它还提供了一个删除指定索引位置上元素的方法removeAt
// List根据index删除元素
numbers.removeAt(3);
print('$numbers'); // [2, 3, 4]

Set

  • 使用 {} 字面量
  • 与 List 的两个不同点：Set 是无序的，且元素不重复
1
2
3
4
5
var lettersSet = {'a', 'b', 'c', 'd'};
print('$lettersSet ${lettersSet.runtimeType}'); // {a, b, c, d} _CompactLinkedHashSet<String>

Set<int> numbersSet = {1, 2, 3, 4};
print('$numbersSet ${numbersSet.runtimeType}'); // {1, 2, 3, 4} _CompactLinkedHashSet<int>

Map

1
2
3
4
5
6
7
var infoMap1 = {'name': 'lxf', 'age': 18};
print('$infoMap1 ${infoMap1.runtimeType}');
// {name: lxf, age: 18} _InternalLinkedHashMap<String, Object>

Map<String, Object> infoMap2 = {'height': 1.8, 'country': 'China'};
print('$infoMap2 ${infoMap2.runtimeType}');
// {height: 1.8, country: China} _InternalLinkedHashMap<String, Object>

Map 特有的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 1.根据key获取value
print(infoMap1['name']); // lxf

// 2.获取所有的entries
print('${infoMap1.entries} ${infoMap1.entries.runtimeType}');
// (MapEntry(name: lxf), MapEntry(age: 18)) MappedIterable<String, MapEntry<String, Object>>

// 3.获取所有的keys
print('${infoMap1.keys} ${infoMap1.keys.runtimeType}');
// (name, age) _CompactIterable<String>

// 4.获取所有的values
print('${infoMap1.values} ${infoMap1.values.runtimeType}');
// (lxf, 18) _CompactIterable<Object>

// 5.判断是否包含某个key或者value
print('${infoMap1.containsKey('age')} ${infoMap1.containsValue(18)}');
// true true

// 6.根据key删除元素
infoMap1.remove('age');
print('${infoMap1}'); // {name: lxf}

集合共有的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 长度
print(letters.length); // 4
print(lettersSet.length); // 4
print(infoMap1.length); // 2

// 添加、删除、包含元素
numbers.add(5);
numbersSet.add(5);
print('$numbers $numbersSet'); // [1, 2, 3, 4, 5] {1, 2, 3, 4, 5}

numbers.remove(1);
numbersSet.remove(1);
print('$numbers $numbersSet'); // [2, 3, 4, 5] {2, 3, 4, 5}

print(numbers.contains(2)); // true
print(numbersSet.contains(2)); // true

四、函数

函数也是对象，类型为 Function

函数定义

注意点：Dart 不支持函数重载！（函数重载：函数名称相同，参数不同）

1
2
3
4
返回值 函数的名称(参数列表) {
  函数体
  return 返回值
}

普通函数

1
2
3
4
5
num sum1(num num1, num num2) {
  return num1 + num2;
}

print(sum1(1, 2)); // 3

省略了类型注释也可以正常工作，但是不建议这么做

1
2
3
4
5
sum2(num1, num2) {
  return num1 + num2;
}

print(sum2(1, 2)); // 3

如果函数的实现只有一个表达式，则可以使用箭头语法

1
2
3
sum3(num num1, num num2) => num1 + num2;

print(sum3(1, 2)); // 3

可选参数

命名可选参数

  • 定义：命名可选参数: {param1, param2, ...}

  • 注意：

    • 如果确定传入的参数不能为 null，则需要加 required 关键字
    • 如果传入的参数可能为 null，则参数类型后面需要加 ?
1
2
3
4
5
6
7
// 命名可选参数
printInfo1(String name, {int? age, double? height}) {
  print('name = $name age = $age height = $height');
}

// 确定参数不能为null，需要添加 required 关键字
// printInfo1(String name, {required int age, required double height}) {}

参数默认值

1
2
3
printInfo3(String name, {int age = 18, double height = 1.8}) {
  print('name = $name age = $age height = $height');
}

调用

1
2
3
4
5
6
7
8
// 命名可选参数
printInfo1('lxf'); // name = lxf age = null height = null
printInfo1('lxf', age: 18); // name = lxf age = 18 height = null
printInfo1('lxf', age: 18, height: 1.8); // name = lxf age = 18 height = 1.8
printInfo1('lxf', height: 1.8); // name = lxf age = null height = 1.8

// 参数默认值
printInfo3('lxf'); // name = lxf age = 18 height = 1.8

位置可选参数

  • 定义：位置可选参数: [param1, param2, ...]
  • 注意：位置可选参数无法使用 required 关键字
1
2
3
4
// 位置可选参数
printInfo2(String name, [int? age, double? height]) {
  print('name = $name age = $age height = $height');
}

参数默认值

1
2
3
printInfo4(String name, [int age = 18, double height = 1.8]) {
  print('name = $name age = $age height = $height');
}

调用

1
2
3
4
5
6
7
// 位置可选参数
printInfo2('lxf'); // name = lxf age = null height = null
printInfo2('lxf', 18); // name = lxf age = 18 height = null
printInfo2('lxf', 18, 1.8); // name = lxf age = 18 height = 1.8

// 参数默认值
printInfo4('lxf'); // name = lxf age = 18 height = 1.8

五、运算符

常见的运算符

1
2
3
4
var num = 10;
print(num / 3); // 除法：3.3333333333333335
print(num ~/ 3); // 整除：3
print(num % 3); // 取模：1

赋值运算符

??= : 当变量为 null 时，使用后面的内容进行赋值

1
2
3
4
5
6
7
8
// 赋值运算符
var name = null;
name ??= 'lxf';
print(name); // lxf

var name1 = 'lin';
name1 ??= 'lxf';
print(name1); // lin

条件运算符

?? : 当变量为 null 时，则使用后面的值，否则使用变量的值

1
2
3
var temp = null;
var other = temp ?? 'lxf';
print(other); // lxf

级联

.. : 可以对对象进行连续操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Person {
  String name;

  Person(this.name);

  void run() {
    print("$name is running");
  }

  void eat() {
    print('$name is eating');
  }

  void swim() {
    print('$name is swimming');
  }
}

main(List<String> args) {
  final p1 = Person('lxf');
  p1.run();
  p1.eat();
  p1.swim();

  final p2 = Person('lin')
    ..run()
    ..eat()
    ..swim();
}

六、流程控制

if 和 else

不支持非空即真或非0即真，必须是明确的 bool 类型

1
2
3
4
5
6
var isHot = true;
if (isHot) {
  print('热门');
} else {
  print('冷门');
}

for

1
2
3
4
5
6
7
8
9
10
// for
for (var i = 0; i < 10; i++) {
  print(i);
}

// for in 遍历集合
var names = ['lxf', 'lin'];
for (var name in names) {
  print(name);
}

while

1
2
3
4
5
var index = 0;
while (index < 5) {
  print('index -- $index');
  index++;
}

do-while

1
2
3
4
5
var index = 0;
do {
  print('index -- $index');
  index++;
} while (index < 10);

break

  • 退出循环
1
2
3
4
5
6
7
8
9
var i = 1;
while (i <= 10) {
  if (i % 5 == 0) {
    print("满足条件，退出循环");
    break;
  }
  // 继续下一个循环
  i++;
}

continue

  • 终止当前迭代并开始后续迭代
  • 不会退出循环
1
2
3
4
5
6
7
8
9
10
var num = 0;
var count = 0;

for (num = 0; num <= 20; num++) {
  if (num % 2 == 0) {
    continue;
  }
  count++;
}
print("累加次数: $count"); // 累加次数: 10

switch-case

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var direction = 'east';
switch (direction) {
  case 'east':
    print('东面');
    break;
  case 'south':
    print('南面');
    break;
  case 'west':
    print('西面');
    break;
  case 'north':
    print('北面');
    break;
  default:
    print('其他方向');
}

六、类

类的定义如下：

1
2
3
4
5
6
class 类名 {
  类型 成员名;
  返回值类型 方法名(参数列表) {
    方法体
  }
}

late 关键字

作用：显式声明一个非空的变量，但不初始化，延迟变量的初始化

默认的构造函数是无参构建函数，这意味着属性无法从默认构建函数得到初始化，这时有两个选择，

选择一：自定义一个构造函数对属性进行初始化

选择二：使用 late 关键字修饰属性，延迟变量的初始化

加上 late 关键字可以通过静态检查，但是会带来运行时风险，你需要保证属性在使用前有进行初始化！

1
2
3
4
5
6
7
8
9
10
11
class Person {
  late String name;
  late int age;
}

main(List<String> args) {
  var p1 = Person();
  p1.name = 'lxf';
  print(p1.name); // lxf
  print(p1.age); // 报错：LateInitializationError: Field 'age' has not been initialized.
}

构造方法

普通构造方法

当类中没有指定构造方法时，默认会有一个无参的构造方法

1
2
3
4
5
6
7
8
9
class Person {
  String? name;
  int? age;
}


main(List<String> args) {
  var p1 = Person(); // 默认的构造方法
}

可以根据自已的需求，定义自已的构建方法，不过需要注意的是：

当定义了自已的构建方法，则默认的无参构造方法会失效，无法使用！

1
2
3
4
5
6
class Person {
  String name;
  int age;

  Person(this.name, this.age);
}

命名构造方法

由于 Dart 不支持方法重载，所以没办法创建相同名称的构造方法，如果希望能实现更多的构造方法，这时就需要使用命名构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Person {
  String? name;
  int? age;

  Person.withArgs(String name, int age) {
    this.name = name;
    this.age = age;
  }
}


main(List<String> args) {
  // var p1 = Person(); // 默认构造方法失效
  var p1 = Person.withArgs('lxf', 18);
  print(p1.name);
  print(p1.age);
}

重定向构造方法

在一个构造方法中，调用另一个构造方法进行初始化

1
2
3
4
5
6
7
8
9
class Person {
  String name;
  int age;

  Person(this.name, this.age);

  // 重定向构造方法
  Person.from(String name): this(name, 0);
}

常量构造方法

使用 const 修饰构造方法，当传入相同参数时，可以确保创建出来的对象是相同的

注意点：

  • 拥有常量构造方法的类中，所有的成员变量必须是final修饰的
  • 为了创建出相同的对象，在使用常量构造方法时，需要使用 const 关键字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Person {
  // 拥有常量构造方法的类中，所有的成员变量必须是final修饰的
  final String name;

  const Person(this.name);
}

main(List<String> args) {
  var p1 = const Person('lxf');
  var p2 = const Person('lxf');
  var p3 = const Person('lxf1');
  
  const p4 = Person4('lxf');
  
  // 判断是不是同一个对象
  print(identical(p1, p2)); // true
  print(identical(p1, p3)); // false
  print(identical(p1, p4)); // true
}

工厂构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Person {
  late String name;

  static final Map<String, Person> _cache = <String, Person>{};

  // 工厂构造方法
  factory Person(String name) {
    var p = _cache[name];
    if (p == null) {
      p = Person._internal(name);
      _cache[name] = p;
    }
    return p;
  }

  Person._internal(this.name);
}

main(List<String> args) {
  var p1 = Person5('lxf');
  var p2 = Person5('lxf');
  // 判断是不是同一个对象
  print(identical(p1, p2)); // true
}

注意：当工厂构造方法与默认构造方法重名时，无法被继承，会报错

1
2
3
The default constructor of superclass 'Father' (called by the implicit default constructor of 'Son') must be a generative constructor, but factory found.

父类的构造器必须是一个生成的构造器，而不能是工厂构造器

如下方代码所示

1
2
3
4
5
6
7
8
9
10
class Father {

  factory Father() {
    return Father._internal();
  }

  Father._internal();
}

class Son extends Father {} // 编译报错

需要添加一个生成构造器，并将工厂构造器改为命名构造器

1
2
3
4
5
6
7
8
9
10
11
class Father {

  Father();

  factory Father.factory() {
    return Father._internal();
  }
  Father._internal();
}

class Son extends Father {}

getter 和 setter

当希望类中定义的属性不轻易给外部访问时，就可以用到 getter 和 setter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Marker {
  String _color;

  String get color => _color;

  set color(String color) {
    _color = color;
  }

  Marker(this._color);
}

main(List<String> args) {
  final m = Marker('red');
  m.color = 'blue';
  print(m.color); // blue
}

继承

继承使用 extends 关键字，子类中使用 super 来访问父类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Animal {
  String name;

  Animal(this.name);

  eat() {
    print("吃吃吃");
  }
}

class Dog extends Animal {
  Dog(String name) : super(name);
}

main(List<String> args) {
  var dog = Dog("Spike");
  dog.eat(); // 吃吃吃
  print(dog.name); // Spike
}

重写父类的方法，@override 是注释，用来标明当前为重写的方法，可有可无，但一般保留着

1
2
3
4
5
6
7
8
9
class Dog extends Animal {
  Dog(String name) : super(name);

  // 重写父类的eat方法
  @override
  eat() {
    print("$name 在吃");
  }
}

抽象类

抽象类：使用 abstract 声明的类，用于定义通用接口，无法被实例化，方法可以没有实现，该方法称为抽象方法，交由子类去实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
abstract class Building {
  getHeight();

  getArea() {
    print("hello");
  }
}

class Tower extends Building {
  @override
  getHeight() {
    print("55m");
  }
}

main(List<String> args) {
  var tower = Tower();
  tower.getArea(); // hello
  tower.getHeight(); // 55m
}

隐式接口

  • Dart 没有关键字可以用来声明接口，所有的类都是隐式接口

  • 当一个类被当作接口使用时，那么实现这个接口的类必须实现接口中的所有方法

  • 实现接口使用 implements 关键字

  • 被实现的接口方法不可以使用 super 调用接口中的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Runner {
  run() {
    print("running");
  }
}

abstract class Fly {
  fly();
}

class SuperPerson implements Runner, Fly {
  @override
  run() {
    // 实现接口的方法不可以调用super
    // 报错：The method 'run' is always abstract in the supertype.
    // super.run();
    print('自由自在的奔跑');
  }

  @override
  fly() {
    print('起飞');
  }
}

Mixin混入

Dart 不支持多继承，使用接口时需要实现接口中的所有方法，而我们需要在当前类可以复用其它类中的实现时就需要用到 Mixin混入 的方式。

  • 定义：To implement a mixin, create a class that extends Object and declares no constructors. Unless you want your mixin to be usable as a regular class, use the mixin keyword instead of class.
  • 取自官方链接：https://dart.dev/guides/language/language-tour#adding-features-to-a-class-mixins
  • 大致意思：创建一个继承自 Object 的类，且没有声明构造函数，则该类就可被混入。除非你希望你的混入类可以被当作常规类使用，否则请使用 mixin 关键字，而不是 class

特性：

  • mixin 关键字声明混入（非必要，也可以用 class）

  • 混入类继承自 Object，且不可以有构造方法

  • on 关键字限定指定类的子类可以使用当前混入（不加默认限定为 Object）

  • 使用 mixin 后无法被继承

  • 使用 with 进行混入

  • 父类与混入的方法重名时，使用的是混入的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// mixin Runner {} // 可以不使用on，默认是 on Object

mixin Runner on Animal {
  run() {
    print('跑起来了');
  }
}

class Animal {
  run() {
    print('Animal run');
  }
}

class SuperPeople extends Animal with Runner {} // 必须继承 Animal 才可以混入 Runner

// 报错：'Runner' can't be mixed onto 'Object' because 'Object' doesn't implement 'Animal'.
// class Person with Runner {}

// 报错：Classes can only extend other classes.
// class Person extends Runner {} // Runner无法被继承

main(List<String> args) {
  var p = SuperPeople();
  p.run(); // 跑起来了（使用的是混入的方法，而不是父类中的）
}

当前类、父类与混入的实现优先级

总结：当前类 > 混入 > 父类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class A {
  void method() {
    print('I am A');
  }
}

class B {
  void method() {
    print('I am B');
  }
}

class C extends A with B {
  // void method() {
  //   print('I am C');
  // }
}

main(List<String> args) {
  var c = C();
  /**
   * C 有无自己的 method 方法实现：
   *  - 有：打印：I am C
   *  - 无：打印：I am B
   */
  c.method();
}

七、枚举

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 定义枚举
enum Color { red, blue, green }

main(List<String> args) {
  print(Color.red); // Color.red

  print(Color.red.index); // 0 枚举的下标从0开始
  print(Color.blue.index); // 1

  print(Color.values); // [Color.red, Color.blue, Color.green]

  var color = Color.green;
  switch (color) {
    case Color.red:
      print("红");
      break;
    case Color.blue:
      print("蓝");
      break;
    case Color.green:
      print("绿");
      break;
  }
}

八、泛型

List 使用泛型

1
2
3
4
5
6
7
8
9
10
// List
var myList = ['lxf', 18];
print(myList.runtimeType); // List<Object>

// List使用泛型，限制类型
var numList = <int>[10, 20];
List<String> nameList = ["lxf", "lin"]; // 一般使用这种

// 报错: The element type 'int' can't be assigned to the list type 'String'.
// List<String> nameList = ["lxf", "lin", 18];

Map 使用泛型

1
2
3
4
5
6
7
8
9
10
// Map
var msgMap = {1: 'one', 'name': 'lxf', 'age': 18};
print(msgMap.runtimeType); // _InternalLinkedHashMap<Object, Object>

// Map使用泛型，限制类型
var infoMap = <String, String>{'name': 'lxf', 'age': '18'};
// Map<String, String> profileMap = {'name': 'lxf', 'age': '18'}; // 一般使用这种

// 报错：The element type 'int' can't be assigned to the map value type 'String'.
// Map<String, String> profileMap = {'name': 'lxf', 'age': 18};

类定义泛型

将类的属性以泛型做为类型声明，由外部来决定最终的类型

1
2
3
4
5
6
7
8
9
10
11
class Point<T> {
  T x;
  T y;

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

main(List<String> args) {
  Point p = Point<double>(10.5, 20.5);
  print(p.x.runtimeType); // double
}

如果希望属性的类型只能是数字，可以使用 extends 来限制泛型 T 只能为 num 的子类

1
2
3
4
5
6
7
8
9
10
11
12
class Size<T extends num> {
  T width;
  T height;

  Size(this.width, this.height);
}

main(List<String> args) {
  Size s = Size<int>(20, 10);
  // 报错：A value of type 'Size<String>' can't be assigned to a variable of type 'Size<num>'.
  // Size s1 = Size<String>("20", "10"); 
}

九、库的使用

库的导入

Dart 标准库

Dart 标准库的导入前缀为 dart:

1
2
3
import 'dart:io';
import 'dart:html';
import 'dart:math';

自定义库

libs/math_utils.dart 文件的内容：

1
2
3
4
5
6
7
num sum(num num1, num num2) {
  return num1 + num2;
}

num multiply(num num1, num num2) {
  return num1 * num2;
}

使用

1
2
3
4
5
6
7
// 导入自定义库
import 'libs/math_utils.dart';

main(List<String> args) {
  print(sum(10, 20)); // 30
  print(multiply(10, 20)); // 200
}

第三方库

在项目目录下创建 pubspec.yaml 文件，在 dependencies 下添加需要依赖的第三方的库名与版本

第三库的使用说明可在 https://pub.flutter-io.cn 上查找

1
2
3
4
5
6
name: dartStudy
description: this is lxf's study project
dependencies:
  dio: ^4.0.0
environment:
  sdk: ">=2.10.0 <3.0.0"

填写好依赖后，在终端下执行 dart pub get 命令，终端会自动拉取对应版本的第三方文件，之后在代码中就可以导入并使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 导入第三方库
import 'package:dio/dio.dart';

main(List<String> args) {
  getHttp();
}

void getHttp() async {
  try {
    var response = await Dio().get('http://www.google.cn');
    print(response);
  } catch (e) {
    print(e);
  }
}

延迟加载

  • 作用：在需要的时候才进行加载
  • 好处：减少 App 的启动时间
  • 使用：使用 deferred as
1
2
// 延迟加载
import 'package:dio/dio.dart' deferred as diolib;

在使用延迟加载的库中，需要调用 loadLibrary 以加载声明为延迟加载的库

1
2
3
4
5
main(List<String> args) async {
  // 调用loadLibrary方法来加载延迟加载的库
  await diolib.loadLibrary();
  diolib.Dio().get('http://www.google.cn');
}

给库起别名

一般在与别的库的内容冲突时使用

1
2
3
4
5
6
import 'libs/math_utils.dart' as MathUtils; // 别名

main(List<String> args) {
  print(MathUtils.sum(10, 20)); // 30
  print(MathUtils.multiply(10, 20)); // 200
}

指定库内容的显示与隐藏

1
2
import 'libs/math_utils.dart' show sum, multiply; // show: 显示指定的内容（即部分引入）
import 'libs/math_utils.dart' hide sum; // hide: 隐藏指定的内容

library、part 和 part of

作用：

  • library：定义库名
  • part：关联分库文件
  • part of：声明隶属哪个库，使用的是 library 定义的库名

特点：

  • library、part 和 part of 都必须定义在文件的第一行，否则会报错
  • 主库可以访问分库中的私有成员
  • 如果需要导入其它库，只能在主库中导入，无法在分库中导入，且 import 只能放在 library 和 part 之间
  • 如果外部需要使用到分库的内容，只需要导入主库即可

文件目录结构：

1
2
3
4
5
6
├── 16_库的定义.dart
└── lib
    └── part
        ├── fitsize.dart
        ├── fitsize_part1.dart
        └── fitsize_part2.dart

fitsize.dart 文件内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 定义库名
library fitsize;

// 关联分库
part 'fitsize_part1.dart';
part 'fitsize_part2.dart';

void fit() {
  // 可以访问分库下的私有成员

  part1PublicMethod(); // part1 public method
  _part1PrivateMethod(); // part1 private method

  part2PublicMethod(); // part2 public method
  _part2PrivateMethod(); // part2 private method
}

fitsize_part1.dart 文件内容

1
2
3
4
5
6
7
8
9
part of fitsize; // 声明为主库的一部分

part1PublicMethod() {
  print("part1 public method");
}

_part1PrivateMethod() {
  print("part1 private method");
}

fitsize_part2.dart 文件内容

1
2
3
4
5
6
7
8
9
part of fitsize; // 声明为主库的一部分

part2PublicMethod() {
  print("part2 public method");
}

_part2PrivateMethod() {
  print("part2 private method");
}

这样三个 dart 文件就组成了 fitsize 库，如果外部需要使用到分库的内容，只需要导入主库即可。

如果需要导入其它库，只能在主库中导入，无法在分库中导入，且 import 只能放在 library 和 part 之间，否则会报错。

1
2
3
4
5
6
7
8
9
10
// fitsize.dart 主库文件

// 定义库名
library fitsize;

import 'dart:io'; // 导入其它库，只能放在这个位置

// 关联分库
part 'fitsize_part1.dart';
part 'fitsize_part2.dart';

export

官方不再推荐使用 part 关键字，而是推荐使用 export

  • 使用：在一个 dart 文件里使用 export 关键字，将其它库文件导出
  • 作用：这样外部在使用时只需要导入一个文件即可使用完整的库内容

文件目录结构：

1
2
3
4
5
6
7
├── 16_库的定义.dart
└── lib
    └── export
        ├── lxf_utils.dart
        └── source
            ├── lxf_file_util.dart
            └── lxf_math_util.dart

lxf_utils.dart 文件内容：

1
2
3
4
5
6
// 定义库名
library lxf_utils;

// 导出所有的库
export './source/lxf_math_util.dart';
export './source/lxf_file_util.dart';

lxf_math_util.dart 文件内容：

1
2
3
num sum(num num1, num num2) {
  return num1 + num2;
}

lxf_file_util.dart 文件内容：

1
2
3
writeFile(String name, String dir_path) {
  print('写入文件 $dir_path$name ');
}

导入并调用

1
2
3
4
5
6
import 'lib/export/lxf_utils.dart' as utils;

main(List<String> args) {
  print(utils.sum(1, 2)); // 3
  utils.writeFile('lxf.jpg', '/lxf/Desktop/'); // 写入文件 /lxf/Desktop/lxf.jpg
}