函数

目录 keyboard_arrow_down keyboard_arrow_up

参数
- 命名参数
- 可选位置参数
main() 函数
函数作为一等对象
函数类型
匿名函数
词法作用域
词法闭包
撕裂函数 (Tear-offs)
测试函数的相等性
返回值
生成器
外部函数

more_horiz

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

以下是如何实现函数的示例：

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

尽管 Effective Dart 建议对公共 API 使用类型注解，但省略类型后函数仍然可以工作：

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

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

dart

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

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

函数可以具有任意数量的 必需位置 参数。这些参数之后可以是命名参数或 可选位置 参数（但不能同时是两者）。

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

命名参数是可选的，除非它们被明确标记为 required 。

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

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

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

dart

enableFlags(bold: true, hidden: false);

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

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

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

如果您希望命名参数是必需的，要求调用者为该参数提供值，请使用 required 对其进行注释：

dart

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

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

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

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

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

dartString 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');

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

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

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

dartString 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() 函数返回 void ，并具有一个可选的 List<String> 参数用于参数。

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

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

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

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

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

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

var list = [1, 2, 3];

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

您还可以将函数赋值给变量，例如：

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

此示例使用匿名函数。下一节将详细介绍这些内容。

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

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

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

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

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

零个或多个参数，用逗号分隔
圆括号之间的可选类型注解

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

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

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

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

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

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();
  // 映射后转换为列表

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

如果函数只包含单个表达式或 return 语句，则可以使用箭头表示法将其简短。将以下行粘贴到 DartPad 中并单击运行以验证它在功能上是等效的。

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

Dart 根据其代码的布局确定变量的作用域。具有此功能的编程语言被称为词法作用域语言。您可以“向外跟随大括号”查看变量是否在作用域内。

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

dartbool 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/// 返回一个函数，该函数将 [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 会创建一个 撕裂函数 。这是一个闭包，它接受与函数相同的参数，并在您调用它时调用底层函数。如果您的代码需要一个闭包来调用具有与闭包接受的参数相同的参数的命名函数，请不要将调用包装在 lambda 中。使用撕裂函数。

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

gooddart// 函数撕裂函数
charCodes.forEach(print);

// 方法撕裂函数
charCodes.forEach(buffer.write);

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

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

以下是如何测试顶级函数、静态方法和实例方法的相等性的示例：

dartvoid 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; 会隐式附加到函数体中。

dartfoo() {}

assert(foo() == null);

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

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

当您需要惰性地生成一系列值时，请考虑使用 生成器函数 。Dart 内置支持两种生成器函数：

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

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

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

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

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

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

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

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

dart

external void someFunc(int i);

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

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

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

函数

参数

命名参数

可选位置参数

main() 函数

函数作为一等对象

函数类型

匿名函数

词法作用域

词法闭包

撕裂函数 (Tear-offs)

测试函数的相等性

返回值

生成器

外部函数