Dart 介绍

Hello World

每个应用程序都需要顶级的 main() 函数，程序执行从这里开始。不显式返回值的函数的返回类型为 void。若要在控制台显示文本，可以使用顶级的 print() 函数：

void main() {
  print('Hello, World!');
}

变量

即使在类型安全的 Dart 代码中，你也可以使用 var 声明大多数变量，而无需显式指定其类型。由于类型推断，这些变量的类型由其初始值决定：

var name = 'Voyager I';
var year = 1977;
var antennaDiameter = 3.7;
var flybyObjects = ['Jupiter', 'Saturn', 'Uranus', 'Neptune'];
var image = {
  'tags': ['saturn'],
  'url': '//path/to/saturn.jpg',
};

控制流语句

Dart 支持常见的控制流语句：

if (year >= 2001) {
  print('21st century');
} else if (year >= 1901) {
  print('20th century');
}

for (final object in flybyObjects) {
  print(object);
}

for (int month = 1; month <= 12; month++) {
  print(month);
}

while (year < 2016) {
  year += 1;
}

函数

我们建议为每个函数的参数和返回值指定类型：

int fibonacci(int n) {
  if (n == 0 || n == 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

var result = fibonacci(20);

简写的 =>（箭头）语法适用于只包含一条语句的函数。当将匿名函数作为参数传递时，这种语法特别有用：

flybyObjects.where((name) => name.contains('turn')).forEach(print);

除了展示匿名函数（where() 的参数）之外，这段代码还表明你可以将函数作为参数使用：顶级的 print() 函数就是 forEach() 的一个参数。

注释

Dart 注释通常以 // 开头。

// 这是一个普通的单行注释。

/// 这是一个文档注释，用于为库、类及其成员编写文档。
/// 像 IDE 和 dartdoc 这样的工具会特殊处理文档注释。

/* 也支持这样的注释。 */

导入

若要访问其他库中定义的 API，请使用 import。

// 导入核心库
import 'dart:math';

// 从外部包导入库
import 'package:test/test.dart';

// 导入文件
import 'path/to/my_other_file.dart';

类

以下是一个具有三个属性、两个构造函数和一个方法的类的示例。其中一个属性不能直接设置，因此使用 getter 方法（而不是变量）来定义。该方法使用字符串插值在字符串字面量中打印变量的字符串表示形式。

class Spacecraft {
  String name;
  DateTime? launchDate;

  // 只读的非 final 属性
  int? get launchYear => launchDate?.year;

  // 构造函数，使用语法糖为成员赋值。
  Spacecraft(this.name, this.launchDate) {
    // 初始化代码放在这里。
  }

  // 命名构造函数，转发到默认构造函数。
  Spacecraft.unlaunched(String name) : this(name, null);

  // 方法。
  void describe() {
    print('Spacecraft: $name');
    // 类型提升对 getter 不起作用。
    var launchDate = this.launchDate;
    if (launchDate != null) {
      int years = DateTime.now().difference(launchDate).inDays ~/ 365;
      print('Launched: $launchYear ($years years ago)');
    } else {
      print('Unlaunched');
    }
  }
}

你可以像这样使用 Spacecraft 类：

var voyager = Spacecraft('Voyager I', DateTime(1977, 9, 5));
voyager.describe();

var voyager3 = Spacecraft.unlaunched('Voyager III');
voyager3.describe();

阅读更多关于 Dart 中类的内容，包括初始化列表、可选的 new 和 const、重定向构造函数、工厂构造函数、getter、setter 等等。

枚举

枚举是一种枚举预定义值或实例的方式，可确保该类型不会有其他实例。

以下是一个简单枚举的示例，它定义了一个简单的预定义行星类型列表：

enum PlanetType { terrestrial, gas, ice }

以下是一个增强枚举声明的示例，描述行星的类，具有一组定义好的常量实例，即我们太阳系中的行星。

/// 枚举我们太阳系中不同的行星
/// 及其一些属性。
enum Planet {
  mercury(planetType: PlanetType.terrestrial, moons: 0, hasRings: false),
  venus(planetType: PlanetType.terrestrial, moons: 0, hasRings: false),
  // ···
  uranus(planetType: PlanetType.ice, moons: 27, hasRings: true),
  neptune(planetType: PlanetType.ice, moons: 14, hasRings: true);

  /// 常量生成构造函数
  const Planet({
    required this.planetType,
    required this.moons,
    required this.hasRings,
  });

  /// 所有实例变量都是 final 的
  final PlanetType planetType;
  final int moons;
  final bool hasRings;

  /// 增强枚举支持 getter 和其他方法
  bool get isGiant =>
      planetType == PlanetType.gas || planetType == PlanetType.ice;
}

你可以像这样使用 Planet 枚举：

final yourPlanet = Planet.earth;

if (!yourPlanet.isGiant) {
  print('Your planet is not a "giant planet".');
}

继承

Dart 支持单继承。

class Orbiter extends Spacecraft {
  double altitude;

  Orbiter(super.name, DateTime super.launchDate, this.altitude);
}

混入

混入是在多个类层次结构中复用代码的一种方式。以下是一个混入声明：

mixin Piloted {
  int astronauts = 1;

  void describeCrew() {
    print('Number of astronauts: $astronauts');
  }
}

若要将混入的功能添加到类中，只需使用混入来扩展该类。

class PilotedCraft extends Spacecraft with Piloted {
  // ···
}

PilotedCraft 现在具有 astronauts 字段以及 describeCrew() 方法。

阅读更多关于混入的内容。

接口和抽象类

所有类都隐式定义了一个接口。因此，你可以实现任何类。

class MockSpaceship implements Spacecraft {
  // ···
}

你可以创建一个抽象类，供具体类扩展（或实现）。抽象类可以包含抽象方法（方法体为空）。

abstract class Describable {
  void describe();

  void describeWithEmphasis() {
    print('=========');
    describe();
    print('=========');
  }
}

任何扩展 Describable 的类都有 describeWithEmphasis() 方法，该方法会调用扩展类实现的 describe() 方法。

异步

使用 async 和 await 可以避免回调地狱，使代码更具可读性。

const oneSecond = Duration(seconds: 1);
// ···
Future<void> printWithDelay(String message) async {
  await Future.delayed(oneSecond);
  print(message);
}

上述方法等同于：

Future<void> printWithDelay(String message) {
  return Future.delayed(oneSecond).then((_) {
    print(message);
  });
}

如下面的示例所示，async 和 await 有助于使异步代码易于阅读。

Future<void> createDescriptions(Iterable<String> objects) async {
  for (final object in objects) {
    try {
      var file = File('$object.txt');
      if (await file.exists()) {
        var modified = await file.lastModified();
        print(
          'File for $object already exists. It was modified on $modified.',
        );
        continue;
      }
      await file.create();
      await file.writeAsString('Start describing $object in this file.');
    } on IOException catch (e) {
      print('Cannot create description for $object: $e');
    }
  }
}

你还可以使用 async*，它为构建流提供了一种简洁、易读的方式。

Stream<String> report(Spacecraft craft, Iterable<String> objects) async* {
  for (final object in objects) {
    await Future.delayed(oneSecond);
    yield '${craft.name} flies by $object';
  }
}

异常

若要抛出异常，请使用 throw：

if (astronauts == 0) {
  throw StateError('No astronauts.');
}

若要捕获异常，请使用带有 on 或 catch（或两者都有）的 try 语句：

Future<void> describeFlybyObjects(List<String> flybyObjects) async {
  try {
    for (final object in flybyObjects) {
      var description = await File('$object.txt').readAsString();
      print(description);
    }
  } on IOException catch (e) {
    print('Could not describe object: $e');
  } finally {
    flybyObjects.clear();
  }
}

请注意，上述代码是异步的；在异步函数中，try 对同步和异步代码都有效。

重要概念

在继续学习 Dart 语言时，请牢记以下事实和概念：

1. 可以放在变量中的一切都是对象，每个对象都是类的实例。即使是数字、函数和 null 也是对象。除了 null（如果你启用了健全的空安全特性）之外，所有对象都继承自 Object 类。

   版本说明：空安全特性在 Dart 2.12 中引入。使用空安全特性需要至少 2.12 的语言版本。

2. 尽管 Dart 是强类型语言，但类型注解是可选的，因为 Dart 可以进行类型推断。在 var number = 101 中，number 会被推断为 int 类型。

3. 如果你启用了空安全特性，变量默认不能包含 null，除非你明确允许。你可以在类型末尾加上问号（?）使变量可为空。例如，int? 类型的变量可能是一个整数，也可能是 null。如果你知道一个表达式永远不会求值为 null，但 Dart 不这么认为，你可以添加 ! 来断言它不为 null（如果为 null 则抛出异常）。例如：int x = nullableButNotNullInt!

4. 当你想显式表示允许任何类型时，可以使用 Object? 类型（如果你启用了空安全特性）、Object 类型，或者——如果你必须将类型检查推迟到运行时——使用特殊类型 dynamic。

5. Dart 支持泛型类型，如 List<int>（整数列表）或 List<Object>（任何类型对象的列表）。

6. Dart 支持顶级函数（如 main()），以及与类或对象关联的函数（分别为静态方法和实例方法）。你还可以在函数内部创建函数（嵌套或局部函数）。

7. 同样，Dart 支持顶级变量，以及与类或对象关联的变量（静态变量和实例变量）。实例变量有时也称为字段或属性。

8. 与 Java 不同，Dart 没有 public、protected 和 private 关键字。如果一个标识符以下划线（_）开头，那么它在其所在的库中是私有的。详细信息请参阅“库和导入”。

9. 标识符可以以字母或下划线（_）开头，后面可以跟这些字符和数字的任意组合。

10. Dart 既有表达式（具有运行时值），也有语句（没有运行时值）。例如，条件表达式 condition ? expr1 : expr2 的值为 expr1 或 expr2。与之相比，if - else 语句没有值。语句通常包含一个或多个表达式，但表达式不能直接包含语句。

11. Dart 工具可以报告两种类型的问题：警告和错误。警告只是表明你的代码可能无法正常工作，但不会阻止程序执行。错误可以是编译时错误或运行时错误。编译时错误会阻止代码执行；运行时错误会在代码执行时引发异常。

参考

Dart官方文档