Dart 函数

Dart 是一门真正面向对象的语言， 甚至其中的函数也是对象，并且有它的类型 Function 。 这也意味着函数可以被赋值给变量或者作为参数传递给其他函数。 也可以把 Dart 类的实例当做方法来调用

简单实现函数的例子

main(List<String> args) {
  List<int> myList = List<int>(3);
  //因为是固定长度，不可以再增加值
  myList[0] =1;
  // myList.add(1);
  // myList.add(2);
  // myList.add(3);
  // List myList = [1, 2, 3];

  bool isNumber(int index) {
    return myList[index] != null;
  }
 
  print(myList.length);
  print(myList[0]);
  print(isNumber(0));

}

尽管Effective Dart建议对公共api使用类型注释，但是如果您省略了类型，这个函数仍然可以工作:

isNumber(int index) {
  return myList[index] != null;
}

箭头函数

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

bool isNumber(int index) => myList[index] != null;

=>expression 语法是{return expression;}的简写写法。=>符号有时被称为胖箭头语法 ⚠️注意: 在箭头(=>)和分号(;)之间只能出现一个表达式(不是语句)。例如，您不能在那里放一个if语句，但是您可以使用一个条件表达式(三元表达式)

参数

函数可以有两种类型的参数:必要参数 和 可选参数

• 必要参数定义在参数列表前面
• 可选参数则定义在必要参数后面
  • 可选参数可以是 命名参数 或 位置参数,但不能两者都是
  • 命名可选参数也可以标记为**@required**

可选的命名参数

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

enableFlags(bold: true, hidden: false);

在定义函数时，使用{type param [,type2 param2]}来指定命名参数:

/// 设置 [bold] 和 [hidden] 标识…… Sets the [bold] and [hidden] flags...
main(List<String> args) {
  void enableFlags(name, {bool bold, bool hidden}) { print(name); }
  enableFlags("张三", bold: true);
}

Flutter实例创建表达式可能会变得复杂，因此小部件构造函数只使用命名参数。这使得实例创建表达式更容易阅读

@required 必传参数 在任何Dart代码(不仅仅是Flutter)中注释一个已命名的参数，并使用@required说明它是一个必传的参数。例如:

import 'package:meta/meta.dart';

class Scrollbar {
  Scrollbar({Key key, @required Widget child}) {}
}

void main(List<String> args) {}

如果调用者想要通过 Scrollbar 的构造函数构造一个 Scrollbar 对象而不提供 child 参数，则会导致编译错误 @required 注解定义在 meta 包中，可以直接导入 package:meta/meta.dart 包使用

位置参数

使用 []将一系列参数包裹起来作为位置参数：

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


main(List<String> args) {
  //下面是不使用可选参数调用上述函数的示例：
  assert(say('Bob', 'Howdy') == 'Bob says Howdy');
	
  //下面是使用可选参数调用上述函数的示例：
  assert(say('Bob', 'Howdy', 'smoke signal') ==
    'Bob says Howdy with a smoke signal');
}

⚠️** 注意: **不能同时使用可选的位置参数和可选的命名参数

默认参数值

可以用=为函数的命名参数或位置参数定义默认值，默认值必须为编译时常量，没有指定默认值时默认为null 下面是设置可选参数默认值示例：

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

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

在老版本的 Dart 代码中会使用冒号:而不是=来设置命名参数的默认值。原因在于刚开始的时候命名参数只支持:。不过现在这个支持已经过时，所以我们建议你现在都使用=来指定默认值

下一个示例将向你展示如何为位置参数设置默认值：

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

main(List<String> args) {
assert(say('Bob', 'Howdy') == 'Bob says Howdy with a carrier pigeon');
}

List 或 Map 同样也可以作为默认值。下面的示例定义了一个名为doStuff() 的函数，并为其名为 list 和 gifts 的参数指定了一个 List 类型的值和 Map 类型的值。

