基本写法

Dart 是一个真正的面向对象语言，方法也是对象并且具有一种 类型， Function。 这意味着，方法可以赋值给变量，也可以当做其他方法的参数。 也可以把 Dart 类的实例当做方法来调用。

下面是定义方法的示例：

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

对于只有一个表达式的方法，你可以选择 使用缩写语法来定义：

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

这个 => _expr_ 语法是 { return _expr_; } 形式的缩写。=> 形式 有时候也称之为 胖箭头 语法。

方法可以有两种类型的参数：必需的和可选的。 必需的参数在参数列表前面， 后面是可选参数。

可选参数

可选参数可以是命名参数或者基于位置的参数，但是这两种参数不能同时当做可选参数。

可选命名参数

调用方法的时候，你可以使用这种形式 _paramName_: _value_ 来指定命名参数。例如：

  1. enableFlags(bold: true, hidden: false);

在定义方法的时候，使用 {_param1_, _param2_, …} 的形式来指定命名参数：

  1. /// Sets the [bold] and [hidden] flags to the values
  2. /// you specify.
  3. enableFlags({bool bold, bool hidden}) {
  4.   // ...
  5. }

可选位置参数

把一些方法的参数放到 [] 中就变成可选 位置参数了：

  1. String say(String from, String msg, [String device]) {
  2.   var result = '$from says $msg';
  3.   if (device != null) {
  4.     result = '$result with a $device';
  5.   }
  6.   return result;
  7. }

下面是不使用可选参数调用上面方法 的示例：

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

下面是使用可选参数调用上面方法的示例：

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

默认参数值

在定义方法的时候，可以使用 = 来定义可选参数的默认值。 默认值只能是编译时常量。 如果没有提供默认值，则默认值为 null。

下面是设置可选参数默认值的示例：

  1. /// Sets the [bold] and [hidden] flags to the values you
  2. /// specify, defaulting to false.
  3. void enableFlags({bool bold = false, bool hidden = false}) {
  4.   // ...
  5. }
  6. // bold will be true; hidden will be false.
  7. enableFlags(bold: true);

版本问题： 就版本代码可能需要使用一个冒号 (:) 而不是 = 来设置参数默认值。 原因在于 Dart SDK 1.21 之前的版本，命名参数只支持 :。 : 设置命名默认参数值在以后版本中将不能使用， 所以我们推荐你 使用 = 来设置默认值， 并指定 Dart SDK 版本为 1.21 或者更高的版本。

还可以使用 list 或者 map 作为默认值。 下面的示例定义了一个方法 doStuff()， 并分别为 list 和 gifts 参数指定了 默认值。

  1. void doStuff(
  2.     {List<int> list = const [1, 2, 3],
  3.     Map<String, String> gifts = const {
  4.       'first': 'paper',
  5.       'second': 'cotton',
  6.       'third': 'leather'
  7.     }}) {
  8.   print('list:  $list');
  9.   print('gifts: $gifts');
  10. }

入口函数

每个应用都需要有个顶级的 main() 入口方法才能执行。 main() 方法的返回值为 void 并且有个可选的 List<String> 参数。

下面是一个命令行应用的 main() 方法，并且使用了方法参数作为输入参数：

  1. // Run the app like this: dart args.dart 1 test
  2. void main(List<String> arguments) {
  3.   print(arguments);
  4.   assert(arguments.length == 2);
  5.   assert(int.parse(arguments[0]) == 1);
  6.   assert(arguments[1] == 'test');
  7. }

一等方法对象

可以把方法当做参数调用另外一个方法。例如：

  1. printElement(element) {
  2.   print(element);
  3. }
  4. var list = [1, 2, 3];
  5. // Pass printElement as a parameter
  6. list.forEach(printElement);

方法也可以赋值给一个变量：

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

匿名方法

大部分方法都带有名字，例如 main() 或者 printElement()。 你有可以创建没有名字的方法，称之为 匿名方法，有时候也被称为 lambda 或者 closure 闭包。 你可以把匿名方法赋值给一个变量， 然后你可以使用这个方法，比如添加到集合或者从集合中删除。

  1. var list = ['apples', 'oranges', 'grapes', 'bananas', 'plums'];
  2. list.forEach((i) {
  3.   print(list.indexOf(i).toString() + ': ' + i);
  4. });

静态作用域

Dart 是静态作用域语言，变量的作用域在写代码的时候就确定过了。 基本上大括号里面定义的变量就 只能在大括号里面访问，和 Java 作用域 类似。

词法闭包

一个 闭包 是一个方法对象，不管该对象在何处被调用， 该对象都可以访问其作用域内 的变量。
方法可以封闭定义到其作用域内的变量。 

  1. /// Returns a function that adds [addBy] to the
  2. /// function's argument.
  3. Function makeAdder(num addBy) {
  4.   return (num i) => addBy + i;
  5. }
  7. main() {
  8.   // Create a function that adds 2.
  9.   var add2 = makeAdder(2);
  10.   // Create a function that adds 4.
  11.   var add4 = makeAdder(4);
  12.   assert(add2(3) == 5);
  13.   assert(add4(3) == 7);
  14. }

测试函数是否相等

  1. foo() {}               // A top-level function
  3. class A {
  4.   static void bar() {} // A static method
  5.   void baz() {}        // An instance method
  6. }
  8. main() {
  9.   var x;
  11.   // Comparing top-level functions.
  12.   x = foo;
  13.   assert(foo == x);
  15.   // Comparing static methods.
  16.   x = A.bar;
  17.   assert(A.bar == x);
  19.   // Comparing instance methods.
  20.   var v = new A(); // Instance #1 of A
  21.   var w = new A(); // Instance #2 of A
  22.   var y = w;
  23.   x = w.baz;
  25.   // These closures refer to the same instance (#2),
  26.   // so they're equal.
  27.   assert(y.baz == x);
  29.   // These closures refer to different instances,
  30.   // so they're unequal.
  31.   assert(v.baz != w.baz);
  32. }

返回值

所有的函数都返回一个值。如果没有指定返回值，则 默认把语句 return null; 作为函数的最后一个语句执行。

参考

【1】Dart 中文网