目录

函数

Dart 是一种真正的面向对象语言,因此即使函数也是对象,并且具有类型,Function。这意味着可以将函数分配给变量或作为参数传递给其他函数。您还可以像调用函数一样调用 Dart 类的实例。有关详细信息,请参阅可调用对象

以下是实现函数的示例

dart
bool isNoble(int atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

尽管有效的 Dart 建议对公共 API 进行类型注释,但如果省略类型,函数仍然有效

dart
isNoble(atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

对于仅包含一个表达式的函数,可以使用简写语法

dart
bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;

=> expr 语法是 { return expr; } 的简写形式。=> 表示法有时被称为箭头语法。

参数

#

一个函数可以有任意数量的必需的位置参数。这些参数后面可以跟命名参数或可选的位置参数(但不能同时跟两者)。

当您将参数传递给函数或定义函数参数时,可以使用尾随逗号

命名参数

#

命名参数是可选的,除非它们被显式标记为 required

定义函数时,使用 {param1, param2, …} 指定命名参数。如果您不提供默认值或将命名参数标记为 required,则它们的类型必须可为空,因为它们的默认值将为 null

dart
/// Sets the [bold] and [hidden] flags ...
void enableFlags({bool? bold, bool? hidden}) {...}

调用函数时,可以使用 paramName: value 指定命名参数。例如

dart
enableFlags(bold: true, hidden: false);

要为命名参数定义除 null 以外的默认值,请使用 = 指定默认值。指定的值必须是编译时常量。例如

dart
/// Sets the [bold] and [hidden] flags ...
void enableFlags({bool bold = false, bool hidden = false}) {...}

// bold will be true; hidden will be false.
enableFlags(bold: true);

如果您希望命名参数是强制性的,要求调用者为该参数提供值,请使用 required 注释它们

dart
const Scrollbar({super.key, required Widget child});

如果有人尝试创建 Scrollbar 而不指定 child 参数,则分析器会报告问题。

您可能希望将位置参数放在前面,但 Dart 不要求这样做。当适合您的 API 时,Dart 允许将命名参数放置在参数列表中的任何位置

dart
repeat(times: 2, () {
  ...
});

可选位置参数

#

将一组函数参数包装在 [] 中会将它们标记为可选的位置参数。如果您不提供默认值,则它们的类型必须可为空,因为它们的默认值将为 null

dart
String say(String from, String msg, [String? device]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}

以下是在没有可选参数的情况下调用此函数的示例

dart
assert(say('Bob', 'Howdy') == 'Bob says Howdy');

以下是使用第三个参数调用此函数的示例

dart
assert(say('Bob', 'Howdy', 'smoke signal') ==
    'Bob says Howdy with a smoke signal');

要为除 null 以外的可选位置参数定义默认值,请使用 = 指定默认值。指定的值必须是编译时常量。例如

dart
String say(String from, String msg, [String device = 'carrier pigeon']) {
  var result = '$from says $msg with a $device';
  return result;
}

assert(say('Bob', 'Howdy') == 'Bob says Howdy with a carrier pigeon');

main() 函数

#

每个应用都必须有一个顶级的 main() 函数,该函数充当应用的入口点。main() 函数返回 void,并且有一个可选的 List<String> 参数用于参数。

这是一个简单的 main() 函数

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

以下是一个命令行应用的 main() 函数示例,该函数接受参数

args.dart
dart
// Run the app like this: dart run args.dart 1 test
void main(List<String> arguments) {
  print(arguments);

  assert(arguments.length == 2);
  assert(int.parse(arguments[0]) == 1);
  assert(arguments[1] == 'test');
}

您可以使用 args 库 来定义和解析命令行参数。

函数作为一等对象

#

您可以将函数作为参数传递给另一个函数。例如

dart
void printElement(int element) {
  print(element);
}

var list = [1, 2, 3];

// Pass printElement as a parameter.
list.forEach(printElement);

您还可以将函数分配给变量,例如

dart
var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';
assert(loudify('hello') == '!!! HELLO !!!');

此示例使用匿名函数。有关这些内容的更多信息,请参见下一节。

函数类型

#

您可以指定函数的类型,这称为函数类型。函数类型是通过将函数声明头中的函数名称替换为关键字 Function 来获得的。此外,您可以省略位置参数的名称,但不能省略命名参数的名称。例如

dart
void greet(String name, {String greeting = 'Hello'}) =>
    print('$greeting $name!');

// Store `greet` in a variable and call it.
void Function(String, {String greeting}) g = greet;
g('Dash', greeting: 'Howdy');

匿名函数

#

尽管您命名大多数函数,例如 main()printElement(),但您也可以创建没有名称的函数。这些函数称为匿名函数lambda闭包

匿名函数类似于命名函数,因为它具有

  • 零个或多个参数,以逗号分隔
  • 括号之间的可选类型注释。

以下代码块包含函数的主体

dart
([[Type] param1[, ...]]) {
  codeBlock;
}

以下示例定义了一个带有未类型化参数 item 的匿名函数。该匿名函数将其传递给 map 函数。对于列表中的每个项,都会调用 map 函数,将每个字符串转换为大写。然后,传递给 forEach 的匿名函数会打印每个转换后的字符串及其长度。

dart
const list = ['apples', 'bananas', 'oranges'];

var uppercaseList = list.map((item) {
  return item.toUpperCase();
}).toList();
// Convert to list after mapping

for (var item in uppercaseList) {
  print('$item: ${item.length}');
}

点击 运行 执行代码。

void main() {
  const list = ['apples', 'bananas', 'oranges'];

  var uppercaseList = list.map((item) {
    return item.toUpperCase();
  }).toList();
  // Convert to list after mapping

  for (var item in uppercaseList) {
    print('$item: ${item.length}');
  }
}

如果函数仅包含单个表达式或 return 语句,则可以使用箭头符号缩短它。将以下行粘贴到 DartPad 中,然后点击 运行 以验证其功能是否等效。

dart
var uppercaseList = list.map((item) => item.toUpperCase()).toList();
uppercaseList.forEach((item) => print('$item: ${item.length}'));

词法作用域

#

Dart 根据代码的布局确定变量的作用域。具有此特性的编程语言被称为词法作用域语言。你可以“向外追踪花括号”来查看变量是否在作用域内。

示例: 一系列嵌套函数,在每个作用域级别都有变量

dart
bool topLevel = true;

void main() {
  var insideMain = true;

  void myFunction() {
    var insideFunction = true;

    void nestedFunction() {
      var insideNestedFunction = true;

      assert(topLevel);
      assert(insideMain);
      assert(insideFunction);
      assert(insideNestedFunction);
    }
  }
}

nestedFunction() 方法可以使用从每个级别到顶层的所有变量。

词法闭包

#

当函数位于其作用域之外时,可以访问其词法作用域中的变量的函数对象称为闭包

函数可以闭包周围作用域中定义的变量。在以下示例中,makeAdder() 捕获了变量 addBy。无论返回的函数去哪里,它都会记住 addBy

dart
/// Returns a function that adds [addBy] to the
/// function's argument.
Function makeAdder(int addBy) {
  return (int i) => addBy + i;
}

void main() {
  // Create a function that adds 2.
  var add2 = makeAdder(2);

  // Create a function that adds 4.
  var add4 = makeAdder(4);

  assert(add2(3) == 5);
  assert(add4(3) == 7);
}

脱落

#

当你引用函数、方法或命名构造函数而不使用括号时,Dart 会创建一个tear-off。这是一个闭包,它接受与函数相同的参数,并在你调用它时调用底层函数。如果你的代码需要一个闭包来调用与闭包接受相同参数的命名函数,请不要将调用包装在 lambda 中。使用 tear-off。

dart
var charCodes = [68, 97, 114, 116];
var buffer = StringBuffer();
dart
// Function tear-off
charCodes.forEach(print);

// Method tear-off
charCodes.forEach(buffer.write);
dart
// Function lambda
charCodes.forEach((code) {
  print(code);
});

// Method lambda
charCodes.forEach((code) {
  buffer.write(code);
});

测试函数的相等性

#

以下是一个测试顶层函数、静态方法和实例方法是否相等性的示例

dart
void foo() {} // A top-level function

class A {
  static void bar() {} // A static method
  void baz() {} // An instance method
}

void main() {
  Function x;

  // Comparing top-level functions.
  x = foo;
  assert(foo == x);

  // Comparing static methods.
  x = A.bar;
  assert(A.bar == x);

  // Comparing instance methods.
  var v = A(); // Instance #1 of A
  var w = A(); // Instance #2 of A
  var y = w;
  x = w.baz;

  // These closures refer to the same instance (#2),
  // so they're equal.
  assert(y.baz == x);

  // These closures refer to different instances,
  // so they're unequal.
  assert(v.baz != w.baz);
}

返回值

#

所有函数都会返回值。如果没有指定返回值,则语句 return null; 会隐式追加到函数体中。

dart
foo() {}

assert(foo() == null);

要在函数中返回多个值,请将这些值聚合到记录中。

dart
(String, int) foo() {
  return ('something', 42);
}

生成器

#

当需要延迟生成一系列值时,请考虑使用生成器函数。Dart 内置支持两种类型的生成器函数

  • 同步生成器:返回一个 Iterable 对象。
  • 异步生成器:返回一个 Stream 对象。

要实现同步生成器函数,请将函数体标记为 sync*,并使用 yield 语句传递值

dart
Iterable<int> naturalsTo(int n) sync* {
  int k = 0;
  while (k < n) yield k++;
}

要实现异步生成器函数,请将函数体标记为 async*,并使用 yield 语句传递值

dart
Stream<int> asynchronousNaturalsTo(int n) async* {
  int k = 0;
  while (k < n) yield k++;
}

如果你的生成器是递归的,则可以使用 yield* 来提高其性能

dart
Iterable<int> naturalsDownFrom(int n) sync* {
  if (n > 0) {
    yield n;
    yield* naturalsDownFrom(n - 1);
  }
}

外部函数

#

外部函数是其主体与声明分开实现的函数。在函数声明之前包含 external 关键字,如下所示

dart
external void someFunc(int i);

外部函数的实现可以来自另一个 Dart 库,或者更常见的是来自另一种语言。在互操作上下文中,external 为外部函数或值引入类型信息,使其可在 Dart 中使用。实现和用法高度依赖于平台,因此请查看有关例如 CJavaScript 的互操作文档以了解更多信息。

外部函数可以是顶层函数、实例方法getter 或 setter,或者非重定向构造函数实例变量也可以是 external,它等效于外部 getter 和(如果该变量不是 final)外部 setter。