函数 Function

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 是否属于惰性气体范围。

参数

函数可以有任意数量的 必需位置 参数。这些参数后面可以跟 命名 参数或 可选位置 参数（但不能同时跟两者）。 向函数传递参数或定义函数参数时，可以使用尾随逗号。

命名参数 Named parameters

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

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

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

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

enableFlags(bold: true, hidden: false);

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

/// 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 对其进行注释：

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

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

标记为的参数required仍然可以为空 const Scrollbar({super.key, required Widget? child});

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

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

可选的位置参数 Optional positional parameters

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

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() 函数返回值为空，参数为一个可选的 List<String> 。

一个简单的 main() 函数：

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

以下是带有参数的命令行应用程序的 main() 函数的示例：

// 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 library来定义和解析命令行参数。

函数是一等对象  first-class objects

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

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

var list = [1, 2, 3];

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

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

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

示例中使用了匿名函数。 下一章节会有更多介绍。

匿名函数 Anonymous

多数函数是有名字的， 比如 main() 和 printElement()。 也可以创建没有名字的函数，这种函数被称为 匿名函数， lambda 或者 closure 。

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

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

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

后面大括号中的代码为函数体：

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

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

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

如果函数只有一条语句， 可以使用箭头简写。两个函数是等价的。

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

词法作用域 Lexical scope

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()方法可以使用来自各个级别的变量，一直到顶层。

词法闭包 Lexical closures

当函数位于词法作用域之外时，可以访问其词法作用域内的变量的函数对象称为闭包。 函数可以关闭周围范围中定义的变量。在以下示例中，makeAdder() 捕获变量 addBy。无论返回的函数走到哪里，它都会记住 addBy。

/// 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);
}

分离式 Tear-offs

当引用不带括号的函数、方法或命名构造函数时，Dart 会创建一个 分离式 。这是一个闭包，它接受与函数相同的参数，并在您调用它时调用底层函数。如果需要一个闭包来调用具有与闭包接受的相同参数的命名函数，不要将调用包装在 lambda 中。而是使用分离式。

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

good
// Function tear-off
charCodes.forEach(print);

// Method tear-off
charCodes.forEach(buffer.write);

bad
// Function lambda
charCodes.forEach((code) {
  print(code);
});

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

函数相等

下面是测试顶级函数、静态方法和实例方法是否相等的示例：

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

foo() {}

assert(foo() == null);

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

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

生成器 Generators

当需要延迟生成一系列值时，考虑使用生成器函数。 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在函数声明前添加关键字，如下所示：

external void someFunc(int i);

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

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