void doStuff({
    Key key,
    List<int> list = const [1, 2, 3],
    Map<String, String> gifts = const {
      'first': 'paper',
      'second': 'cotton',
      'third': 'leather'
    }}) {
  print('list:  $list');
  print('gifts: $gifts');
}

main() 函数

每个 Dart 程序都必须有一个main() 顶级函数作为程序的入口

• main()函数返回值为 void,可省略
• 并且有一个 List<String> 类型的可选参数

下面是一个 Web 应用的 main() 函数示例：

void main(List<String> args) {
    querySelector('#sample_text_id')
    ..text = 'Click me!'
    ..onClick.listen(reverseText);
}

备忘:上述代码中的 ..语法称之为 级联调用。使用级联访问可以在一个对象上执行多个操作

下面是使用命令行访问带参数的 main() 函数示例：

// dart main.dart 1 2 3 test 使用前面的命令运行该应用
void main(List<String> arguments) {
  print(arguments);
  assert(arguments.length == 4);
  assert(int.parse(arguments[0]) == 1);
  assert(arguments[4] == 'test');
}

你可以通过使用 参数库 来定义和解析命令行参数

函数作为一级对象

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

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

var list = [1, 2, 3];

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

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

main(List<String> args) {
  var loudify = (msg) => '${msg.toUpperCase()}';
  assert(loudify('hello') == 'HELLO');
}

匿名函数

大多数方法都是有名字的，比如 main()或printElement()。你可以创建一个没有名字的方法，称之为匿名函数，或Lambda表达式或Closure闭包 你可以将匿名方法赋值给一个变量然后使用它，比如将该变量添加到集合或从中删除

匿名方法看起来与命名方法类似,以下是语法

• 在括号之间可以定义参数，参数之间用逗号分割
• 后面大括号中的内容则为函数体：

([[类型] 参数[, …]]) { 
  函数体; 
}; 

下面代码定义了只有一个参数 item且没有参数类型的匿名方法。List 中的每个元素都会调用这个函数，打印元素位置和值的字符串：

void main() {
  List<String> list = ['apples', 'bananas', 'oranges'];
  list.forEach((item) => print('${list.indexOf(item)}: $item'));
}

如果函数体内只有一行语句，你可以使用胖箭头缩写法

void main() {
  List<String> list = ['apples', 'bananas', 'oranges'];
  list.forEach((item) => print('${list.indexOf(item)}: $item'));
}

词法作用域

Dart 是词法有作用域语言，变量的作用域在写代码的时候就确定了，大括号内定义的变量只能在大括号内访问，与 Java 和TS的let const类似

下面是一个嵌套函数中变量在多个作用域中的示例：

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] 添加到该函数参数的函数。Returns a function that adds [addBy] to the
// Function makeAdder(num addBy) {
//   return (num i) => addBy + i;
// }

Function makeAdder(num addBy) =>  (num i) => addBy + i;

void main() {
  // 生成加 2 的函数。
  var add2 = makeAdder(2);
  print(add2(3) == 5);

  // 生成加 4 的函数。
  var add4 = makeAdder(4);
  print(add4(3) == 7);
}

测试函数是否相等

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

void foo() {} // 定义顶层函数 (A top-level function)

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

void main() {
  var 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;

  // 这两个闭包引用了相同的实例对象，因此它们相等。
  assert(y.baz == x);

  // 这两个闭包引用了不同的实例对象，因此它们不相等。
  assert(v.baz != w.baz);
}

返回值

所有的函数都有返回值。没有显示返回语句的函数最后一行默认为执行 return null;

foo() {}
assert(foo() == null);

对比python

class Kim(object):
	def __init__(self, age =10 , *args, **kwargs):
			self.age = age
			self.args = args
			self.kwargs = kwargs

	@staticmethod
	def methods(name = "张三"):
			return name


def main():
	kim = Kim(1, 2, 3, 4, 5, 6, a='7', c='b')
	print(kim.args, kim.kwargs) #(2, 3, 4, 5, 6) {'a': '7', 'c': 'b'}
	print(kim.methods())



if __name__ == '__main__':
	main()