Dart 简介

目录 keyboard_arrow_down keyboard_arrow_up

Hello World
变量
控制流语句
函数
注释
导入
类
枚举
继承
Mixin
接口和抽象类
异步
异常
重要概念
附加资源

more_horiz

本页面通过示例介绍 Dart 语言的主要特性。

要深入了解 Dart 语言，请访问左侧菜单“语言”下列出的详细主题页面。

有关 Dart 核心库的介绍，请查看核心库文档。您还可以查看 Dart 速查表，以获得更具交互性的介绍。

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

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

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

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

dartvar 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 支持常用的控制流语句：

dartif (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 。

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

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

var result = fibonacci(20);

对于包含单个语句的函数， => （箭头）简写语法非常方便。当将匿名函数作为参数传递时，此语法尤其有用：

dart

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

除了显示匿名函数（ where() 的参数）之外，此代码还显示您可以将函数用作参数：顶级 print() 函数是 forEach() 的参数。

阅读更多关于 Dart 中函数的信息，包括可选参数、默认参数值和词法作用域。

Dart 注释通常以 // 开头。

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

/// 这是一个文档注释，用于记录库、类及其成员。IDE 和 dartdoc 等工具会特殊处理文档注释。

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

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

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

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

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

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

阅读更多关于 Dart 中库和可见性的信息，包括库前缀、 show 和 hide 以及通过 deferred 关键字进行延迟加载。

这是一个具有三个属性、两个构造函数和一个方法的类的示例。其中一个属性不能直接设置，因此它是使用 getter 方法（而不是变量）定义的。该方法使用字符串插值在字符串文字内打印变量的字符串等效项。

dartclass 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 类：

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

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

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

枚举是一种枚举预定义值或实例集的方法，它确保不能存在该类型的任何其他实例。

这是一个简单的 enum 示例，它定义了一个简单的预定义行星类型的列表：

dart

enum PlanetType { terrestrial, gas, ice }

这是一个描述行星的类的增强型枚举声明示例，它定义了一组常量实例，即我们太阳系中的行星。

dart/// 枚举我们太阳系中不同的行星及其一些属性。
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 枚举：

dartfinal yourPlanet = Planet.earth;

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

阅读更多关于 Dart 中枚举的信息，包括增强型枚举的要求、自动引入的属性、访问枚举值名称、switch 语句支持等等。

Dart 支持单继承。

dartclass Orbiter extends Spacecraft {
  double altitude;

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

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

Mixin 是一种在多个类层次结构中重用代码的方法。以下是 mixin 声明：

dartmixin Piloted {
  int astronauts = 1;

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

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

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

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

阅读更多关于 mixin 的信息。

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

dartclass MockSpaceship implements Spacecraft {
  // ···
}

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

您可以创建一个抽象类，以便由具体的类扩展（或实现）。抽象类可以包含抽象方法（具有空主体）。

dartabstract class Describable {
  void describe();

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

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

阅读更多关于抽象类和方法的信息。

通过使用 async 和 await ，避免回调地狱并使您的代码更具可读性。

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

上面的方法等同于：

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

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

dartFuture<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* ，它为您提供了一种简洁易读的构建流的方法。

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

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

要引发异常，请使用 throw ：

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

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

dartFuture<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 适用于同步代码和 async 函数中的代码。

阅读更多关于异常的信息，包括堆栈跟踪、 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 样式指南中的约定。

除非另有说明，否则本网站上的文档反映的是 Dart 3.6.0。页面最后更新于 2025-02-05。查看源代码或报告问题.

Dart 简介

Hello World

变量

控制流语句

函数

注释

导入

类

枚举

继承

Mixin

接口和抽象类

异步

异常

重要概念

附加资源