Dart 简介
本页面通过 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 注释通常以 //
开头。
// This is a normal, one-line comment.
/// This is a documentation comment, used to document libraries,
/// classes, and their members. Tools like IDEs and dartdoc treat
/// doc comments specially.
/* Comments like these are also supported. */
阅读更多关于 Dart 中注释的信息,包括文档工具的工作原理。
导入
#要访问在其他库中定义的 API,请使用 import
。
// Importing core libraries
import 'dart:math';
// Importing libraries from external packages
import 'package:test/test.dart';
// Importing files
import 'path/to/my_other_file.dart';
阅读更多关于 Dart 中库和可见性的信息,包括库前缀、show
和 hide
,以及通过 deferred
关键字进行延迟加载。
类
#这是一个类的示例,它有三个属性、两个构造函数和一个方法。其中一个属性不能直接设置,因此使用 getter 方法(而不是变量)定义。该方法使用字符串插值来打印字符串字面量中变量的字符串等效项。
class Spacecraft {
String name;
DateTime? launchDate;
// Read-only non-final property
int? get launchYear => launchDate?.year;
// Constructor, with syntactic sugar for assignment to members.
Spacecraft(this.name, this.launchDate) {
// Initialization code goes here.
}
// Named constructor that forwards to the default one.
Spacecraft.unlaunched(String name) : this(name, null);
// Method.
void describe() {
print('Spacecraft: $name');
// Type promotion doesn't work on getters.
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 that enumerates the different planets in our solar system
/// and some of their properties.
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);
/// A constant generating constructor
const Planet({
required this.planetType,
required this.moons,
required this.hasRings,
});
/// All instance variables are final
final PlanetType planetType;
final int moons;
final bool hasRings;
/// Enhanced enums support getters and other methods
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 是一种在多个类层次结构中重用代码的方式。以下是一个 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
#通过使用 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 的简洁、可读的方式。
Stream<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
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
语句在 async
函数中既适用于同步代码,也适用于异步代码。
阅读更多关于异常的信息,包括堆栈跟踪、rethrow
以及 Error
和 Exception
之间的区别。
重要概念
#当您继续学习 Dart 语言时,请记住以下事实和概念
您可以放入变量中的任何内容都是一个对象,而每个对象都是一个类的实例。即使是数字、函数和
null
也是对象。除了null
(如果您启用健全的空安全)之外,所有对象都继承自Object
类。尽管 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 语句进行比较,if-else 语句没有值。一个语句通常包含一个或多个表达式,但一个表达式不能直接包含一个语句。Dart 工具可以报告两种问题:警告和错误。警告只是表明您的代码可能无法工作,但它们不会阻止您的程序执行。错误可以是编译时错误或运行时错误。编译时错误会阻止代码完全执行;运行时错误会导致在代码执行时引发异常。
其他资源
#您可以在核心库文档和 Dart API 参考中找到更多文档和代码示例。本站点的代码遵循 Dart 风格指南中的约定。
除非另有说明,否则本站点上的文档反映的是 Dart 3.7.1 版本。页面最后更新于 2025-02-13。 查看源代码 或 报告问题。