函数
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; } 的简写。=> 符号有时被称为箭头语法。
参数
#函数可以有任意数量的必需位置参数。这些参数后面可以跟命名参数或可选位置参数（但不能同时出现）。
在向函数传递参数或定义函数参数时，可以使用尾随逗号。
命名参数
#命名参数是可选的，除非它们被明确标记为 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 参数的情况下创建 Scrollbar，分析器将报告问题。
你可能希望将位置参数放在前面，但 Dart 不要求这样做。Dart 允许命名参数在参数列表中的任何位置，以适应你的 API 需求：
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() 函数示例：
// 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 库来定义和解析命令行参数。
函数作为一等对象
#你可以将函数作为参数传递给另一个函数。例如：
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 !!!');此示例使用匿名函数。更多内容请参阅下一节。
函数类型
#你可以指定函数的类型，这被称为函数类型。函数类型是通过将函数声明头中的函数名替换为关键字 Function 来获得的。此外，你可以省略位置参数的名称，但命名参数的名称不能省略。例如：
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 或闭包。
匿名函数类似于命名函数，因为它具有：
- 零个或多个参数，以逗号分隔。
- 括号内可选的类型注解。
以下代码块包含函数体：
([[Type] param1[, ...]]) {
codeBlock;
}以下示例定义了一个带有未类型化参数 item 的匿名函数。该匿名函数将其传递给 map 函数。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}');
}点击运行执行代码。
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 中并点击运行以验证其功能等效性。
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。
/// 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 会创建一个 tear-off。这是一个闭包，它接受与该函数相同的参数，并在你调用它时调用底层函数。如果你的代码需要一个闭包，它调用一个与闭包接受相同参数的命名函数，请不要将调用封装在 lambda 中。使用 tear-off。
var charCodes = [68, 97, 114, 116];
var buffer = StringBuffer();// Function tear-off
charCodes.forEach(print);
// Method tear-off
charCodes.forEach(buffer.write);// 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);
}生成器
#当你需要延迟生成一系列值时，考虑使用生成器函数。Dart 内置支持两种生成器函数：
要实现同步生成器函数，请将函数体标记为 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，或非重定向构造函数。实例变量也可以是 external，这相当于一个外部 getter 和（如果变量不是 final）一个外部 setter。