Dart 函数

函数介绍

Dart 是一门真正的面向对象语言，因此即使是函数也是对象，并且有自己的类型 Function。这意味着函数可以赋值给变量，也可以作为参数传递给其他函数。你还可以像调用函数一样调用 Dart 类的实例。详情请参阅“可调用对象”。

以下是一个实现函数的示例：

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

尽管《Effective Dart》建议为公共 API 添加类型注解，但如果你省略类型，函数仍然可以正常工作：

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

对于只包含一个表达式的函数，你可以使用简写语法：

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

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

注意： 只有表达式可以出现在箭头 (=>) 和分号 (;) 之间。表达式会计算出一个值。这意味着在 Dart 期望一个值的地方，你不能写语句。例如，你可以使用条件表达式，但不能使用 if 语句。在前面的示例中，_nobleGases[atomicNumber] != null; 返回一个布尔值。然后该函数返回一个布尔值，用于指示 atomicNumber 是否属于惰性气体的范围。

函数语法

参数

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

注意： 有些 API（尤其是 Flutter 小部件构造函数）即使对于必需的参数也只使用命名参数。详情请参阅下一节。

在向函数传递参数或定义函数参数时，可以使用尾随逗号。

命名参数

命名参数是可选的，除非它们被显式标记为必需。

定义函数时，使用 {param1, param2, …} 来指定命名参数。如果你没有提供默认值，也没有将命名参数标记为必需，那么它们的类型必须是可空的，因为它们的默认值将是 null：

/// 设置 [bold] 和 [hidden] 标志 ...
void enableFlags({bool? bold, bool? hidden}) {
  ...
}

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

enableFlags(bold: true, hidden: false);

若要为命名参数定义除 null 之外的默认值，可以使用 = 来指定默认值。指定的值必须是编译时常量。例如：

/// 设置 [bold] 和 [hidden] 标志 ...
void enableFlags({bool bold = false, bool hidden = false}) {
  ...
}

// bold 将为 true；hidden 将为 false。
enableFlags(bold: true);

如果你希望某个命名参数是必需的，要求调用者为该参数提供一个值，可以使用 required 进行注解：

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

如果有人试图在不指定 child 参数的情况下创建 Scrollbar，分析器会报告问题。

注意： 标记为 required 的参数仍然可以是可空的：

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

你可能想先放置位置参数，但 Dart 并不强制要求这样做。当符合你的 API 设计时，Dart 允许命名参数放在参数列表的任何位置：

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

可选位置参数

将一组函数参数用 [] 括起来，可将它们标记为可选位置参数。如果你没有提供默认值，它们的类型必须是可空的，因为它们的默认值将是 null：

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

以下是不使用可选参数调用此函数的示例：

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

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

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

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

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() 函数：

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

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

// 像这样运行应用程序：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 库来定义和解析命令行参数。

函数作为一等公民对象

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

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

var list = [1, 2, 3];

// 将 printElement 作为参数传递。
list.forEach(printElement);

你还可以将一个函数赋值给一个变量，例如：

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

这个示例使用了匿名函数。下一节将详细介绍匿名函数。

函数类型

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

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

// 将 `greet` 存储在变量中并调用它。
void Function(String, {String greeting}) g = greet;
g('Dash', greeting: 'Howdy');

注意： 在 Dart 中，函数是一等公民对象，这意味着它们可以赋值给变量、作为参数传递，也可以从其他函数返回。

你可以使用 typedef 声明来显式命名函数类型，这有助于提高代码的清晰度和可复用性。

匿名函数

尽管大多数函数都有名称，例如 main() 或 printElement()，但你也可以创建没有名称的函数。这些函数被称为匿名函数、lambda 函数或闭包。

匿名函数与命名函数类似，它有：

• 零个或多个用逗号分隔的参数
• 括号内可选的类型注解

以下代码块包含函数体：

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

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

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

var uppercaseList =
    list.map((item) {
      return item.toUpperCase();
    }).toList();
// 映射后转换为列表

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

点击“运行”来执行代码。

如果函数只包含一个表达式或返回语句，你可以使用箭头表示法来简化它。将以下代码粘贴到 DartPad 中，点击“运行”以验证其功能是否等效。

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

词法作用域

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 的值。

/// 返回一个函数，该函数将 [addBy] 加到其参数上。
Function makeAdder(int addBy) {
  return (int i) => addBy + i;
}

void main() {
  // 创建一个加 2 的函数。
  var add2 = makeAdder(2);

  // 创建一个加 4 的函数。
  var add4 = makeAdder(4);

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

函数剥离

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

var charCodes = [68, 97, 114, 116];
var buffer = StringBuffer();

// 函数剥离
charCodes.forEach(print);

// 方法剥离
charCodes.forEach(buffer.write);

// 函数 lambda
charCodes.forEach((code) {
  print(code);
});

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

函数相等性测试

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

void foo() {} // 一个顶层函数

class A {
  static void bar() {} // 一个静态方法
  void baz() {} // 一个实例方法
}

void main() {
  Function x;

  // 比较顶层函数。
  x = foo;
  assert(foo == x);

  // 比较静态方法。
  x = A.bar;
  assert(A.bar == x);

  // 比较实例方法。
  var v = A(); // A 的实例 #1
  var w = A(); // A 的实例 #2
  var y = w;
  x = w.baz;

  // 这些闭包引用同一个实例（#2），
  // 所以它们相等。
  assert(y.baz == x);

  // 这些闭包引用不同的实例，
  // 所以它们不相等。
  assert(v.baz != w.baz);
}

返回值

所有函数都会返回一个值。如果没有指定返回值，return null; 语句会被隐式添加到函数体末尾。

foo() {}

assert(foo() == null);

若要在一个函数中返回多个值，可以将这些值聚合到一个记录中。

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

生成器

当你需要按需懒生成一系列值时，可以考虑使用生成器函数。Dart 对两种类型的生成器函数提供了内置支持：

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

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

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

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

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

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

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

外部函数

外部函数是指其函数体的实现与其声明分离的函数。在函数声明前加上 external 关键字，如下所示：

external void someFunc(int i);

外部函数的实现可以来自另一个 Dart 库，或者更常见的是来自另一种语言。在互操作性上下文中，external 为外部函数或值引入类型信息，使其可以在 Dart 中使用。实现和使用方式在很大程度上取决于具体平台，因此请查阅有关 C 或 JavaScript 等的互操作性文档以了解更多信息。

外部函数可以是顶层函数、实例方法、getter 或 setter，也可以是非重定向构造函数。实例变量也可以是外部的，这相当于一个外部 getter 和（如果该变量不是 final 的）一个外部 setter。

参考

Dart官方文档