示例代码

这里的示例并不全面—它只是为那些喜欢通过示例了解语言的人提供一个语言的介绍。你可能还希望阅读语言概览和库概览。

语言概览

包含示例的 Dart 语言综合概览。文中多数的阅读更多会跳转到此概览。

库概览

基于示例的 Dart 核心库简介。通过概览可以了解内置类型，集合，日期和时间，stream 等的使用方法。

Hello World

每个 app 都有一个 main() 函数。使用顶级函数 print() 将文字输出到控制台。

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

变量

虽然 Dart 代码是类型安全的，但是由于支持类型推断，大多数变量是不需要显式指定类型的：

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 (var 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 通常使用 // 作为注释的开始。

// 这是一个标准的单行注释。

/// 这是一个文档注释，用来为库，类，以及它们的成员提供文档。
/// 像 IDEs 和 dartdoc 的工具会专门处理这些注释来生成文档。

/* 也支持类似的注释 */

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

Import

使用 import 来访问其他库中的 API 。

// 导入核心库
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;

  // 构造函数，使用语法糖设置成员变量。
  Spacecraft(this.name, this.launchDate) {
    // 这里编写初始化代码。
  }

  // 命名构造函数，最终调用默认构造函数。
  Spacecraft.unlaunched(String name) : this(name, null);

  int get launchYear =>
      launchDate?.year; // read-only non-final 属性

  // 方法。
  void describe() {
    print('Spacecraft: $name');
    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 ，重定向构造函数， factory 构造函数， getter 方法， setter 方法，以及更多类似部分。

扩展类（继承）

Dart 支持单继承。

class Orbiter extends Spacecraft {
  num altitude;
  Orbiter(String name, DateTime launchDate, this.altitude)
      : super(name, launchDate);
}

阅读更多关于类继承，可选的 @override 注解，以及其他内容。

Mixin

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

class Piloted {
  int astronauts = 1;
  void describeCrew() {
    print('Number of astronauts: $astronauts');
  }
}

将 mixin 的功能添加到一个类中，只需要继承这个类并 with 这个 mixin 。

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

现在 飞行器 有了 astronauts 字段以及 describeCrew() 方法。

阅读更多关于 mixin 的内容.

接口和抽象类

Dart 没有 interface 关键字。相反，所有的类都隐式定义了一个接口，因此，任意类都可以作为接口被实现。

class MockSpaceship implements Spacecraft {
  // ···
}

阅读更多关于隐式接口的内容。

创建一个抽象类，这个类可以被一个具体的类去扩展（或实现）。抽象类可以包含抽象方法（只声明未实现）。

abstract class Describable {
  void describe();

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

任意一个扩展了 Describable 的具体类都拥有 describeWithEmphasis() 方法，这个方法调用了具体类中实现的 describe() 。

阅读更多关于抽象类和方法的内容。

Async

避免回调地狱（callback hell），使用 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 (var 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 (var 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.');
}

使用 try 语句以及 on 和 catch（或者两者），捕获一个异常。

try {
  for (var 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 捕获异常。

阅读更多关于异常的内容，包括栈跟踪（ stack traces ）， rethrow ，以及 Error 和 Exception的区别。

其他主题

更多代码示例在语言概览和库概览中。另请参阅 Dart API reference，其中通常包含代码示例。

语言

库

平台

测试

资源