本页面通过 Dart 语言主要特性的示例，为您提供该语言的简要介绍。

要深入了解 Dart 语言，请访问左侧菜单中“语言”部分下列出的各个主题页面。

关于 Dart 核心库的内容，请查阅核心库文档。您还可以查看 Dart 速查表，获取更具交互性的介绍。

Hello World

每个应用都需要顶级的 main() 函数，它是程序执行的起点。不显式返回值的函数使用 void 返回类型。若要在控制台显示文本，可使用顶级的 print() 函数：

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

阅读更多关于 Dart 中 main() 函数的内容，包括命令行参数的可选参数。

变量

即使在类型安全的 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 变量的内容，包括默认值、final 和 const 关键字以及静态类型。

控制流语句

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

阅读更多关于 Dart 控制流语句的内容，包括 break 和 continue、switch 和 case 以及 assert。

函数

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

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 函数的内容，包括可选参数、默认参数值和词法作用域。

注释

Dart 注释通常以 // 开头。

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

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

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

阅读更多关于 Dart 注释的内容，包括文档工具的工作原理。

导入

要使用其他库中定义的 API，可使用 import。

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

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

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

阅读更多关于 Dart 库和可见性的内容，包括库前缀、show 和 hide 以及通过 deferred 关键字实现的懒加载。

类

下面是一个类的示例，它有三个属性、两个构造函数和一个方法。其中一个属性不能直接设置，因此使用 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');
    }
  }
}

阅读更多关于字符串的内容，包括字符串插值、字面量、表达式和 toString() 方法。

您可以这样使用 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 枚举的内容，包括增强型枚举的要求、自动引入的属性、访问枚举值名称、switch 语句支持等等。

继承

Dart 支持单继承。

class Orbiter extends Spacecraft {
  double altitude;

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

阅读更多关于扩展类、可选的 @override 注解等内容。

Mixins

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

mixin Piloted {
  int astronauts = 1;

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

要将 mixin 的功能添加到类中，只需使用 mixin 扩展该类。

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

PilotedCraft 现在拥有 astronauts 字段和 describeCrew() 方法。

阅读更多关于 mixins 的内容。

接口和抽象类

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

class MockSpaceship implements Spacecraft {
  // ···
}

阅读更多关于隐式接口或显式 interface 关键字的内容。

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

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';
  }
}

阅读更多关于异步支持的内容，包括异步函数、Future、Stream 和异步循环（await for）。

异常

要抛出异常，使用 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 对同步和异步代码都有效。

阅读更多关于异常的内容，包括堆栈跟踪、rethrow 以及 Error 和 Exception 之间的区别。

重要概念

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

• 能放入变量的一切都是对象，每个对象都是类的实例。即使是数字、函数和 null 也是对象。除了 null（如果启用了健全的空安全），所有对象都继承自 Object 类。

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

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

• 如果启用空安全，变量不能包含 null，除非您明确允许。在类型末尾加问号（?），可使变量可为空。例如，int? 类型的变量可能是整数，也可能是 null。如果您知道某个表达式永远不会求值为 null，但 Dart 不认同，可添加 ! 断言它不为 null（若为 null 则抛出异常）。示例：int x = nullableButNotNullInt!

• 若想明确表示允许任何类型，使用 Object? 类型（如果启用了空安全）、Object，或者——如果必须将类型检查推迟到运行时——使用特殊类型 dynamic。

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

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

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

• 与 Java 不同，Dart 没有 public、protected 和 private 关键字。如果标识符以下划线（_）开头，则对其库是私有的。详情见“库和导入”。

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

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

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

其他资源

您可以在核心库文档和 Dart API 参考中找到更多文档和代码示例。本网站的代码遵循 Dart 风格指南中的约定。